Sulley
/
ComptaClub
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Minor improvement and refactoring.

This commit is contained in:
Trullemans Gregory 2020-02-18 22:38:02 +01:00
parent 3d6efb2fc1
commit 2c010a1e03
4 changed files with 166 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
src/comptabilite/compta_tools.py
View File

@ -10,12 +10,28 @@ from .models import (
RightEngagementType, RightEngagementType,
RightEngagement, RightEngagement,
) )
from .utils import zero_or_value as zov
def get_transaction_and_sum_ooo(year, param): def get_transaction_and_sum_for_year_and_type(year, transaction_type_id):
"""
La fonction va chercher toutes les transactions qui correspondent à une date et un type de
transaction (recette ou dépense), ensuite elle fait la somme des trois champs `BkAmount`,
`BxAmount` et `TotalAmount`.
Args:
year (int): année
transaction_type_id (int): type de transaction
Returns:
lines (list): liste des transactions
sum_BkAmount (decimal): total du compte en banque
sum_BxAmount (decimal): total de la caisse
sum_TotalAmount (decimal): total du total
"""
lines = ( lines = (
Transaction.objects.filter(registrationDate__year=year) Transaction.objects.filter(registrationDate__year=year)
.filter(transaction_type__transaction_type=param) .filter(transaction_type__transaction_type=transaction_type_id)
.order_by("registrationDate") .order_by("registrationDate")
) )
sum_BkAmount = 0 sum_BkAmount = 0
@ -23,9 +39,9 @@ def get_transaction_and_sum_ooo(year, param):
sum_TotalAmount = 0 sum_TotalAmount = 0
for line in lines: for line in lines:
sum_BkAmount = sum_BkAmount + line.bkAmount sum_BkAmount += line.bkAmount
sum_BxAmount = sum_BxAmount + line.bxAmount sum_BxAmount += line.bxAmount
sum_TotalAmount = sum_TotalAmount + line.totalAmount sum_TotalAmount += line.totalAmount
return { return {
"lines": lines, "lines": lines,
@ -35,25 +51,19 @@ def get_transaction_and_sum_ooo(year, param):
} }
def get_transaction_and_sum_sxs(year, param): def get_TotalAmount_Sum_Value(year, transaction_type):
""" """
On va chercher tous les types de transactions qui existent. La fonction additionne le montant total de toutes les transactions correspondant à une année et
à un type passées en paramatre.
Ensuite, pour chacun d'eux, on va sélectionner toutes les transactions appartenant à ce Args:
type de transactions et qui sont `effectuées` et `non simulées` ; et on additionne le year (int): année
montant total de la transaction. transaction_type (id): type de transaction
Returns:
(int): somme totale
""" """
return zov(list(
i = 0
transaction_sum = []
transaction_type_list = TransactionType.objects.filter(
transaction_type=param, parent=None
).order_by("order")
for transaction_type in transaction_type_list:
j = 0
sum_value = list(
Transaction.objects.filter( Transaction.objects.filter(
registrationDate__year=year, registrationDate__year=year,
transaction_type=transaction_type, transaction_type=transaction_type,
@ -62,11 +72,38 @@ def get_transaction_and_sum_sxs(year, param):
) )
.aggregate(Sum("totalAmount")) .aggregate(Sum("totalAmount"))
.values() .values()
)[0] )[0])
def get_transaction_and_sum_sxs(year, transaction_type_id):
"""
La fonction va chercher tous les types de transactions qui existent. Ensuite, pour chacun d'eux
elle va sélectionner toutes les transactions qui sont `effectuées` et `non simulées`
appartenant à ce type de transactions ; et va ensuite additionner les montants totaux du type
de transaction.
Args:
year (int): année
transaction_type_id (int): type de transaction
Returns:
(int): somme totale
"""
i = 0
transaction_sum = []
transaction_type_list = TransactionType.objects.filter(
transaction_type=transaction_type_id, parent=None
).order_by("order")
for transaction_type in transaction_type_list:
j = 0
sum_value = get_TotalAmount_Sum_Value(year, transaction_type)
transaction_sum.append( transaction_sum.append(
[ [
# le label de mon `type de transaction` # le label du `type de transaction`
transaction_type.label, transaction_type.label,
# la catégorie du type de transaction (e.g. Machandise, Service, Cotisation, …) # la catégorie du type de transaction (e.g. Machandise, Service, Cotisation, …)
transaction_type.category, transaction_type.category,
@ -77,25 +114,13 @@ def get_transaction_and_sum_sxs(year, param):
] ]
) )
# print(transaction_sum[-1][4])
# Cela affiche ce qu'il faut, dans l'ordre ou il faut. L'information est donc présente ici.
# print(str(transaction_sum.count()) + ' : ' + transaction_sum[-1][4])
transaction_subtype = TransactionType.objects.filter( transaction_subtype = TransactionType.objects.filter(
parent=transaction_type parent=transaction_type
).order_by("order") ).order_by("order")
for subtype in transaction_subtype: for subtype in transaction_subtype:
subtype_sum_value = list( subtype_sum_value = get_TotalAmount_Sum_Value(year, subtype)
Transaction.objects.filter(
registrationDate__year=year,
transaction_type=subtype,
is_simulated=False,
is_done=True,
)
.aggregate(Sum("totalAmount"))
.values()
)[0]
transaction_sum.append( transaction_sum.append(
[ [
subtype.label, subtype.label,
@ -110,11 +135,7 @@ def get_transaction_and_sum_sxs(year, param):
transaction_sum[i][3] += subtype_sum_value transaction_sum[i][3] += subtype_sum_value
j += 1 j += 1
i = i + j + 1 i += j + 1
# print('______________________________________________')
# for transaction_line in transaction_sum:
# print(transaction_line) # ICI L'INFORMATION N'EST ***PLUS*** PRESENTE !!!
total_transaction = 0 total_transaction = 0
for depense in transaction_sum: for depense in transaction_sum:
@ -124,86 +145,93 @@ def get_transaction_and_sum_sxs(year, param):
return {"sum": transaction_sum, "total": total_transaction} return {"sum": transaction_sum, "total": total_transaction}
def get_transaction_and_sum_spf(year, param): def get_transaction_and_sum_for_spf_export(year, transaction_type_id):
""" """
La fonction va chercher tous les types de transactions sans parents qui existent pour une année
et un type passés en paramètre. Ensuite, pour chacun d'eux elle va sélectionner toutes les
transactions qui sont `effectuées` et `non simulées` appartenant à ce type de transactions et
va ensuite additionner les montants totaux du type de transaction.
Args:
year (int): année
transaction_type_id (int): type de transaction
Returns:
(int): somme totale
""" """
transaction_sum = [] transaction_type_info = []
transaction_type_list = TransactionType.objects.filter( transaction_type_list = TransactionType.objects.filter(
transaction_type=param, parent=None transaction_type=transaction_type_id, parent=None
).order_by("order") ).order_by("order")
for transaction_type in transaction_type_list: for transaction_type in transaction_type_list:
sum_value = 0
# Somme du père # Somme du père
tmp = list( sum_value = get_TotalAmount_Sum_Value(year, transaction_type)
Transaction.objects.filter(
registrationDate__year=year,
transaction_type=transaction_type,
is_simulated=False,
is_done=True,
)
.aggregate(Sum("totalAmount"))
.values()
)[0]
if tmp is not None:
sum_value = tmp
# Selection des fils # Selection des fils
compta_subtype_list = TransactionType.objects.filter( sum_value += zov(list(
parent=transaction_type
).order_by("order")
for subtype in compta_subtype_list:
# Somme des fils
# , is_done = False, is_simulated = False ??
tmp = list(
Transaction.objects.filter( Transaction.objects.filter(
registrationDate__year=year, registrationDate__year=year,
transaction_type=subtype, transaction_type__parent=transaction_type,
is_simulated=False, is_simulated=False,
is_done=True, is_done=True,
) )
.aggregate(Sum("totalAmount")) .aggregate(Sum("totalAmount"))
.values() .values()
)[0] )[0])
# transaction_subtype = TransactionType.objects.filter(
# parent=transaction_type
# ).order_by("order")
# for subtype in transaction_subtype:
# # Somme des fils
# sum_value += get_TotalAmount_Sum_Value(year, subtype)
if tmp is not None: transaction_type_info.append(
sum_value += tmp
transaction_sum.append(
[ [
# le label du `type de transaction`
transaction_type.label, transaction_type.label,
sum_value if sum_value is not None else Decimal(0.00), # somme totale pour le type de transaction
sum_value if sum_value != 0 else Decimal(0.00),
# catégorie de la transaction
transaction_type.category, transaction_type.category,
] ]
) )
total_transaction = 0 sum_total_transaction = 0
for transaction in transaction_sum: for transaction_type in transaction_type_info:
if transaction[1] is not None: # if transaction[1] is not None:
total_transaction += transaction[1] sum_total_transaction += transaction_type[1]
# print(transaction_sum) return {"sum": transaction_type_info, "sum_total_transaction": sum_total_transaction}
return {"sum": transaction_sum, "total": total_transaction}
def get_right_engagement_and_sump_spf(year, category): def get_right_engagement_and_sump_spf(year, category):
""" """
Va chercher tous les types de droits et d'engagements. Pour chacun de ces types, va chercher La fonction va chercher tous les types de droits et d'engagements. Pour chacun de ces types,
l'ensemble lignes correspondantes et sommes les montants. elle va chercher l'ensemble lignes correspondantes et additionne les montants.
Args:
year (int): année
category (int): ???
Returns:
(int): somme totale
""" """
line_sum = [] line_sum = []
right_engagement_list = RightEngagementType.objects.filter( right_engagement_list = RightEngagementType.objects.filter(
category=category category=category
).order_by("order") ).order_by("order")
for line in right_engagement_list:
for right_engagement in right_engagement_list:
tmp = list( tmp = list(
RightEngagement.objects.filter(registrationDate__year=year, r_e_type=line) RightEngagement.objects.filter(registrationDate__year=year, r_e_type=right_engagement)
.aggregate(Sum("amount")) .aggregate(Sum("amount"))
.values() .values()
)[0] )[0]
line_sum.append([line.label, tmp if tmp is not None else Decimal(0.00)]) line_sum.append([right_engagement.label, tmp if tmp is not None else Decimal(0.00)])
return line_sum return line_sum
@ -211,20 +239,26 @@ def get_asset_liability_and_sump_spf(year, category):
""" """
Va chercher tous les types de droits et dettes. Pour chacun de ces types, va chercher Va chercher tous les types de droits et dettes. Pour chacun de ces types, va chercher
l'ensemble lignes correspondantes et sommes les montants. l'ensemble lignes correspondantes et sommes les montants.
Args:
year (int): année
category (int): ???
Returns:
(int): somme totale
""" """
line_sum = [] line_sum = []
asset_liability_list = PatrimonyType.objects.filter(category=category).order_by( asset_liability_list = PatrimonyType.objects.filter(category=category).order_by(
"order" "order"
) )
# print(asset_liability_list)
for line in asset_liability_list: for line in asset_liability_list:
# print(line)
tmp = list( tmp = list(
Patrimony.objects.filter(registrationDate__year=year, patrimony_type=line) Patrimony.objects.filter(registrationDate__year=year, patrimony_type=line)
.aggregate(Sum("totalAmount")) .aggregate(Sum("totalAmount"))
.values() .values()
)[0] )[0]
line_sum.append([line.label, tmp if tmp is not None else Decimal(0.00)]) line_sum.append([line.label, tmp if tmp is not None else Decimal(0.00)])
# print(line_sum)
return line_sum return line_sum

5
src/comptabilite/management/commands/importcsv.py
View File

@ -53,6 +53,9 @@ class Command(BaseCommand):
# records_added += 1 # records_added += 1
if options["bank"] == "crelan" or options["bank"] == "keytrade": if options["bank"] == "crelan" or options["bank"] == "keytrade":
import_csv_transaction(options["file"], options["bank"]) records_added, error_list = import_csv_transaction(options["file"], options["bank"])
print("%s transactions ont été importées" % records_added)
for error in error_list:
print(error)
else: else:
print("Format non supporté…") print("Format non supporté…")

26
src/comptabilite/models.py
View File

@ -138,7 +138,9 @@ class ComplementaryInformations(models.Model):
class TransactionType(models.Model): class TransactionType(models.Model):
""" Type de comptabilité """ """
Représente les types de transaction possible.
"""
class Meta: class Meta:
verbose_name = "Type de transaction" verbose_name = "Type de transaction"
@ -147,12 +149,12 @@ class TransactionType(models.Model):
"label", "label",
] ]
COMPTA_CHOICE = ( TRANSACTION_TYPE_CHOICE = (
(0, "Dépense"), (0, "Dépense"),
(1, "Recette"), (1, "Recette"),
) )
LINE_CHOICE = ( TRANSACTION_SUBTYPE_CHOICE = (
(0, "Autre"), # pour les deux (0, "Autre"), # pour les deux
(1, "Marchandise & Service"), # dépense (1, "Marchandise & Service"), # dépense
(2, "Rémunérations"), # dépense (2, "Rémunérations"), # dépense
@ -164,8 +166,8 @@ class TransactionType(models.Model):
order = models.IntegerField() order = models.IntegerField()
label = models.CharField(max_length=255) label = models.CharField(max_length=255)
category = models.IntegerField(choices=LINE_CHOICE) category = models.IntegerField(choices=TRANSACTION_SUBTYPE_CHOICE)
transaction_type = models.IntegerField(choices=COMPTA_CHOICE) transaction_type = models.IntegerField(choices=TRANSACTION_TYPE_CHOICE)
parent = models.ForeignKey("self", null=True, blank=True, on_delete=models.SET_NULL) parent = models.ForeignKey("self", null=True, blank=True, on_delete=models.SET_NULL)
def __str__(self): def __str__(self):
@ -225,7 +227,7 @@ class Transaction(Comptability):
self.totalAmount = zov(self.bkAmount) + zov(self.bxAmount) self.totalAmount = zov(self.bkAmount) + zov(self.bxAmount)
def __compute_amount(self): def __compute_amount(self):
""" Calculte le montant de la transaction s'il n'est pas déjà fourni. """ """Calcule le montant de la transaction s'il n'est pas déjà fourni. """
if self.amount is None: if self.amount is None:
self.amount = self.totalAmount self.amount = self.totalAmount
@ -251,12 +253,12 @@ class PatrimonyType(models.Model):
verbose_name = "Type de patrimoine" verbose_name = "Type de patrimoine"
verbose_name_plural = "Types de patrimoine" verbose_name_plural = "Types de patrimoine"
Patrimony_CHOICE = ( PATRIMONY_CHOICE = (
(0, "Avoirs"), (0, "Avoirs"),
(1, "Dettes"), (1, "Dettes"),
) )
Patrimony_TYPE_CHOICE = ( PATRIMONY_TYPE_CHOICE = (
(0, "Immeubles (terrain, …)"), (0, "Immeubles (terrain, …)"),
(1, "Machines"), (1, "Machines"),
(2, "Mobilier et matériel roulant"), (2, "Mobilier et matériel roulant"),
@ -274,8 +276,8 @@ class PatrimonyType(models.Model):
order = models.IntegerField(verbose_name="Ordre") order = models.IntegerField(verbose_name="Ordre")
label = models.CharField(max_length=255) label = models.CharField(max_length=255)
category = models.IntegerField(choices=Patrimony_CHOICE, verbose_name="Catégorie") category = models.IntegerField(choices=PATRIMONY_CHOICE, verbose_name="Catégorie")
ptype = models.IntegerField(choices=Patrimony_TYPE_CHOICE, verbose_name="Type") ptype = models.IntegerField(choices=PATRIMONY_TYPE_CHOICE, verbose_name="Type")
def __str__(self): def __str__(self):
return "%s" % (self.label,) return "%s" % (self.label,)
@ -303,7 +305,7 @@ class RightEngagementType(models.Model):
"label", "label",
] ]
RightEngagementType_CHOICE = ( RIGHT_ENGAGEMENT_TYPE_CHOICE = (
(0, "Droit"), (0, "Droit"),
(1, "Engagement"), (1, "Engagement"),
) )
@ -319,7 +321,7 @@ class RightEngagementType(models.Model):
order = models.IntegerField() order = models.IntegerField()
label = models.CharField(max_length=255) label = models.CharField(max_length=255)
category = models.IntegerField(choices=RightEngagementType_CHOICE) category = models.IntegerField(choices=RIGHT_ENGAGEMENT_TYPE_CHOICE)
RightEngagementType_type = models.IntegerField(choices=TYPE_CHOICE) RightEngagementType_type = models.IntegerField(choices=TYPE_CHOICE)
def __str__(self): def __str__(self):

50
src/comptabilite/views.py
View File

@ -21,9 +21,9 @@ from .models import (
) )
from .compta_tools import ( from .compta_tools import (
get_transaction_and_sum_ooo, get_transaction_and_sum_for_year_and_type,
get_transaction_and_sum_sxs, get_transaction_and_sum_sxs,
get_transaction_and_sum_spf, get_transaction_and_sum_for_spf_export,
get_right_engagement_and_sump_spf, get_right_engagement_and_sump_spf,
get_asset_liability_and_sump_spf, get_asset_liability_and_sump_spf,
) )
@ -34,7 +34,8 @@ import locale
def comptability_export(request, year, export_type): def comptability_export(request, year, export_type):
"""Définit une fonction d'export. """
Définit une fonction d'export.
Args: Args:
request: La requête HTTP request: La requête HTTP
@ -53,10 +54,10 @@ def comptability_export(request, year, export_type):
def export_year_ooo(request, year): def export_year_ooo(request, year):
""" """
Affichage et calcul des Recettes et Dépenses pour une année donnée dans deux tableaux l'un au Affichage et calcul des Recettes et Dépenses pour une année donnée dans deux tableaux l'un au
dessus de l'autre. dessus de l'autre (one over other).
""" """
compta_depenses = get_transaction_and_sum_ooo(year, param=0) compta_depenses = get_transaction_and_sum_for_year_and_type(year, 0)
compta_recettes = get_transaction_and_sum_ooo(year, param=1) compta_recettes = get_transaction_and_sum_for_year_and_type(year, 1)
context = { context = {
"compta_depenses": compta_depenses, "compta_depenses": compta_depenses,
"year": year, "year": year,
@ -71,19 +72,16 @@ def export_year_sxs(request, year):
Calcule et affiche la comptabilité d'une année passée en parametre dans un unique tableau (side Calcule et affiche la comptabilité d'une année passée en parametre dans un unique tableau (side
by side). by side).
""" """
tmp_compta_depenses = get_transaction_and_sum_sxs(year, param=0) tmp_compta_depenses = get_transaction_and_sum_sxs(year, 0)
tmp_compta_recettes = get_transaction_and_sum_sxs(year, param=1) tmp_compta_recettes = get_transaction_and_sum_sxs(year, 1)
# for line in tmp_compta_recettes['sum']:
# print(line)
list_sum = zip_longest(tmp_compta_recettes["sum"], tmp_compta_depenses["sum"]) list_sum = zip_longest(tmp_compta_recettes["sum"], tmp_compta_depenses["sum"])
context = { context = {
"list_sum": list_sum, "list_sum": list_sum,
"year": year, "year": year,
"total_depense": tmp_compta_depenses["total"], "total_depense": tmp_compta_depenses["sum_total_transaction"],
"total_recette": tmp_compta_recettes["total"], "total_recette": tmp_compta_recettes["sum_total_transaction"],
} }
return render(request, "year_transaction_export_sxs.html", context) return render(request, "year_transaction_export_sxs.html", context)
@ -101,8 +99,8 @@ def export_year_spf_finance(request, year):
# print(annuality[0].opening_balance) # print(annuality[0].opening_balance)
tmp_compta_depenses = get_transaction_and_sum_spf(year, param=0) tmp_compta_depenses = get_transaction_and_sum_for_spf_export(year, 0)
tmp_compta_recettes = get_transaction_and_sum_spf(year, param=1) tmp_compta_recettes = get_transaction_and_sum_for_spf_export(year, 1)
list_sum = [ list_sum = [
x for x in zip_longest(tmp_compta_recettes["sum"], tmp_compta_depenses["sum"]) x for x in zip_longest(tmp_compta_recettes["sum"], tmp_compta_depenses["sum"])
] ]
@ -125,8 +123,8 @@ def export_year_spf_finance(request, year):
if item[0] == "Liquidité": if item[0] == "Liquidité":
item[1] += ( item[1] += (
annuality[0].opening_balance annuality[0].opening_balance
+ tmp_compta_recettes["total"] + tmp_compta_recettes["sum_total_transaction"]
- tmp_compta_depenses["total"] - tmp_compta_depenses["sum_total_transaction"]
) )
liquidity = item[1] liquidity = item[1]
@ -147,8 +145,8 @@ def export_year_spf_finance(request, year):
context = { context = {
"list_sum": list_sum, "list_sum": list_sum,
"year": year, "year": year,
"total_depense": tmp_compta_depenses["total"], "total_depense": tmp_compta_depenses["sum_total_transaction"],
"total_recette": tmp_compta_recettes["total"], "total_recette": tmp_compta_recettes["sum_total_transaction"],
"rules_list": rules_list, "rules_list": rules_list,
"rules_adaptation_list": rules_adaptation_list, "rules_adaptation_list": rules_adaptation_list,
"complementary_informations": complementary_informations, "complementary_informations": complementary_informations,
@ -269,8 +267,8 @@ class MyDocument(object):
def __display_table_transaction(self, year): def __display_table_transaction(self, year):
self.__display_table_header("DEPENSES", "RECETTES") self.__display_table_header("DEPENSES", "RECETTES")
tmp_compta_depenses = get_transaction_and_sum_spf(year, param=0) tmp_compta_depenses = get_transaction_and_sum_for_spf_export(year, 0)
tmp_compta_recettes = get_transaction_and_sum_spf(year, param=1) tmp_compta_recettes = get_transaction_and_sum_for_spf_export(year, 1)
self.__display_table_transaction_body(tmp_compta_depenses, tmp_compta_recettes) self.__display_table_transaction_body(tmp_compta_depenses, tmp_compta_recettes)
@ -279,7 +277,7 @@ class MyDocument(object):
# totalrecette = self.__display_table_two_column(tmp_compta_recettes, 2) # totalrecette = self.__display_table_two_column(tmp_compta_recettes, 2)
self.__display_table_footer( self.__display_table_footer(
int(tmp_compta_depenses["total"]), int(tmp_compta_recettes["total"]) int(tmp_compta_depenses["sum_total_transaction"]), int(tmp_compta_recettes["sum_total_transaction"])
) )
def __display_table_header(self, title_left, title_right): def __display_table_header(self, title_left, title_right):
@ -431,16 +429,16 @@ class MyDocument(object):
self.drawNewLine(X, "4. Etat du patrimoine") self.drawNewLine(X, "4. Etat du patrimoine")
annuality = Annuality.objects.filter(year__year=year) annuality = Annuality.objects.filter(year__year=year)
tmp_compta_depenses = get_transaction_and_sum_spf(year, param=0) tmp_compta_depenses = get_transaction_and_sum_for_spf_export(year, 0)
tmp_compta_recettes = get_transaction_and_sum_spf(year, param=1) tmp_compta_recettes = get_transaction_and_sum_for_spf_export(year, 1)
assets_list = get_asset_liability_and_sump_spf(year, category=0) assets_list = get_asset_liability_and_sump_spf(year, category=0)
for item in assets_list: for item in assets_list:
if item[0] == "Liquidité": if item[0] == "Liquidité":
item[1] += ( item[1] += (
annuality[0].opening_balance annuality[0].opening_balance
+ tmp_compta_recettes["total"] + tmp_compta_recettes["sum_total_transaction"]
- tmp_compta_depenses["total"] - tmp_compta_depenses["sum_total_transaction"]
) )
liability_list = get_asset_liability_and_sump_spf(year, category=1) liability_list = get_asset_liability_and_sump_spf(year, category=1)