diff --git a/src/comptabilite/compta_tools.py b/src/comptabilite/compta_tools.py index d9b1093..af2fc51 100644 --- a/src/comptabilite/compta_tools.py +++ b/src/comptabilite/compta_tools.py @@ -10,12 +10,28 @@ from .models import ( RightEngagementType, 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 = ( Transaction.objects.filter(registrationDate__year=year) - .filter(transaction_type__transaction_type=param) + .filter(transaction_type__transaction_type=transaction_type_id) .order_by("registrationDate") ) sum_BkAmount = 0 @@ -23,9 +39,9 @@ def get_transaction_and_sum_ooo(year, param): sum_TotalAmount = 0 for line in lines: - sum_BkAmount = sum_BkAmount + line.bkAmount - sum_BxAmount = sum_BxAmount + line.bxAmount - sum_TotalAmount = sum_TotalAmount + line.totalAmount + sum_BkAmount += line.bkAmount + sum_BxAmount += line.bxAmount + sum_TotalAmount += line.totalAmount return { "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 - type de transactions et qui sont `effectuées` et `non simulées` ; et on additionne le - montant total de la transaction. + Args: + year (int): année + transaction_type (id): type de transaction + + Returns: + (int): somme totale """ - - 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( + return zov(list( Transaction.objects.filter( registrationDate__year=year, transaction_type=transaction_type, @@ -62,11 +72,38 @@ def get_transaction_and_sum_sxs(year, param): ) .aggregate(Sum("totalAmount")) .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( [ - # le label de mon `type de transaction` + # le label du `type de transaction` transaction_type.label, # la catégorie du type de transaction (e.g. Machandise, Service, Cotisation, …) 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( parent=transaction_type ).order_by("order") for subtype in transaction_subtype: - subtype_sum_value = list( - Transaction.objects.filter( - registrationDate__year=year, - transaction_type=subtype, - is_simulated=False, - is_done=True, - ) - .aggregate(Sum("totalAmount")) - .values() - )[0] + subtype_sum_value = get_TotalAmount_Sum_Value(year, subtype) + transaction_sum.append( [ subtype.label, @@ -110,11 +135,7 @@ def get_transaction_and_sum_sxs(year, param): transaction_sum[i][3] += subtype_sum_value j += 1 - i = i + j + 1 - - # print('______________________________________________') - # for transaction_line in transaction_sum: - # print(transaction_line) # ICI L'INFORMATION N'EST ***PLUS*** PRESENTE !!! + i += j + 1 total_transaction = 0 for depense in transaction_sum: @@ -124,107 +145,120 @@ def get_transaction_and_sum_sxs(year, param): 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=param, parent=None + transaction_type=transaction_type_id, parent=None ).order_by("order") + for transaction_type in transaction_type_list: - sum_value = 0 # Somme du père - tmp = list( + sum_value = get_TotalAmount_Sum_Value(year, transaction_type) + + # Selection des fils + sum_value += zov(list( Transaction.objects.filter( registrationDate__year=year, - transaction_type=transaction_type, + transaction_type__parent=transaction_type, is_simulated=False, is_done=True, ) .aggregate(Sum("totalAmount")) .values() - )[0] - if tmp is not None: - sum_value = tmp + )[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) - # Selection des fils - compta_subtype_list = TransactionType.objects.filter( - 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( - registrationDate__year=year, - transaction_type=subtype, - is_simulated=False, - is_done=True, - ) - .aggregate(Sum("totalAmount")) - .values() - )[0] - - if tmp is not None: - sum_value += tmp - - transaction_sum.append( + transaction_type_info.append( [ + # le label du `type de transaction` 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, ] ) - total_transaction = 0 - for transaction in transaction_sum: - if transaction[1] is not None: - total_transaction += transaction[1] + sum_total_transaction = 0 + for transaction_type in transaction_type_info: + # if transaction[1] is not None: + sum_total_transaction += transaction_type[1] - # print(transaction_sum) - - return {"sum": transaction_sum, "total": total_transaction} + return {"sum": transaction_type_info, "sum_total_transaction": sum_total_transaction} 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 - l'ensemble lignes correspondantes et sommes les montants. + La fonction va chercher tous les types de droits et d'engagements. Pour chacun de ces types, + elle va chercher l'ensemble lignes correspondantes et additionne les montants. + + Args: + year (int): année + category (int): ??? + + Returns: + (int): somme totale """ line_sum = [] right_engagement_list = RightEngagementType.objects.filter( category=category ).order_by("order") - for line in right_engagement_list: + + for right_engagement in right_engagement_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")) .values() )[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 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. + + Args: + year (int): année + category (int): ??? + + Returns: + (int): somme totale """ line_sum = [] asset_liability_list = PatrimonyType.objects.filter(category=category).order_by( "order" ) - # print(asset_liability_list) + for line in asset_liability_list: - # print(line) tmp = list( Patrimony.objects.filter(registrationDate__year=year, patrimony_type=line) .aggregate(Sum("totalAmount")) .values() )[0] line_sum.append([line.label, tmp if tmp is not None else Decimal(0.00)]) - # print(line_sum) + return line_sum diff --git a/src/comptabilite/management/commands/importcsv.py b/src/comptabilite/management/commands/importcsv.py index 24b0f05..3536913 100644 --- a/src/comptabilite/management/commands/importcsv.py +++ b/src/comptabilite/management/commands/importcsv.py @@ -53,6 +53,9 @@ class Command(BaseCommand): # records_added += 1 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: print("Format non supporté…") diff --git a/src/comptabilite/models.py b/src/comptabilite/models.py index 6086ea4..e237585 100644 --- a/src/comptabilite/models.py +++ b/src/comptabilite/models.py @@ -138,7 +138,9 @@ class ComplementaryInformations(models.Model): class TransactionType(models.Model): - """ Type de comptabilité """ + """ + Représente les types de transaction possible. + """ class Meta: verbose_name = "Type de transaction" @@ -147,12 +149,12 @@ class TransactionType(models.Model): "label", ] - COMPTA_CHOICE = ( + TRANSACTION_TYPE_CHOICE = ( (0, "Dépense"), (1, "Recette"), ) - LINE_CHOICE = ( + TRANSACTION_SUBTYPE_CHOICE = ( (0, "Autre"), # pour les deux (1, "Marchandise & Service"), # dépense (2, "Rémunérations"), # dépense @@ -164,8 +166,8 @@ class TransactionType(models.Model): order = models.IntegerField() label = models.CharField(max_length=255) - category = models.IntegerField(choices=LINE_CHOICE) - transaction_type = models.IntegerField(choices=COMPTA_CHOICE) + category = models.IntegerField(choices=TRANSACTION_SUBTYPE_CHOICE) + transaction_type = models.IntegerField(choices=TRANSACTION_TYPE_CHOICE) parent = models.ForeignKey("self", null=True, blank=True, on_delete=models.SET_NULL) def __str__(self): @@ -225,7 +227,7 @@ class Transaction(Comptability): self.totalAmount = zov(self.bkAmount) + zov(self.bxAmount) 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: self.amount = self.totalAmount @@ -251,12 +253,12 @@ class PatrimonyType(models.Model): verbose_name = "Type de patrimoine" verbose_name_plural = "Types de patrimoine" - Patrimony_CHOICE = ( + PATRIMONY_CHOICE = ( (0, "Avoirs"), (1, "Dettes"), ) - Patrimony_TYPE_CHOICE = ( + PATRIMONY_TYPE_CHOICE = ( (0, "Immeubles (terrain, …)"), (1, "Machines"), (2, "Mobilier et matériel roulant"), @@ -274,8 +276,8 @@ class PatrimonyType(models.Model): order = models.IntegerField(verbose_name="Ordre") label = models.CharField(max_length=255) - category = models.IntegerField(choices=Patrimony_CHOICE, verbose_name="Catégorie") - ptype = models.IntegerField(choices=Patrimony_TYPE_CHOICE, verbose_name="Type") + category = models.IntegerField(choices=PATRIMONY_CHOICE, verbose_name="Catégorie") + ptype = models.IntegerField(choices=PATRIMONY_TYPE_CHOICE, verbose_name="Type") def __str__(self): return "%s" % (self.label,) @@ -303,7 +305,7 @@ class RightEngagementType(models.Model): "label", ] - RightEngagementType_CHOICE = ( + RIGHT_ENGAGEMENT_TYPE_CHOICE = ( (0, "Droit"), (1, "Engagement"), ) @@ -319,7 +321,7 @@ class RightEngagementType(models.Model): order = models.IntegerField() 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) def __str__(self): diff --git a/src/comptabilite/views.py b/src/comptabilite/views.py index 3ad160a..3fe4366 100644 --- a/src/comptabilite/views.py +++ b/src/comptabilite/views.py @@ -21,9 +21,9 @@ from .models 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_spf, + get_transaction_and_sum_for_spf_export, get_right_engagement_and_sump_spf, get_asset_liability_and_sump_spf, ) @@ -34,7 +34,8 @@ import locale def comptability_export(request, year, export_type): - """Définit une fonction d'export. + """ + Définit une fonction d'export. Args: request: La requête HTTP @@ -53,10 +54,10 @@ def comptability_export(request, year, export_type): 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 - dessus de l'autre. + dessus de l'autre (one over other). """ - compta_depenses = get_transaction_and_sum_ooo(year, param=0) - compta_recettes = get_transaction_and_sum_ooo(year, param=1) + compta_depenses = get_transaction_and_sum_for_year_and_type(year, 0) + compta_recettes = get_transaction_and_sum_for_year_and_type(year, 1) context = { "compta_depenses": compta_depenses, "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 by side). """ - tmp_compta_depenses = get_transaction_and_sum_sxs(year, param=0) - tmp_compta_recettes = get_transaction_and_sum_sxs(year, param=1) - - # for line in tmp_compta_recettes['sum']: - # print(line) + tmp_compta_depenses = get_transaction_and_sum_sxs(year, 0) + tmp_compta_recettes = get_transaction_and_sum_sxs(year, 1) list_sum = zip_longest(tmp_compta_recettes["sum"], tmp_compta_depenses["sum"]) context = { "list_sum": list_sum, "year": year, - "total_depense": tmp_compta_depenses["total"], - "total_recette": tmp_compta_recettes["total"], + "total_depense": tmp_compta_depenses["sum_total_transaction"], + "total_recette": tmp_compta_recettes["sum_total_transaction"], } 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) - tmp_compta_depenses = get_transaction_and_sum_spf(year, param=0) - tmp_compta_recettes = get_transaction_and_sum_spf(year, param=1) + tmp_compta_depenses = get_transaction_and_sum_for_spf_export(year, 0) + tmp_compta_recettes = get_transaction_and_sum_for_spf_export(year, 1) list_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é": item[1] += ( annuality[0].opening_balance - + tmp_compta_recettes["total"] - - tmp_compta_depenses["total"] + + tmp_compta_recettes["sum_total_transaction"] + - tmp_compta_depenses["sum_total_transaction"] ) liquidity = item[1] @@ -147,8 +145,8 @@ def export_year_spf_finance(request, year): context = { "list_sum": list_sum, "year": year, - "total_depense": tmp_compta_depenses["total"], - "total_recette": tmp_compta_recettes["total"], + "total_depense": tmp_compta_depenses["sum_total_transaction"], + "total_recette": tmp_compta_recettes["sum_total_transaction"], "rules_list": rules_list, "rules_adaptation_list": rules_adaptation_list, "complementary_informations": complementary_informations, @@ -269,8 +267,8 @@ class MyDocument(object): def __display_table_transaction(self, year): self.__display_table_header("DEPENSES", "RECETTES") - tmp_compta_depenses = get_transaction_and_sum_spf(year, param=0) - tmp_compta_recettes = get_transaction_and_sum_spf(year, param=1) + tmp_compta_depenses = get_transaction_and_sum_for_spf_export(year, 0) + tmp_compta_recettes = get_transaction_and_sum_for_spf_export(year, 1) 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) 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): @@ -431,16 +429,16 @@ class MyDocument(object): self.drawNewLine(X, "4. Etat du patrimoine") annuality = Annuality.objects.filter(year__year=year) - tmp_compta_depenses = get_transaction_and_sum_spf(year, param=0) - tmp_compta_recettes = get_transaction_and_sum_spf(year, param=1) + tmp_compta_depenses = get_transaction_and_sum_for_spf_export(year, 0) + tmp_compta_recettes = get_transaction_and_sum_for_spf_export(year, 1) assets_list = get_asset_liability_and_sump_spf(year, category=0) for item in assets_list: if item[0] == "Liquidité": item[1] += ( annuality[0].opening_balance - + tmp_compta_recettes["total"] - - tmp_compta_depenses["total"] + + tmp_compta_recettes["sum_total_transaction"] + - tmp_compta_depenses["sum_total_transaction"] ) liability_list = get_asset_liability_and_sump_spf(year, category=1)