Minor improvement and refactoring.
This commit is contained in:
parent
3d6efb2fc1
commit
2c010a1e03
|
@ -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,86 +145,93 @@ 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(
|
||||
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
|
||||
sum_value = get_TotalAmount_Sum_Value(year, transaction_type)
|
||||
|
||||
# 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(
|
||||
sum_value += zov(list(
|
||||
Transaction.objects.filter(
|
||||
registrationDate__year=year,
|
||||
transaction_type=subtype,
|
||||
transaction_type__parent=transaction_type,
|
||||
is_simulated=False,
|
||||
is_done=True,
|
||||
)
|
||||
.aggregate(Sum("totalAmount"))
|
||||
.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:
|
||||
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
|
||||
|
||||
|
||||
|
@ -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
|
||||
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
|
||||
|
|
|
@ -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é…")
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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)
|
||||
|
|
Loading…
Reference in New Issue