def generer(self, trans_vals, paramtexte, dossier_destination, par_plate):
"""
génération du fichier des usages de labos à partir des transactions
:param trans_vals: valeurs des transactions générées
:param paramtexte: paramètres textuels
:param dossier_destination: Une instance de la classe dossier.DossierDestination
:param par_plate: tri des transactions par plateforme, par utilisateur, par client, par jour
"""
ii = 0
for id_plate in par_plate.keys():
par_user = par_plate[id_plate]['users']
for id_user in par_user.keys():
par_client = par_user[id_user]
for code in par_client.keys():
par_jour = par_client[code]
for jour in par_jour.keys():
key = par_jour[jour]
trans = trans_vals[key]
date, info = Outils.est_une_date(trans['transac-date'], "la date de transaction")
if info != "":
Outils.affiche_message(info)
donnee = []
for cle in range(2, len(self.cles)):
if self.cles[cle] == 'day':
donnee.append(date.day)
elif self.cles[cle] == 'week-nbr':
donnee.append(date.isocalendar()[1])
else:
donnee.append(trans[self.cles[cle]])
self.ajouter_valeur(donnee, ii)
ii += 1
self.csv(dossier_destination, paramtexte)
def verification_date(self, annee, mois):
"""
vérifie que le mois et l'année présents sur la ligne sont bien ceux espérés
:param annee: année selon paramètres d'édition
:param mois: mois selon paramètres d'édition
:return: 0 si ok, 1 sinon
"""
if self.verifie_date == 1:
print(self.libelle + ": date déjà vérifiée")
return 0
msg = ""
position = 1
for donnee in self.donnees:
try:
if (int(donnee["mois"]) != mois) or (int(donnee["annee"]) != annee):
msg += "date incorrect ligne " + str(position) + "\n"
except ValueError:
msg += "année ou mois n'est pas valable" + str(position) + "\n"
position += 1
del self.donnees[0]
self.verifie_date = 1
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
def generer(self, trans_vals, paramtexte, dossier_destination, par_plate):
"""
génération du fichier de bilan des usages à partir des transactions
:param trans_vals: valeurs des transactions générées
:param paramtexte: paramètres textuels
:param dossier_destination: Une instance de la classe dossier.DossierDestination
:param par_plate: tri des transactions par plateforme, par item
"""
ii = 0
for id_plate in par_plate.keys():
par_item = par_plate[id_plate]['items']
for item in par_item.keys():
tbtr = par_item[item]
base = trans_vals[tbtr[0]]
if base['item-type'] == paramtexte.donnees['item-service']:
donnee = []
for cle in range(2, len(self.cles)-1):
donnee.append(base[self.cles[cle]])
usage = 0
for indice in tbtr:
val, info = Outils.est_un_nombre(trans_vals[indice]['transac-usage'], "l'usage", arrondi=4)
if info != "":
Outils.affiche_message(info)
usage += val
donnee += [round(usage, 4)]
self.ajouter_valeur(donnee, ii)
ii += 1
self.csv(dossier_destination, paramtexte)
def livraisons_pour_projet_par_categorie(self, num_projet, id_compte, code_client, prestations):
"""
retourne les livraisons pour un projet donné, pour une catégorie de prestations donnée
:param num_projet: lenuméro de projet
:param id_compte: l'id du compte
:param code_client: le code du client
:param prestations: prestations importées et vérifiées
:return: les livraisons pour le projet donné, pour une catégorie de prestations donnée
"""
if prestations.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence des prestations avant de pouvvoir sélectionner " \
"les livraisons par catégorie"
print(info)
Outils.affiche_message(info)
return {}
donnees_dico = {}
for donnee in self.donnees:
if (donnee['id_compte'] == id_compte) and (donnee['code_client'] == code_client) \
and (donnee['num_projet'] == num_projet):
categorie = prestations.donnees[donnee['id_prestation']]['categorie']
if categorie not in donnees_dico:
donnees_dico[categorie] = []
liste = donnees_dico[categorie]
liste.append(donnee)
return donnees_dico
def verification_date(self, annee, mois):
"""
vérifie que le mois et l'année présents sur la ligne sont bien ceux espérés
:param annee: année selon paramètres d'édition
:param mois: mois selon paramètres d'édition
:return: 0 si ok, 1 sinon
"""
if self.verifie_date == 1:
print(self.libelle + ": date déjà vérifiée")
return 0
msg = ""
position = 1
for donnee in self.donnees:
try:
if (int(donnee['mois']) != mois) or (int(donnee['annee']) != annee):
msg += "date incorrect ligne " + str(position) + "\n"
except ValueError:
msg += "année ou mois n'est pas valable" + str(position) + "\n"
position += 1
del self.donnees[0]
self.verifie_date = 1
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
def mise_a_jour(edition, clients, dossier_source, dossier_destination, maj, f_html_sections):
"""
modification des résumés mensuels au niveau du client dont la facture est modifiée
:param edition: paramètres d'édition
:param clients: clients importés
:param dossier_source: Une instance de la classe dossier.DossierSource
:param dossier_destination: Une instance de la classe dossier.DossierDestination
:param maj: données modifiées pour le client pour les différents fichiers
:param f_html_sections: section html modifiée pour le client
"""
if len(maj) != len(Resumes.fichiers):
info = "Résumés : erreur taille tableau"
Outils.affiche_message(info)
return
for i in range(len(Resumes.fichiers)):
fichier_complet = Resumes.fichiers[i] + "_" + str(edition.annee) + "_" + \
Outils.mois_string(edition.mois) + ".csv"
donnees_csv = Resumes.ouvrir_csv_sans_client(
dossier_source, fichier_complet, edition.client_unique, Resumes.positions[i])
with dossier_destination.writer(fichier_complet) as fichier_writer:
for ligne in donnees_csv:
fichier_writer.writerow(ligne)
for ligne in maj[i]:
fichier_writer.writerow(ligne)
ticket_complet = "ticket_" + str(edition.annee) + "_" + Outils.mois_string(edition.mois) + ".html"
section = list(f_html_sections.values())[0]
nom_client = clients.donnees[edition.client_unique]['abrev_labo'] + " (" + edition.client_unique + ")"
Resumes.maj_ticket(dossier_source, dossier_destination, ticket_complet, section, edition.client_unique,
nom_client)
def est_coherent(self, comptes_actifs):
"""
vérifie que les données du fichier importé sont cohérentes (code client dans clients,
ou alors absent des clients actifs, id compte unique), et efface les colonnes mois et année
:param comptes_actifs: codes des clients présents dans accès, réservations et livraisons
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
print(info)
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
ids = []
donnees_dict = {}
for donnee in self.donnees:
if donnee['code_client'] == "":
if donnee['id_compte'] in comptes_actifs:
print("code client du compte vide")
msg += "le code client de la ligne " + str(ligne) + " ne peut être vide si le compte est utilisé\n"
continue
if donnee['id_compte'] == "":
msg += "le compte id de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_compte'] not in ids:
ids.append(donnee['id_compte'])
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_compte']] = donnee
else:
msg += "l'id compte '" + donnee['id_compte'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
donnee['seuil'], info = Outils.est_un_nombre(donnee['seuil'], "le seuil", ligne)
if info != "":
print(info)
msg += info
donnee['pourcent'], info = Outils.est_un_nombre(donnee['pourcent'], "le pourcent après seuil", ligne)
if info != "":
print(info)
msg += info
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self, comptes, machines):
"""
vérifie que les données du fichier importé sont cohérentes (id compte parmi comptes,
id machine parmi machines), et efface les colonnes mois et année
:param comptes: comptes importés
:param machines: machines importées
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
print(info)
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
donnees_list = []
for donnee in self.donnees:
if donnee['id_compte'] == "":
msg += "le compte id de la ligne " + str(ligne) + " ne peut être vide\n"
elif comptes.contient_id(donnee['id_compte']) == 0:
msg += "le compte id '" + donnee['id_compte'] + "' de la ligne " + str(ligne) + " n'est pas référencé\n"
elif donnee['code_client'] not in self.comptes:
self.comptes[donnee['code_client']] = [donnee['id_compte']]
elif donnee['id_compte'] not in self.comptes[donnee['code_client']]:
self.comptes[donnee['code_client']].append(donnee['id_compte'])
if donnee['id_machine'] == "":
msg += "le machine id de la ligne " + str(ligne) + " ne peut être vide\n"
elif machines.contient_id(donnee['id_machine']) == 0:
msg += "le machine id '" + donnee['id_machine'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
donnee['duree_hp'], info = Outils.est_un_nombre(donnee['duree_hp'], "la durée réservée HP", ligne)
msg += info
donnee['duree_hc'], info = Outils.est_un_nombre(donnee['duree_hc'], "la durée réservée HC", ligne)
msg += info
donnee['duree_ouvree'], info = Outils.est_un_nombre(donnee['duree_ouvree'], "la durée ouvrée", ligne)
msg += info
del donnee['annee']
del donnee['mois']
donnees_list.append(donnee)
ligne += 1
self.donnees = donnees_list
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
def __init__(self, dossier_source):
"""
initialisation et importation des données
:param dossier_source: Une instance de la classe dossier.DossierSource
"""
self._chemin = dossier_source.chemin
try:
fichier_reader = dossier_source.reader(self.nom_fichier)
donnees_csv = []
for ligne in fichier_reader:
donnees_ligne = self.extraction_ligne(ligne)
if donnees_ligne == -1:
continue
donnees_csv.append(donnees_ligne)
self.donnees = donnees_csv
except IOError as e:
Outils.fatal(
e, "impossible d'ouvrir le fichier : " + self.nom_fichier)
del self.donnees[0]
for donnee in self.donnees:
if donnee['nom'] in self.dossiers_annexes:
donnee['dossier'] = self.dossiers_annexes[donnee['nom']]
else:
info = self.libelle + ": nom non-attendu : " + donnee[
'nom'] + ", pas de nom de dossier "
Outils.affiche_message(info)
sys.exit("Erreur de consistance")
def calcul_montants(self, prestations, coefprests, comptes, clients, verification):
"""
calcule le 'montant' et le 'rabais_r' et les ajoute aux données
:param prestations: prestations importées et vérifiées
:param coefprests: coefficients prestations importés et vérifiés
:param comptes: comptes importés et vérifiés
:param clients: clients importés et vérifiés
:param verification: pour vérifier si les dates et les cohérences sont correctes
"""
if verification.a_verifier != 0:
info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
print(info)
Outils.affiche_message(info)
return
donnees_list = []
for donnee in self.donnees:
prestation = prestations.donnees[donnee['id_prestation']]
compte = comptes.donnees[donnee['id_compte']]
client = clients.donnees[compte['code_client']]
coefprest = coefprests.donnees[client['id_classe_tarif'] + prestation['categorie']]
donnee['prix_unit_client'] = round(prestation['prix_unit'] * coefprest['coefficient'], 2)
donnee['montant'] = round(donnee['quantite'] * donnee['prix_unit_client'], 2)
donnee['rabais_r'] = round(donnee['rabais'], 2)
donnees_list.append(donnee)
self.donnees = donnees_list
def livraisons_pour_compte_par_categorie(self, id_compte, code_client,
prestations):
"""
retourne les livraisons pour un compte donné, pour une catégorie de prestations donnée
:param id_compte: l'id du compte
:param code_client: le code du client
:param prestations: prestations importées et vérifiées
:return: les livraisons pour le projet donné, pour une catégorie de prestations donnée
"""
if prestations.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence des prestations avant de pouvvoir sélectionner " \
"les livraisons par catégorie"
Outils.affiche_message(info)
return {}
donnees_dico = {}
for donnee in self.donnees:
if (donnee['id_compte'] == id_compte) and (donnee['code_client']
== code_client):
categorie = prestations.donnees[
donnee['id_prestation']]['categorie']
if categorie not in donnees_dico:
donnees_dico[categorie] = []
liste = donnees_dico[categorie]
liste.append(donnee)
return donnees_dico
def verification_date(self, annee, mois):
"""
vérifie que le mois et l'année présents sur la ligne sont bien ceux espérés
:param annee: année selon paramètres d'édition
:param mois: mois selon paramètres d'édition
:return: 0 si ok, 1 sinon
"""
if self.verifie_date == 1:
print(self.libelle + ": date déjà vérifiée")
return 0
msg = ""
position = 1
for donnee in self.donnees:
donnee['mois'], info = Outils.est_un_entier(
donnee['mois'], "le mois ", position, 1, 12)
msg += info
donnee['annee'], info = Outils.est_un_entier(
donnee['annee'], "l'annee ", position, 2000, 2099)
msg += info
if donnee['mois'] != mois or donnee['annee'] != annee:
msg += "date incorrect ligne " + str(position) + "\n"
position += 1
del self.donnees[0]
self.verifie_date = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def creer_latex_pdf(nom_fichier, contenu):
"""
création d'un pdf à partir d'un contenu latex
:param nom_fichier: nom du pdf final
:param contenu: contenu latex
"""
with open(nom_fichier + ".tex", 'w') as f:
f.write(contenu)
proc = subprocess.Popen(['pdflatex', nom_fichier + ".tex"])
proc.communicate()
# 2 fois pour que les longtable soient réguliers (courant de relancer latex)
proc = subprocess.Popen(['pdflatex', nom_fichier + ".tex"])
proc.communicate()
try:
os.unlink(nom_fichier + '.tex')
os.unlink(nom_fichier + '.log')
os.unlink(nom_fichier + '.aux')
except OSError as err:
Outils.affiche_message("OSError: {0}".format(err))
except IOError as err:
Outils.affiche_message("IOError: {0}".format(err))
def calcul_montants(self, prestations, coefprests, comptes, clients,
verification):
"""
calcule le 'montant' et le 'rabais_r' et les ajoute aux données
:param prestations: prestations importées et vérifiées
:param coefprests: coefficients prestations importés et vérifiés
:param comptes: comptes importés et vérifiés
:param clients: clients importés et vérifiés
:param verification: pour vérifier si les dates et les cohérences sont correctes
"""
if verification.a_verifier != 0:
info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
print(info)
Outils.affiche_message(info)
return
donnees_list = []
for donnee in self.donnees:
prestation = prestations.donnees[donnee['id_prestation']]
compte = comptes.donnees[donnee['id_compte']]
client = clients.donnees[compte['code_client']]
coefprest = coefprests.donnees[client['id_classe_tarif'] +
prestation['categorie']]
donnee['prix_unit_client'] = round(
prestation['prix_unit'] * coefprest['coefficient'], 2)
donnee['montant'] = round(
donnee['quantite'] * donnee['prix_unit_client'], 2)
donnee['rabais_r'] = round(donnee['rabais'], 2)
donnees_list.append(donnee)
self.donnees = donnees_list
def creer_latex_pdf(nom_fichier, contenu, nom_dossier=""):
"""
création d'un pdf à partir d'un contenu latex
:param nom_fichier: nom du pdf final
:param contenu: contenu latex
:param nom_dossier: nom du dossier dans lequel enregistrer le pdf
"""
with open(nom_fichier + ".tex", 'w') as f:
f.write(contenu)
proc = subprocess.Popen(['pdflatex', nom_fichier + ".tex"])
proc.communicate()
# 2 fois pour que les longtable soient réguliers (courant de relancer latex)
proc = subprocess.Popen(['pdflatex', nom_fichier + ".tex"])
proc.communicate()
os.unlink(nom_fichier + '.tex')
os.unlink(nom_fichier + '.log')
os.unlink(nom_fichier + '.aux')
if nom_dossier != '':
try:
shutil.copy(nom_fichier + ".pdf", nom_dossier)
os.unlink(nom_fichier + '.pdf')
except IOError:
Outils.affiche_message(
"Le pdf " + nom_fichier +
" est resté ouvert et ne sera pas mis à jour")
def verification_date(self):
"""
vérifie que le mois et l'année présents sur la ligne sont bien ceux espérés
:return: 0 si ok, 1 sinon
"""
if self.verifie_date == 1:
print(self.nom + ": date déjà vérifiée")
return 0
msg = ""
position = 1
for donnee in self.donnees:
try:
if int(donnee[self.cles['mois']]) != self.mois or int(donnee[self.cles['année']]) != self.annee:
msg += "date incorrect ligne " + str(position) + "\n"
except ValueError:
msg += "année ou mois n'est pas valable" + str(position) + "\n"
position += 1
self.verifie_date = 1
if msg != "":
msg = "L’année et le mois ne correspondent pas à ceux attendus dans " + self.nom
Outils.affiche_message(msg)
return 1
return 0
def pdfs_pour_client(self, client, type_annexe):
"""
retourne les pdfs à ajouter en fin d'annexe pour le client
:return: pdfs selon position
"""
if self.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les codes"
Outils.affiche_message(info)
return []
pdfs = {}
for donnee in self.donnees:
if donnee['code'] != "" and donnee['code'] != client['code']:
continue
if donnee['nature'] != "" and donnee['nature'] != client['nature']:
continue
if donnee[type_annexe] == 'NON':
continue
if not donnee['position'] in pdfs:
pdfs[donnee['position']] = [{
'chemin': donnee['chemin'],
'nom': donnee['nom']
}]
else:
pdfs[donnee['position']].append({
'chemin': donnee['chemin'],
'nom': donnee['nom']
})
return pdfs
def est_coherent(self, comptes, users):
"""
vérifie que les données du fichier importé sont cohérentes, et efface les colonnes mois et année
:param comptes: comptes importés
:param users: users importés
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
couples = []
donnees_dict = {}
for donnee in self.donnees:
if donnee['id_compte'] == "":
msg += "le compte id de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_compte'] not in comptes.donnees:
msg += "le compte id " + donnee['id_compte'] + " de la ligne " + str(ligne) + \
" n'est pas référencé\n"
if donnee['id_user'] == "":
msg += "le user id de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_user'] not in users.donnees:
msg += "le user id " + donnee['id_user'] + " de la ligne " + str(ligne) + \
" n'est pas référencé\n"
couple = [donnee['id_user'], donnee['id_compte']]
if couple not in couples:
couples.append(couple)
else:
msg += "Couple user id '" + donnee['id_user'] + "' et compte id '" + \
donnee['id_compte'] + "' de la ligne " + str(ligne) + " pas unique\n"
if donnee['debut'] != 'NULL':
donnee['debut'], info = Outils.est_une_date(donnee['debut'], "la date de début", ligne)
msg += info
if donnee['fin'] != 'NULL':
donnee['fin'], info = Outils.est_une_date(donnee['fin'], "la date de fin", ligne)
msg += info
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_user'] + donnee['id_compte']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def somme_par_categorie(self, comptes):
"""
calcule les sommes par catégories sous forme de dictionnaire : client->catégorie->clés_sommes
:param comptes: comptes importés et vérifiés
"""
if self.verification.a_verifier != 0:
info = "Sommes : vous devez faire les vérifications avant de calculer les sommes"
print(info)
Outils.affiche_message(info)
return
if self.sco != 0:
spca = {}
for code_client, spco_cl in self.sommes_comptes.items():
if code_client not in spca:
spca[code_client] = {}
spca_cl = spca[code_client]
for id_compte, spco_co in spco_cl.items():
cat = comptes.donnees[id_compte]['categorie']
if cat not in spca_cl:
spca_cl[cat] = self.nouveau_somme(Sommes.cles_somme_categorie)
somme = spca_cl[cat]
somme['somme_k_ai'] += spco_co['somme_j_ai']
somme['somme_k_bi'] += spco_co['somme_j_bi']
somme['somme_k_ci'] += spco_co['somme_j_ci']
somme['somme_k_oi'] += spco_co['somme_j_oi']
somme['somme_k_mai'] += spco_co['somme_j_mai']
somme['somme_k_moi'] += spco_co['somme_j_moi']
somme['somme_k_dsi'] += spco_co['somme_j_dsi']
somme['somme_k_dhi'] += spco_co['somme_j_dhi']
somme['somme_k_mm'] += spco_co['somme_j_mm']
somme['somme_k_mr'] += spco_co['somme_j_mr']
somme['mk'] += spco_co['mj']
for categorie in self.categories:
somme['sommes_cat_m'][categorie] += spco_co['sommes_cat_m'][categorie]
somme['sommes_cat_r'][categorie] += spco_co['sommes_cat_r'][categorie]
somme['tot_cat'][categorie] += spco_co['tot_cat'][categorie]
# print("")
# print("spca")
# for code in spca:
# if code != "220208":
# continue
# print(code)
# spca_cl = spca[code]
# for cat in spca_cl:
# somme = spca_cl[cat]
# print(" ", cat, somme['somme_k_mai'])
self.sca = 1
self.sommes_categories = spca
else:
info = "Vous devez d'abord faire la somme par compte, avant la somme par catégorie"
print(info)
Outils.affiche_message(info)
def est_coherent(self, subsides, generaux):
"""
vérifie que les données du fichier importé sont cohérentes
:param subsides: subsides importés
:param generaux: paramètres généraux
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
donnees_dict = {}
couples = []
del self.donnees[0]
for donnee in self.donnees:
if donnee['type'] == "":
msg += "le type de la ligne " + str(
ligne) + " ne peut être vide\n"
elif subsides.contient_type(donnee['type']) == 0:
msg += "le type '" + donnee['type'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
if donnee['code_d'] == "":
msg += "la code D de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['code_d'] not in generaux.obtenir_code_d():
msg += "la code D de la ligne " + str(
ligne) + " n'existe pas dans les codes D\n"
couple = [donnee['type'], donnee['code_d']]
if couple not in couples:
couples.append(couple)
else:
msg += "Couple type '" + donnee['type'] + "' et code D '" + \
donnee['code_d'] + "' de la ligne " + str(ligne) + " pas unique\n"
donnee['max_mois'], info = Outils.est_un_nombre(
donnee['max_mois'], "le max mensuel", ligne, 2, 0)
msg += info
donnee['max_compte'], info = Outils.est_un_nombre(
donnee['max_compte'], "le max compte", ligne, 2, 0)
msg += info
donnees_dict[donnee['type'] + donnee['code_d']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def calcul_montants(self, machines, coefmachines, comptes, clients, verification):
"""
calcule les montants 'pv' et 'qv' et les ajoute aux données
:param machines: machines importées et vérifiées
:param coefmachines: coefficients machines importés et vérifiés
:param comptes: comptes importés et vérifiés
:param clients: clients importés et vérifiés
:param verification: pour vérifier si les dates et les cohérences sont correctes
"""
if verification.a_verifier != 0:
info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
print(info)
Outils.affiche_message(info)
return
donnees_list = []
for donnee in self.donnees:
id_compte = donnee['id_compte']
compte = comptes.donnees[id_compte]
code_client = compte['code_client']
id_machine = donnee['id_machine']
machine = machines.donnees[id_machine]
client = clients.donnees[code_client]
coefmachine = coefmachines.donnees[client['id_classe_tarif'] + machine['categorie']]
duree_fact_hp, duree_fact_hc = Rabais.rabais_reservation(machine['delai_sans_frais'],
donnee['duree_ouvree'],
donnee['duree_hp'],
donnee['duree_hc'])
if code_client not in self.sommes:
self.sommes[code_client] = {'comptes': {}, 'machines': {}}
scl = self.sommes[code_client]
if id_compte not in scl['comptes']:
scl['comptes'][id_compte] = {}
sco = scl['comptes'][id_compte]
if id_machine not in sco:
sco[id_machine] = {'res_hp': 0, 'ann_hp': 0,
'res_hc': 0, 'ann_hc': 0}
if donnee['si_supprime'] == 'OUI':
sco[id_machine]['ann_hp'] += duree_fact_hp
sco[id_machine]['ann_hc'] += duree_fact_hc
else:
sco[id_machine]['res_hp'] += duree_fact_hp
sco[id_machine]['res_hc'] += duree_fact_hc
if id_machine not in scl['machines']:
pu_hp = round(coefmachine['coef_r'] * machine['t_h_reservation_hp'], 2)
pu_hc = round(coefmachine['coef_r'] * machine['t_h_reservation_hc'], 2)
scl['machines'][id_machine] = {'pu_hp': pu_hp, 'pu_hc': pu_hc}
donnee['duree_fact_hp'] = duree_fact_hp
donnee['duree_fact_hc'] = duree_fact_hc
donnees_list.append(donnee)
self.donnees = donnees_list
def verification_coherence(self, generaux, edition, acces, clients,
emoluments, coefprests, comptes, users,
livraisons, machines, prestations, reservations,
categories, categprix, docpdf):
"""
vérifie la cohérence des données importées
:param generaux: paramètres généraux
:param edition: paramètres d'édition
:param acces: accès importés
:param clients: clients importés
:param emoluments: émoluments importés
:param coefprests: coefficients prestations importés
:param comptes: comptes importés
:param users: users importés
:param livraisons: livraisons importées
:param machines: machines importées
:param prestations: prestations importées
:param reservations: réservations importées
:param categories: catégories importées
:param categprix: catégories prix importées
:param docpdf: paramètres d'ajout de document pdf
:return: 0 si ok, sinon le nombre d'échecs à la vérification
"""
verif = 0
verif += acces.est_coherent(comptes, machines, users)
verif += livraisons.est_coherent(comptes, prestations, users)
verif += categories.est_coherent()
verif += users.est_coherent()
verif += machines.est_coherent(categories)
verif += prestations.est_coherent(generaux, coefprests)
verif += emoluments.est_coherent(generaux)
verif += categprix.est_coherent(generaux, categories)
verif += coefprests.est_coherent(generaux)
verif += clients.est_coherent(emoluments, generaux)
verif += reservations.est_coherent(comptes, machines, users)
verif += docpdf.est_coherent(generaux, clients)
verif += comptes.est_coherent(clients, generaux)
if verif > 0:
return verif
comptes_actifs = Verification.obtenir_comptes_actifs(acces, livraisons)
clients_actifs = Verification.obtenir_clients_actifs(
comptes_actifs, comptes)
if edition.version > 0 and len(clients_actifs) > 0:
if len(clients_actifs) > 1:
Outils.affiche_message(
"Si version différente de 0, un seul client autorisé")
sys.exit("Trop de clients pour version > 0")
if edition.client_unique != clients_actifs[0]:
Outils.affiche_message(
"Le client unique des paramètres d'édition n'est pas le même que celui présent dans "
"les transactions")
sys.exit("clients non-correspondants pour version > 0")
self.a_verifier = 0
return verif
def creation_annexes(sommes, clients, edition, livraisons, acces, machines, reservations, prestations, comptes,
dossier_annexe, plateforme, prefixe, coefprests, coefmachines, generaux, garde):
"""
création des annexes techniques
:param sommes: sommes calculées
:param clients: clients importés
:param edition: paramètres d'édition
:param livraisons: livraisons importées
:param acces: accès importés
:param machines: machines importées
:param reservations: réservations importées
:param prestations: prestations importées
:param comptes: comptes importés
:param dossier_annexe: nom du dossier dans lequel enregistrer les annexes
:param plateforme: OS utilisé
:param prefixe: prefixe de nom des annexes
:param coefprests: coefficients prestations importés
:param coefmachines: coefficients machines importés
:param generaux: paramètres généraux
:param garde: titre page de garde
"""
if sommes.calculees == 0:
info = "Vous devez d'abord faire toutes les sommes avant de pouvoir créer les annexes"
print(info)
Outils.affiche_message(info)
return
for code_client in sommes.sommes_clients.keys():
contenu = Latex.entete(plateforme)
contenu += r'''\usepackage[margin=10mm, includefoot]{geometry}
\usepackage{multirow}
\usepackage{longtable}
\usepackage{dcolumn}
\usepackage{changepage}
\usepackage[scriptsize]{caption}
\begin{document}
\renewcommand{\arraystretch}{1.5}
'''
contenu += r'''
\vspace*{8cm}
\begin{adjustwidth}{5cm}{}
\Large\textsc{''' + garde + r'''}\newline\newline'''
nom = Latex.echappe_caracteres(clients.donnees[code_client]['abrev_labo'])
code_sap = clients.donnees[code_client]['code_sap']
contenu += code_client + " - " + code_sap + " - " + nom + r'''\newpage
\end{adjustwidth}'''
contenu += Annexes.contenu_client(sommes, clients, code_client, edition, livraisons, acces, machines,
reservations, prestations, comptes, coefprests, coefmachines, generaux)
contenu += r'''\end{document}'''
nom = prefixe + str(edition.annee) + "_" + Outils.mois_string(edition.mois) + "_" + \
str(edition.version) + "_" + code_client
Latex.creer_latex_pdf(nom, contenu, dossier_annexe)
def creation_lignes(edition, sommes, clients, generaux, acces, livraisons, comptes, categories, prestations):
"""
génération des lignes de données du détail
:param edition: paramètres d'édition
:param sommes: sommes calculées
:param clients: clients importés
:param generaux: paramètres généraux
:param acces: accès importés
:param livraisons: livraisons importées
:param comptes: comptes importés
:param categories: catégories importées
:param prestations: prestations importées
:return: lignes de données du détail
"""
if sommes.calculees == 0:
info = "Vous devez d'abord faire toutes les sommes avant de pouvoir créer le détail des coûts"
Outils.affiche_message(info)
return None
lignes = []
for code_client in sorted(sommes.sommes_clients.keys()):
client = clients.donnees[code_client]
if code_client in sommes.sommes_comptes:
sclo = sommes.sommes_comptes[code_client]
comptes_utilises = Outils.comptes_in_somme(sclo, comptes)
base_client = [edition.annee, edition.mois, code_client, client['code_sap'], client['abrev_labo'],
'U', client['nature']]
for id_compte, num_compte in sorted(comptes_utilises.items(), key=lambda x: x[1]):
compte = comptes.donnees[id_compte]
base_compte = base_client + [id_compte, num_compte, compte['intitule'], compte['type_subside']]
if code_client in acces.sommes and id_compte in acces.sommes[code_client]['categories']:
som_cats = acces.sommes[code_client]['categories'][id_compte]['machine']
for id_categorie, som_cat in sorted(som_cats.items()):
duree = som_cat['duree_hp'] + som_cat['duree_hc']
ligne = base_compte + ['M', id_categorie, categories.donnees[id_categorie]['intitule'], duree,
som_cat['mo'], 0, 0, 0, 0, "", "", "", "", "", "", ""]
lignes.append(ligne)
if code_client in livraisons.sommes and id_compte in livraisons.sommes[code_client]:
somme = livraisons.sommes[code_client][id_compte]
for article in generaux.articles_d3:
if article.code_d in somme:
for no_prestation, sip in sorted(somme[article.code_d].items()):
prestation = prestations.prestation_de_num(no_prestation)
ligne = base_compte + [article.code_d, "", "", "", "", "", "", "", "",
article.intitule_court, no_prestation, sip['nom'],
Outils.format_2_dec(sip['montantx']),
Outils.format_2_dec(sip['rabais']), prestation['categ_stock'], prestation['affiliation']]
lignes.append(ligne)
return lignes
def est_coherent(self, subcomptes):
"""
vérifie que les données du fichier importé sont cohérentes
:param subcomptes: comptes subsides importés
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
donnees_dict = {}
ids = []
for donnee in self.donnees:
if donnee['id_compte'] == "":
msg += "le compte id de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['id_compte'] not in ids:
ids.append(donnee['id_compte'])
else:
msg += "le compte id '" + donnee['id_compte'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['id_compte'] not in subcomptes.obtenir_ids():
msg += "le compte id '" + donnee['id_compte'] + "' de la ligne " + str(ligne) +\
" n'est pas référencée dans les comptes subisdes\n"
donnee['m_mois'], info = Outils.est_un_nombre(
donnee['m_mois'], "le maximum m mois", ligne)
msg += info
donnee['m_compte'], info = Outils.est_un_nombre(
donnee['m_compte'], "le maximum m compte", ligne)
msg += info
donnees_dict[donnee['id_compte']] = donnee
ligne += 1
for id_compte in subcomptes.obtenir_ids():
if id_compte not in ids:
msg += "Le compte id '" + id_compte + "' dans les comptes subsides n'est pas présente dans " \
"les plafonds machines\n"
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def obtenir_comptes(self):
"""
retourne la liste de tous les comptes clients
:return: liste des comptes clients présents dans les données livraisons importées
"""
if self.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les comptes"
Outils.affiche_message(info)
return []
return self.comptes
def obtenir_codes(self):
"""
retourne les codes de tous les clients
:return: codes de tous les clients
"""
if self.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les codes"
Outils.affiche_message(info)
return []
return self.codes
def somme_par_compte(self, comptes):
"""
calcule les sommes par comptes sous forme de dictionnaire : client->compte->clés_sommes
:param comptes: comptes importés et vérifiés
"""
if self.sp != 0:
spc = {}
for code_client, client in self.sommes_projets.items():
if code_client not in spc:
spc[code_client] = {}
cl = spc[code_client]
for id_compte, compte in client.items():
cc = comptes.donnees[id_compte]
cl[id_compte] = self.nouveau_somme(Sommes.cles_somme_compte)
somme = cl[id_compte]
for num_projet, projet in compte.items():
somme["somme_j_pu"] += projet["somme_p_pu"]
somme["somme_j_pv"] += projet["somme_p_pv"]
somme["somme_j_pm"] += projet["somme_p_pm"]
somme["somme_j_qu"] += projet["somme_p_qu"]
somme["somme_j_qv"] += projet["somme_p_qv"]
somme["somme_j_qm"] += projet["somme_p_qm"]
somme["somme_j_om"] += projet["somme_p_om"]
somme["somme_j_nm"] += projet["somme_p_nm"]
for categorie in self.categories:
somme["sommes_cat_m"][categorie] += projet["sommes_cat_m"][categorie]
somme["sommes_cat_r"][categorie] += projet["sommes_cat_r"][categorie]
somme["tot_cat"][categorie] += projet["tot_cat"][categorie]
somme["prj"], somme["qrj"], somme["orj"] = Rabais.rabais_plafonnement(
somme["somme_j_pm"], cc["seuil"], cc["pourcent"]
)
somme["pj"] = somme["somme_j_pm"] - somme["prj"]
somme["qj"] = somme["somme_j_qm"] - somme["qrj"]
somme["oj"] = somme["somme_j_om"] - somme["orj"]
somme["nrj"] = somme["qrj"] + somme["orj"]
somme["nj"] = somme["somme_j_nm"] - somme["nrj"]
tot = somme["somme_j_pm"] + somme["somme_j_qm"] + somme["somme_j_om"]
for categorie in self.categories:
tot += somme["sommes_cat_m"][categorie]
if tot > 0:
somme["si_facture"] = 1
self.sco = 1
self.sommes_comptes = spc
else:
info = "Vous devez d'abord faire la somme par projet, avant la somme par compte"
print(info)
Outils.affiche_message(info)
def est_coherent(self, clients, generaux):
"""
vérifie que les données du fichier importé sont cohérentes (code client dans clients,
id compte unique), et efface les colonnes mois et année
:param clients: clients importés
:param generaux: paramètres généraux
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
ids = []
donnees_dict = {}
for donnee in self.donnees:
if donnee['code_client'] == "":
msg += "le code client de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['code_client'] not in clients.donnees:
msg += "le code client " + donnee['code_client'] + " de la ligne " + str(ligne) + \
" n'est pas référencé\n"
if donnee['id_compte'] == "":
msg += "le compte id de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['id_compte'] not in ids:
ids.append(donnee['id_compte'])
else:
msg += "l'id compte '" + donnee['id_compte'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['type_tarif'] != generaux.code_t:
msg += "le type de tarif de la ligne " + str(
ligne) + " n'est pas correct\n"
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_compte']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self, clients):
"""
vérifie que les données du fichier importé sont cohérentes
:param clients: clients importés
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
donnees_dict = {}
ids = []
del self.donnees[0]
for donnee in self.donnees:
if donnee['id_plateforme'] == "":
msg += "l'id plateforme " + str(ligne) + " ne peut être vide\n"
elif donnee['id_plateforme'] not in clients.obtenir_codes():
msg += "l'id plateforme de la ligne " + str(
ligne) + " n'existe pas dans les clients \n"
elif donnee['id_plateforme'] not in ids:
ids.append(donnee['id_plateforme'])
else:
msg += "l'id plateforme de la ligne " + str(
ligne) + " n'est pas unique \n"
donnee['code_p'], info = Outils.est_un_alphanumerique(
donnee['code_p'], "le code P", ligne)
msg += info
donnee['centre'], info = Outils.est_un_alphanumerique(
donnee['centre'], "le centre financier", ligne)
msg += info
donnee['fonds'], info = Outils.est_un_alphanumerique(
donnee['fonds'], "les fonds à créditer", ligne)
msg += info
donnee['intitule'], info = Outils.est_un_texte(
donnee['intitule'], "l'intitulé", ligne)
msg += info
donnee['grille'], info = Outils.est_un_document(
donnee['grille'], "la grille tarifaire", ligne, True)
msg += info
donnees_dict[donnee['id_plateforme']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self, groupes):
"""
vérifie que les données du fichier importé sont cohérentes, et efface les colonnes mois et année
:param categories: catégories importées
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
ids = []
donnees_dict = {}
for donnee in self.donnees:
donnee['id_machine'], info = Outils.est_un_alphanumerique(donnee['id_machine'], "l'id machine", ligne)
msg += info
if info == "":
if donnee['id_machine'] not in ids:
ids.append(donnee['id_machine'])
else:
msg += "l'id machine '" + donnee['id_machine'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['id_groupe'] == "":
msg += "l'id groupe de la ligne " + str(ligne) + " ne peut être vide\n"
elif groupes.contient_id(donnee['id_groupe']) == 0:
msg += "l'id groupe '" + donnee['id_groupe'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
donnee['tx_rabais_hc'], info = Outils.est_un_nombre(donnee['tx_rabais_hc'], "le rabais heures creuses",
ligne, min=0, max=100)
msg += info
donnee['nom'], info = Outils.est_un_texte(donnee['nom'], "le nom machine", ligne)
msg += info
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_machine']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self):
"""
vérifie que les données du fichier importé sont cohérentes (si id catégorie est unique),
et efface les colonnes mois et année
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
donnees_dict = {}
ids = []
del self.donnees[0]
for donnee in self.donnees:
if donnee['id_cat_cout'] == "":
msg += "l'id catégorie de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['id_cat_cout'] not in ids:
ids.append(donnee['id_cat_cout'])
else:
msg += "l'id catégorie '" + donnee['id_cat_cout'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
donnee['U1'], info = Outils.est_un_nombre(donnee['U1'],
"le coût U1 ", ligne)
msg += info
donnee['U2'], info = Outils.est_un_nombre(donnee['U2'],
"le coût U2 ", ligne)
msg += info
donnee['U3'], info = Outils.est_un_nombre(donnee['U3'],
"le coût U3 ", ligne)
msg += info
donnee['MO'], info = Outils.est_un_nombre(donnee['MO'],
"le coût MO ", ligne)
msg += info
donnees_dict[donnee['id_cat_cout']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self):
"""
vérifie que les données du fichier importé sont cohérentes
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
donnees_dict = {}
types = []
del self.donnees[0]
for donnee in self.donnees:
donnee['type'], info = Outils.est_un_alphanumerique(
donnee['type'], "le type subside", ligne)
msg += info
if info == "":
if donnee['type'] not in types:
types.append(donnee['type'])
else:
msg += "le type de la ligne " + str(
ligne) + " n'est pas unique\n"
donnee['intitule'], info = Outils.est_un_texte(
donnee['intitule'], "l'intitulé", ligne)
msg += info
if donnee['debut'] != 'NULL':
donnee['debut'], info = Outils.est_une_date(
donnee['debut'], "la date de début", ligne)
msg += info
if donnee['fin'] != 'NULL':
donnee['fin'], info = Outils.est_une_date(
donnee['fin'], "la date de fin", ligne)
msg += info
if donnee['debut'] != 'NULL' and donnee['fin'] != 'NULL':
if donnee['debut'] > donnee['fin']:
msg += "la date de fin de la ligne " + str(
ligne) + " doit être postérieure à la date de début"
donnees_dict[donnee['type']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def obtenir_comptes(self):
"""
retourne la liste de tous les comptes clients
:return: liste des comptes clients présents dans les données livraisons importées
"""
if self.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les comptes"
print(info)
Outils.affiche_message(info)
return []
return self.comptes
def obtenir_ids(self):
"""
retourne les ids de tous les comptes
:return: ids de tous les comptes
"""
if self.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les ids"
print(info)
Outils.affiche_message(info)
return []
return self._ids
def creation_lignes(edition, sommes, clients, generaux, acces, livraisons,
comptes, reservations):
"""
génération des lignes de données du bilan
:param edition: paramètres d'édition
:param sommes: sommes calculées
:param clients: clients importés
:param generaux: paramètres généraux
:param acces: accès importés
:param livraisons: livraisons importées
:param comptes: comptes importés
:param reservations: réservations importées
:return: lignes de données du bilan
"""
if sommes.calculees == 0:
info = "Vous devez d'abord faire toutes les sommes avant de pouvoir créer le bilan mensuel"
Outils.affiche_message(info)
return None
lignes = []
for code_client in sorted(sommes.sommes_clients.keys()):
scl = sommes.sommes_clients[code_client]
client = clients.donnees[code_client]
nature = generaux.code_ref_par_code_n(client['nature'])
reference = nature + str(edition.annee)[2:] + Outils.mois_string(
edition.mois) + "." + code_client
if edition.version > 0:
reference += "-" + str(edition.version)
users, cptes = BilanMensuel.utilisateurs_et_comptes(
acces, livraisons, code_client, comptes, reservations)
nb_u = len(users)
nb_c = len(cptes)
rht = client['rh'] * scl['dht']
ligne = [
edition.annee, edition.mois, reference, code_client,
client['code_sap'], client['abrev_labo'], client['nom_labo'],
'U', client['nature'], scl['em'], scl['er'], nb_u, nb_c,
Outils.format_2_dec(scl['mat']),
Outils.format_2_dec(scl['mot']),
Outils.format_2_dec(rht), scl['e'],
Outils.format_2_dec(scl['r']),
Outils.format_2_dec(scl['mt'])
]
for categorie in generaux.codes_d3():
ligne.append(Outils.format_2_dec(scl['tot_cat'][categorie]))
ligne += [
Outils.format_2_dec(scl['somme_t']),
Outils.format_2_dec(scl['somme_t_mb'])
]
lignes.append(ligne)
return lignes
def somme_par_categorie(self, comptes):
"""
calcule les sommes par catégories sous forme de dictionnaire : client->catégorie->clés_sommes
:param comptes: comptes importés et vérifiés
"""
if self.verification.a_verifier != 0:
info = "Sommes : vous devez faire les vérifications avant de calculer les sommes"
print(info)
Outils.affiche_message(info)
return
if self.sco != 0:
spc = {}
for code_client, client in self.sommes_comptes.items():
if code_client not in spc:
spc[code_client] = {}
cl = spc[code_client]
for id_compte, compte in client.items():
co = comptes.donnees[id_compte]
cat = co["categorie"]
if cat not in cl:
cl[cat] = self.nouveau_somme(Sommes.cles_somme_categorie)
somme = cl[cat]
somme["somme_k_pu"] += compte["somme_j_pu"]
somme["somme_k_pv"] += compte["somme_j_pv"]
somme["somme_k_pm"] += compte["somme_j_pm"]
somme["somme_k_prj"] += compte["prj"]
somme["pk"] += compte["pj"]
somme["somme_k_qu"] += compte["somme_j_qu"]
somme["somme_k_qv"] += compte["somme_j_qv"]
somme["somme_k_qm"] += compte["somme_j_qm"]
somme["somme_k_qrj"] += compte["qrj"]
somme["qk"] += compte["qj"]
somme["somme_k_om"] += compte["somme_j_om"]
somme["somme_k_orj"] += compte["orj"]
somme["ok"] += compte["oj"]
somme["somme_k_nm"] += compte["somme_j_nm"]
somme["somme_k_nrj"] += compte["nrj"]
somme["nk"] += compte["nj"]
for categorie in self.categories:
somme["sommes_cat_m"][categorie] += compte["sommes_cat_m"][categorie]
somme["sommes_cat_r"][categorie] += compte["sommes_cat_r"][categorie]
somme["tot_cat"][categorie] += compte["tot_cat"][categorie]
self.sca = 1
self.sommes_categories = spc
else:
info = "Vous devez d'abord faire la somme par compte, avant la somme par catégorie"
print(info)
Outils.affiche_message(info)
def obtenir_classes(self):
"""
retourne toutes les classes de tarif présentes
:return: toutes les classes de tarif présentes
"""
if self.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les classes"
print(info)
Outils.affiche_message(info)
return []
return self.classes
def obtenir_codes(self):
"""
retourne les codes de tous les clients
:return: codes de tous les clients
"""
if self.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les codes"
print(info)
Outils.affiche_message(info)
return []
return self.codes
def creation_lignes(edition, sommes, clients, generaux, comptes):
"""
génération des lignes de données du bilan
:param edition: paramètres d'édition
:param sommes: sommes calculées
:param clients: clients importés
:param generaux: paramètres généraux
:param comptes: comptes importés
:return: lignes de données du bilan
"""
if sommes.calculees == 0:
info = "Vous devez d'abord faire toutes les sommes avant de pouvoir créer le bilan des comptes"
Outils.affiche_message(info)
return None
lignes = []
for code_client in sorted(sommes.sommes_clients.keys()):
if code_client in sommes.sommes_comptes:
client = clients.donnees[code_client]
nature = generaux.code_ref_par_code_n(client['nature'])
reference = nature + str(
edition.annee)[2:] + Outils.mois_string(
edition.mois) + "." + code_client
if edition.version > 0:
reference += "-" + str(edition.version)
comptes_utilises = Outils.comptes_in_somme(
sommes.sommes_comptes[code_client], comptes)
for id_compte, num_compte in sorted(comptes_utilises.items(),
key=lambda x: x[1]):
compte = comptes.donnees[id_compte]
sco = sommes.sommes_comptes[code_client][id_compte]
ligne = [
edition.annee, edition.mois, reference, code_client,
client['code_sap'], client['abrev_labo'],
client['nom_labo'], 'U', client['nature'], id_compte,
num_compte, compte['intitule'], compte['type_subside'],
Outils.format_2_dec(sco['somme_j_mai']),
Outils.format_2_dec(sco['somme_j_moi']),
Outils.format_2_dec(client['rh'] * sco['somme_j_dhi']),
Outils.format_2_dec(sco['mj'])
]
total = sco['mj']
for categorie in generaux.codes_d3():
total += sco['tot_cat'][categorie]
ligne.append(
Outils.format_2_dec(sco['tot_cat'][categorie]))
ligne += [
Outils.format_2_dec(total),
Outils.format_2_dec(client['bh'] * sco['somme_j_dhi'])
]
lignes.append(ligne)
return lignes
def est_coherent(self, subgeneraux):
"""
vérifie que les données du fichier importé sont cohérentes
:param subgeneraux: paramètres généraux
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
donnees_dict = {}
for donnee in self.donnees:
if donnee['id_compte'] == "":
msg += "le compte id de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['id_compte'] not in self._ids:
self._ids.append(donnee['id_compte'])
else:
msg += "le compte id '" + donnee['id_compte'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['nature'] == "":
msg += "le nature de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['nature'] not in subgeneraux.obtenir_code_n():
msg += "la nature '" + donnee['nature'] + "' de la ligne " + str(ligne) +\
" n'existe pas dans les types N\n"
if donnee['type_subside'] == "":
msg += "le type subside de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['type_subside'] not in subgeneraux.obtenir_code_t():
msg += "le type subside '" + donnee['type_subside'] + "' de la ligne " + str(ligne) +\
" n'existe pas dans les types T3\n"
donnees_dict[donnee['id_compte']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def finaliser_pdf(nom_fichier, chemin_dossier=""):
"""
déplacer le pdf créé si nécessaire
:param nom_fichier: nom du pdf
:param chemin_dossier: chemin du dossier dans lequel enregistrer le pdf
"""
fichier = nom_fichier + ".pdf"
try:
if chemin_dossier != '':
shutil.copy(fichier, chemin_dossier)
os.unlink(fichier)
except IOError as err:
Outils.affiche_message("IOError: {0}".format(err))
def obtenir_noms_categories(self, categorie):
"""
retourne le nom lié à une catégorie
:return: nom lié à une catégorie
"""
if self.verifie_coherence == 0:
info = self.libelle + ". vous devez vérifier la cohérence avant de pouvoir obtenir les catégories"
print(info)
Outils.affiche_message(info)
return []
if categorie not in self.noms_cat:
return categorie
else:
return self.noms_cat[categorie]
def extraction_ligne(self, ligne):
"""
extracte une ligne de données du csv
:param ligne: ligne lue du fichier
:return: tableau représentant la ligne, indexé par les clés
"""
num = len(self.cles)
if len(ligne) != num:
info = self.libelle + ": nombre de colonnes incorrect : " + str(len(ligne)) + ", attendu : " + str(num)
print(info)
Outils.affiche_message(info)
sys.exit("Erreur de consistance")
donnees_ligne = {}
for xx in range(0, num):
donnees_ligne[self.cles[xx]] = ligne[xx]
return donnees_ligne
def calcul_montants(self, machines, coefmachines, comptes, clients, verification):
"""
calcule les montants 'pu', 'qu' et 'mo' et les ajoute aux données
:param machines: machines importées
:param coefmachines: coefficients machines importés et vérifiés
:param comptes: comptes importés et vérifiés
:param clients: clients importés et vérifiés
:param verification: pour vérifier si les dates et les cohérences sont correctes
"""
if verification.a_verifier != 0:
info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
print(info)
Outils.affiche_message(info)
return
donnees_list = []
for donnee in self.donnees:
compte = comptes.donnees[donnee['id_compte']]
machine = machines.donnees[donnee['id_machine']]
client = clients.donnees[compte['code_client']]
coefmachine = coefmachines.donnees[client['id_classe_tarif'] + machine['categorie']]
donnee['pu'] = round(donnee['duree_machine_hp'] / 60 * round(machine['t_h_machine_hp_p'] *
coefmachine['coef_p'], 2) +
donnee['duree_machine_hc'] / 60 * round(machine['t_h_machine_hc_p'] *
coefmachine['coef_p']), 2)
donnee['qu'] = round(donnee['duree_machine_hp'] / 60 * round(machine['t_h_machine_hp_np'] *
coefmachine['coef_np'], 2) +
donnee['duree_machine_hc'] / 60 * round(machine['t_h_machine_hc_np'] *
coefmachine['coef_np']), 2)
donnee['om'] = round(donnee['duree_operateur_hp'] / 60 *
round(machine['t_h_operateur_hp_mo'] * coefmachine['coef_mo'], 2) +
donnee['duree_operateur_hc'] / 60 *
round(machine['t_h_operateur_hc_mo'] * coefmachine['coef_mo']), 2)
donnees_list.append(donnee)
self.donnees = donnees_list
def verification_cohérence(self, generaux, edition, acces, clients, coefmachines, coefprests, comptes, livraisons,
machines, prestations, reservations):
"""
vérifie la cohérence des données importées
:param generaux: paramètres généraux
:param edition: paramètres d'édition
:param acces: accès importés
:param clients: clients importés
:param coefmachines: coefficients machines importés
:param coefprests: coefficients prestations importés
:param comptes: comptes importés
:param livraisons: livraisons importées
:param machines: machines importées
:param prestations: prestations importées
:param reservations: réservations importées
:return: 0 si ok, sinon le nombre d'échecs à la vérification
"""
verif = 0
verif += acces.est_coherent(comptes, machines)
verif += reservations.est_coherent(comptes, machines)
verif += livraisons.est_coherent(comptes, prestations)
verif += machines.est_coherent(coefmachines)
verif += prestations.est_coherent(generaux, coefprests)
verif += coefmachines.est_coherent()
verif += coefprests.est_coherent(generaux)
verif += clients.est_coherent(coefmachines, coefprests, generaux)
comptes_actifs, clients_actifs = Verification.obtenir_comptes_clients_actifs(acces, reservations, livraisons)
if (edition.version != '0') and (len(clients_actifs) > 1):
Outils.affiche_message("Si version différente de 0, un seul client autorisé")
sys.exit("Trop de clients pour version > 0")
verif += comptes.est_coherent(comptes_actifs)
self.a_verifier = 0
if len(clients_actifs) == 1:
edition.client_unique = clients_actifs[0]
return verif
def calcul_montants(self, machines, coefmachines, comptes, clients, verification):
"""
calcule les montants 'pv' et 'qv' et les ajoute aux données
:param machines: machines importées et vérifiées
:param coefmachines: coefficients machines importés et vérifiés
:param comptes: comptes importés et vérifiés
:param clients: clients importés et vérifiés
:param verification: pour vérifier si les dates et les cohérences sont correctes
"""
if verification.a_verifier != 0:
info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
print(info)
Outils.affiche_message(info)
return
donnees_list = []
for donnee in self.donnees:
compte = comptes.donnees[donnee['id_compte']]
machine = machines.donnees[donnee['id_machine']]
client = clients.donnees[compte['code_client']]
coefmachine = coefmachines.donnees[client['id_classe_tarif'] + machine['categorie']]
duree_fact_hp, duree_fact_hc = Rabais.rabais_reservation(machine['delai_sans_frais'],
donnee['duree_ouvree'],
donnee['duree_hp'],
donnee['duree_hc'])
donnee['pv'] = round(duree_fact_hp / 60 * round(machine['t_h_reservation_hp_p'] *
coefmachine['coef_p'], 2) + duree_fact_hc / 60 *
round(machine['t_h_reservation_hc_p'] * coefmachine['coef_p']), 2)
donnee['qv'] = round(duree_fact_hp / 60 * round(machine['t_h_reservation_hp_np'] *
coefmachine['coef_np'], 2) + duree_fact_hc / 60 *
round(machine['t_h_reservation_hc_np'] * coefmachine['coef_np']), 2)
donnee['duree_fact_hp'] = duree_fact_hp
donnee['duree_fact_hc'] = duree_fact_hc
donnees_list.append(donnee)
self.donnees = donnees_list
def est_coherent(self, generaux, coefprests):
"""
vérifie que les données du fichier importé sont cohérentes (id prestation unique,
catégorie prestation présente dans les paramètres D3), et efface les colonnes mois et année
:param generaux: paramètres généraux
:param coefprests: coefficients prestations importés
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
print(info)
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
ids = []
donnees_dict = {}
for donnee in self.donnees:
if donnee['id_prestation'] == "":
msg += "le prestation id de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_prestation'] not in ids:
ids.append(donnee['id_prestation'])
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_prestation']] = donnee
else:
msg += "l'id prestation '" + donnee['id_prestation'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['categorie'] == "":
msg += "la catégorie de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['categorie'] not in generaux.codes_d3():
msg += "la catégorie '" + donnee['categorie'] + "' de la ligne " + str(ligne) +\
" n'existe pas dans les paramètres D3\n"
elif coefprests.contient_categorie(donnee['categorie']) == 0:
msg += "la catégorie prestation '" + donnee['categorie'] + "' de la ligne " + str(ligne) +\
" n'est pas référencée dans les coefficients\n"
donnee['prix_unit'], info = Outils.est_un_nombre(donnee['prix_unit'], "le prix unitaire", ligne)
msg += info
donnee['val_moy_achat'], info = Outils.est_un_nombre(donnee['val_moy_achat'], "la valeur moyenne d'achat",
ligne)
msg += info
donnee['cout_unit'], info = Outils.est_un_nombre(donnee['cout_unit'], "le coût unitaire", ligne)
msg += info
donnee['prix_rev_unit'], info = Outils.est_un_nombre(donnee['prix_rev_unit'], "le prix de revient unitaire",
ligne)
msg += info
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self, coefmachines):
"""
vérifie que les données du fichier importé sont cohérentes (id machine unique,
catégorie machine référencé dans les coefficients machines), et efface les colonnes mois et année
:param coefmachines: coefficients machines importés
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
print(info)
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
ids = []
donnees_dict = {}
for donnee in self.donnees:
if donnee['id_machine'] == "":
msg += "le machine id de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_machine'] not in ids:
ids.append(donnee['id_machine'])
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_machine']] = donnee
else:
msg += "l'id machine '" + donnee['id_machine'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['categorie'] == "":
msg += "la catégorie machine de la ligne " + str(ligne) + " ne peut être vide\n"
elif coefmachines.contient_categorie(donnee['categorie']) == 0:
msg += "la catégorie machine '" + donnee['categorie'] + "' de la ligne " + str(ligne) +\
" n'est pas référencée dans les coefficients\n"
donnee['t_h_machine_a'], info = Outils.est_un_nombre(donnee['t_h_machine_a'], "le tarif machine A", ligne)
msg += info
donnee['t_h_machine_b'], info = Outils.est_un_nombre(donnee['t_h_machine_b'],
"le tarif machine B", ligne)
msg += info
donnee['t_h_machine_c'], info = Outils.est_un_nombre(donnee['t_h_machine_c'],
"le tarif machine C", ligne)
msg += info
donnee['d_h_machine_d'], info = Outils.est_un_nombre(donnee['d_h_machine_d'],
"la déduction machine D", ligne)
msg += info
donnee['d_h_creuses_e'], info = Outils.est_un_nombre(donnee['d_h_creuses_e'],
"la déduction heures creuses E", ligne)
msg += info
donnee['t_h_operateur_hp_mo'], info = Outils.est_un_nombre(donnee['t_h_operateur_hp_mo'],
"le tarif opérateur HP MO", ligne)
msg += info
donnee['tx_occ_eff_hp'], info = Outils.est_un_nombre(donnee['tx_occ_eff_hp'],
"le taux effectif d'occupation HP", ligne)
msg += info
donnee['t_h_reservation_hp'], info = Outils.est_un_nombre(donnee['t_h_reservation_hp'],
"le tarif réservation HP", ligne)
msg += info
donnee['t_h_operateur_hc_mo'], info = Outils.est_un_nombre(donnee['t_h_operateur_hc_mo'],
"le tarif opérateur HC MO", ligne)
msg += info
donnee['tx_occ_eff_hc'], info = Outils.est_un_nombre(donnee['tx_occ_eff_hc'],
"le taux effectif d'occupation HC", ligne)
msg += info
donnee['t_h_reservation_hc'], info = Outils.est_un_nombre(donnee['t_h_reservation_hc'],
"le tarif réservation HC", ligne)
msg += info
donnee['delai_sans_frais'], info = Outils.est_un_nombre(donnee['delai_sans_frais'], "le délai sans frais",
ligne)
msg += info
donnee['hc'], info = Outils.est_un_nombre(donnee['hc'], "le hc",
ligne)
msg += info
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
annexes_techniques = "annexes_techniques"
dossier_annexes_techniques = Outils.chemin_dossier([dossier_enregistrement, annexes_techniques], plateforme, generaux)
lien_annexes_techniques = Outils.lien_dossier([dossier_lien, annexes_techniques], plateforme, generaux)
facture_prod = Facture()
facture_prod.factures(sommes, dossier_destination, edition, generaux, clients, comptes,
lien_annexes, lien_annexes_techniques, annexes, annexes_techniques)
prod2qual = Prod2Qual(dossier_source)
if prod2qual.actif:
facture_qual = Facture(prod2qual)
generaux_qual = Generaux(dossier_source, prod2qual)
facture_qual.factures(sommes, dossier_destination, edition, generaux_qual, clients, comptes,
lien_annexes, lien_annexes_techniques, annexes, annexes_techniques)
if Latex.possibles():
Annexes.annexes_techniques(sommes, clients, edition, livraisons, acces, machines, reservations, prestations,
comptes, dossier_annexes_techniques, plateforme, coefprests, coefmachines, generaux)
Annexes.annexes(sommes, clients, edition, livraisons, acces, machines, reservations, prestations, comptes,
dossier_annexes, plateforme, coefprests, coefmachines, generaux)
BilanMensuel.bilan(dossier_destination, edition, sommes, clients, generaux, acces,
reservations, livraisons, comptes)
for fichier in [acces.nom_fichier, clients.nom_fichier, coefmachines.nom_fichier, coefprests.nom_fichier,
comptes.nom_fichier, livraisons.nom_fichier, machines.nom_fichier, prestations.nom_fichier,
reservations.nom_fichier, generaux.nom_fichier, edition.nom_fichier]:
dossier_destination.ecrire(fichier, dossier_source.lire(fichier))
Outils.affiche_message("OK !!!")
def somme_par_client(self, clients):
"""
calcule les sommes par clients sous forme de dictionnaire : client->clés_sommes
:param clients: clients importés et vérifiés
"""
if self.verification.a_verifier != 0:
info = "Sommes : vous devez faire les vérifications avant de calculer les sommes"
print(info)
Outils.affiche_message(info)
return
if self.sca != 0:
spc = {}
for code_client, client in self.sommes_categories.items():
spc[code_client] = self.nouveau_somme(Sommes.cles_somme_client)
somme = spc[code_client]
for cat, som_cat in client.items():
somme["somme_t_pu"] += som_cat["somme_k_pu"]
somme["somme_t_pv"] += som_cat["somme_k_pv"]
somme["somme_t_pm"] += som_cat["somme_k_pm"]
somme["somme_t_prj"] += som_cat["somme_k_prj"]
somme["pt"] += som_cat["pk"]
somme["somme_t_qu"] += som_cat["somme_k_qu"]
somme["somme_t_qv"] += som_cat["somme_k_qv"]
somme["somme_t_qm"] += som_cat["somme_k_qm"]
somme["somme_t_qrj"] += som_cat["somme_k_qrj"]
somme["qt"] += som_cat["qk"]
somme["somme_t_om"] += som_cat["somme_k_om"]
somme["somme_t_orj"] += som_cat["somme_k_orj"]
somme["ot"] += som_cat["ok"]
somme["somme_t_nm"] += som_cat["somme_k_nm"]
somme["somme_t_nrj"] += som_cat["somme_k_nrj"]
somme["nt"] += som_cat["nk"]
for categorie in self.categories:
somme["sommes_cat_m"][categorie] += som_cat["sommes_cat_m"][categorie]
somme["sommes_cat_r"][categorie] += som_cat["sommes_cat_r"][categorie]
somme["tot_cat"][categorie] += som_cat["tot_cat"][categorie]
cl = clients.donnees[code_client]
somme["somme_eq"], somme["somme_sb"], somme["somme_t"], somme["em"], somme["er0"], somme[
"er"
] = Rabais.rabais_emolument(
somme["pt"],
somme["qt"],
somme["ot"],
somme["tot_cat"],
cl["emol_base_mens"],
cl["emol_fixe"],
cl["coef"],
cl["emol_sans_activite"],
)
somme["e"] = somme["em"] - somme["er"]
self.calculees = 1
self.sommes_clients = spc
else:
info = "Vous devez d'abord faire la somme par catégorie, avant la somme par client"
print(info)
Outils.affiche_message(info)
def est_coherent(self):
"""
vérifie que les données du fichier importé sont cohérentes (si couple catégorie - classe de tarif est unique),
et efface les colonnes mois et année
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
print(info)
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
categories = []
couples = []
donnees_dict = {}
for donnee in self.donnees:
if donnee['categorie'] == "":
msg += "la catégorie de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['categorie'] not in categories:
categories.append(donnee['categorie'])
if donnee['id_classe_tarif'] == "":
msg += "la classe de tarif de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_classe_tarif'] not in self.classes:
self.classes.append(donnee['id_classe_tarif'])
if (donnee['categorie'] != "") and (donnee['id_classe_tarif'] != ""):
couple = [donnee['categorie'], donnee['id_classe_tarif']]
if couple not in couples:
couples.append(couple)
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_classe_tarif']+donnee['categorie']] = donnee
else:
msg += "Couple categorie '" + donnee['categorie'] + "' et classe de tarif '" + \
donnee['id_classe_tarif'] + "' de la ligne " + str(ligne) + " pas unique\n"
donnee['coef_p'], info = Outils.est_un_nombre(donnee['coef_p'], "le coefficient P", ligne)
msg += info
donnee['coef_np'], info = Outils.est_un_nombre(donnee['coef_np'], "le coefficient NP", ligne)
msg += info
donnee['coef_mo'], info = Outils.est_un_nombre(donnee['coef_mo'], "le coefficient MO", ligne)
msg += info
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
for categorie in categories:
for classe in self.classes:
couple = [categorie, classe]
if couple not in couples:
msg += "Couple categorie '" + categorie + "' et classe de tarif '" + \
classe + "' n'existe pas\n"
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self, generaux):
"""
vérifie que les données du fichier importé sont cohérentes (si couple catégorie - classe de tarif est unique),
et efface les colonnes mois et année
:param generaux: paramètres généraux
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
print(info)
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
categories = []
couples = []
donnees_dict = {}
for donnee in self.donnees:
if donnee['categorie'] == "":
msg += "la catégorie de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['categorie'] not in generaux.codes_d3():
msg += "la catégorie '" + donnee['categorie'] + "' de la ligne " + str(ligne) +\
" n'existe pas dans les paramètres D3\n"
elif donnee['categorie'] not in categories:
categories.append(donnee['categorie'])
if donnee['id_classe_tarif'] == "":
msg += "la classe de tarif de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_classe_tarif'] not in self.classes:
self.classes.append(donnee['id_classe_tarif'])
if (donnee['categorie'] != "") and (donnee['id_classe_tarif'] != ""):
couple = [donnee['categorie'], donnee['id_classe_tarif']]
if couple not in couples:
couples.append(couple)
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_classe_tarif']+donnee['categorie']] = donnee
else:
msg += "Couple categorie '" + donnee['categorie'] + "' et classe de tarif '" + \
donnee['id_classe_tarif'] + "' de la ligne " + str(ligne) + " pas unique\n"
if donnee['categorie'] not in self.noms_cat:
self.noms_cat[donnee['categorie']] = donnee['nom_categorie']
donnee['coefficient'], info = Outils.est_un_nombre(donnee['coefficient'], "le coefficient", ligne)
msg += info
for categorie in generaux.codes_d3():
if categorie not in categories:
msg += "La categorie D3 '" + categorie + "' dans les paramètres généraux n'est pas présente dans " \
"les coefficients de prestations\n"
for categorie in categories:
for classe in self.classes:
couple = [categorie, classe]
if couple not in couples:
msg += "Couple categorie '" + categorie + "' et classe de tarif '" + \
classe + "' n'existe pas\n"
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
def sommes_par_projet(self, livraisons, reservations, acces, prestations, comptes):
"""
calcule les sommes par projets sous forme de dictionnaire : client->compte->projet->clés_sommes
:param livraisons: livraisons importées et vérifiées
:param reservations: réservations importées et vérifiées
:param acces: accès machines importés et vérifiés
:param prestations: prestations importées et vérifiées
:param comptes: comptes importés et vérifiés
"""
if self.verification.a_verifier != 0:
info = "Sommes : vous devez faire les vérifications avant de calculer les sommes"
print(info)
Outils.affiche_message(info)
return
spp = {}
for acce in acces.donnees:
id_compte = acce["id_compte"]
co = comptes.donnees[id_compte]
code_client = co["code_client"]
if code_client not in spp:
spp[code_client] = {}
client = spp[code_client]
if id_compte not in client:
client[id_compte] = {}
num_projet = acce["num_projet"]
compte = client[id_compte]
if num_projet not in compte:
compte[num_projet] = self.nouveau_somme(Sommes.cles_somme_projet)
projet = compte[num_projet]
projet["intitule"] = acce["intitule_projet"]
else:
projet = compte[num_projet]
projet["somme_p_pu"] += acce["pu"]
projet["somme_p_pm"] += acce["pu"]
projet["somme_p_qu"] += acce["qu"]
projet["somme_p_qm"] += acce["qu"]
projet["somme_p_om"] += acce["om"]
projet["somme_p_nm"] += acce["om"]
projet["somme_p_nm"] += acce["qu"]
for reservation in reservations.donnees:
id_compte = reservation["id_compte"]
co = comptes.donnees[id_compte]
code_client = co["code_client"]
if code_client not in spp:
spp[code_client] = {}
client = spp[code_client]
if id_compte not in client:
client[id_compte] = {}
num_projet = reservation["num_projet"]
compte = client[id_compte]
if num_projet not in compte:
compte[num_projet] = self.nouveau_somme(Sommes.cles_somme_projet)
projet = compte[num_projet]
projet["intitule"] = reservation["intitule_projet"]
else:
projet = compte[num_projet]
projet["somme_p_pv"] += reservation["pv"]
projet["somme_p_pm"] += reservation["pv"]
projet["somme_p_qv"] += reservation["qv"]
projet["somme_p_qm"] += reservation["qv"]
projet["somme_p_nm"] += reservation["qv"]
for livraison in livraisons.donnees:
id_compte = livraison["id_compte"]
co = comptes.donnees[id_compte]
code_client = co["code_client"]
if code_client not in spp:
spp[code_client] = {}
client = spp[code_client]
if id_compte not in client:
client[id_compte] = {}
num_projet = livraison["num_projet"]
compte = client[id_compte]
if num_projet not in compte:
compte[num_projet] = self.nouveau_somme(Sommes.cles_somme_projet)
projet = compte[num_projet]
projet["intitule"] = livraison["intitule_projet"]
else:
projet = compte[num_projet]
id_prestation = livraison["id_prestation"]
prestation = prestations.donnees[id_prestation]
projet["sommes_cat_m"][prestation["categorie"]] += livraison["montant"]
projet["sommes_cat_r"][prestation["categorie"]] += livraison["rabais_r"]
projet["tot_cat"][prestation["categorie"]] += livraison["montant"] - livraison["rabais_r"]
self.sp = 1
self.sommes_projets = spp
def somme_par_compte(self, reservations, acces, machines):
"""
calcule les sommes par comptes sous forme de dictionnaire : client->compte->clés_sommes
:param reservations: réservations importées et vérifiées
:param acces: accès machines importées et vérifiés
:param machines: machines importées et vérifiées
"""
if self.sp != 0:
spco = {}
for code_client, spp_cl in self.sommes_projets.items():
if code_client not in spco:
spco[code_client] = {}
spco_cl = spco[code_client]
for id_compte, spp_co in spp_cl.items():
spco_cl[id_compte] = self.nouveau_somme(Sommes.cles_somme_compte)
somme = spco_cl[id_compte]
for num_projet, projet in spp_co.items():
somme['somme_j_ai'] += projet['somme_p_ai']
somme['somme_j_bi'] += projet['somme_p_bi']
somme['somme_j_ci'] += projet['somme_p_ci']
somme['somme_j_oi'] += projet['somme_p_oi']
somme['somme_j_mai'] += projet['somme_p_mai']
somme['somme_j_moi'] += projet['somme_p_moi']
somme['somme_j_dsi'] += projet['somme_p_dsi']
somme['somme_j_dhi'] += projet['somme_p_dhi']
somme['somme_j_mm'] += projet['somme_p_mm']
somme['somme_j_mr'] += projet['somme_p_mr']
somme['mj'] += projet['mp']
somme['res'] = {}
for categorie in self.categories:
somme['sommes_cat_m'][categorie] += projet['sommes_cat_m'][categorie]
somme['sommes_cat_r'][categorie] += projet['sommes_cat_r'][categorie]
somme['tot_cat'][categorie] += projet['tot_cat'][categorie]
tot = somme['somme_j_mm']
for categorie in self.categories:
tot += somme['sommes_cat_m'][categorie]
if tot > 0:
somme['si_facture'] = 1
# réservations
for code_client in reservations.sommes:
for id_compte in reservations.sommes[code_client]['comptes']:
if code_client not in spco:
spco[code_client] = {}
spco_cl = spco[code_client]
if id_compte not in spco_cl:
spco_cl[id_compte] = self.nouveau_somme(Sommes.cles_somme_compte)
spco_cl[id_compte]['res'] = {}
somme = spco_cl[id_compte]
machines_utilisees = []
somme_res = reservations.sommes[code_client]['comptes'][id_compte]
for key in somme_res.keys():
machines_utilisees.append(key)
somme_cae = {}
if code_client in acces.sommes:
if id_compte in acces.sommes[code_client]:
somme_cae = acces.sommes[code_client][id_compte]
for key in somme_cae.keys():
if key not in machines_utilisees:
machines_utilisees.append(key)
for mach_u in machines_utilisees:
if mach_u in somme_res:
mini_hp = (somme_res[mach_u]['res_hp'] + somme_res[mach_u]['ann_hp']) * machines.donnees[mach_u]['tx_occ_eff_hp'] / 100
mini_hc = (somme_res[mach_u]['res_hc'] + somme_res[mach_u]['ann_hc']) * machines.donnees[mach_u]['tx_occ_eff_hc'] / 100
else:
mini_hp = 0
mini_hc = 0
if mach_u in somme_cae:
pen_hp = mini_hp - somme_cae[mach_u]['duree_hp']
pen_hc = mini_hc - somme_cae[mach_u]['duree_hc']
else:
pen_hp = mini_hp
pen_hc = mini_hc
somme['res'][mach_u] = {'pen_hp': round(pen_hp/60, 1), 'pen_hc': round(pen_hc/60, 1)}
# print("")
# print("spco")
# for code in spco:
# if code != "220208":
# continue
# print(code)
# spco_cl = spco[code]
# for id in spco_cl:
# somme = spco_cl[id]
# print(" ", id, somme['somme_j_mai'])
self.sco = 1
self.sommes_comptes = spco
else:
info = "Vous devez d'abord faire la somme par projet, avant la somme par compte"
print(info)
Outils.affiche_message(info)
def calcul_montants(self, machines, coefmachines, comptes, clients, verification):
"""
calcule les montants 'pu', 'qu' et 'mo' et les ajoute aux données
:param machines: machines importées
:param coefmachines: coefficients machines importés et vérifiés
:param comptes: comptes importés et vérifiés
:param clients: clients importés et vérifiés
:param verification: pour vérifier si les dates et les cohérences sont correctes
"""
if verification.a_verifier != 0:
info = self.libelle + ". vous devez faire les vérifications avant de calculer les montants"
print(info)
Outils.affiche_message(info)
return
donnees_list = []
for donnee in self.donnees:
id_compte = donnee['id_compte']
compte = comptes.donnees[id_compte]
code_client = compte['code_client']
id_machine = donnee['id_machine']
machine = machines.donnees[id_machine]
client = clients.donnees[code_client]
coefmachine = coefmachines.donnees[client['id_classe_tarif'] + machine['categorie']]
tm = donnee['duree_machine_hp'] / 60 + donnee['duree_machine_hc'] / 60
donnee['ai'] = round(tm * machine['t_h_machine_a'], 2)
donnee['bi'] = round(tm * machine['t_h_machine_b'], 2)
donnee['ci'] = round(tm * machine['t_h_machine_c'], 2)
donnee['oi'] = round(donnee['duree_operateur_hp'] / 60 * machine['t_h_operateur_hp_mo'] +
donnee['duree_operateur_hc'] / 60 * machine['t_h_operateur_hc_mo'], 2)
donnee['pum'] = coefmachine['coef_a'] * machine['t_h_machine_a'] + coefmachine['coef_b'] * machine['t_h_machine_b'] +\
coefmachine['coef_c'] * machine['t_h_machine_c']
donnee['mai'] = round(tm * donnee['pum'], 2)
donnee['puo_hp'] = coefmachine['coef_mo'] * machine['t_h_operateur_hp_mo']
donnee['puo_hc'] = coefmachine['coef_mo'] * machine['t_h_operateur_hc_mo']
donnee['moi'] = round(donnee['duree_operateur_hp'] / 60 * donnee['puo_hp'] +
donnee['duree_operateur_hc'] / 60 * donnee['puo_hc'], 2)
donnee['dsi'] = round(tm * coefmachine['coef_d'] * machine['d_h_machine_d'],2)
if machine['hc'] == 1:
donnee['dhi'] = round(donnee['duree_machine_hc'] / 60 * coefmachine['coef_e'] * machine['d_h_creuses_e'],2)
else:
donnee['dhi'] = 0
donnee['mm'] = donnee['mai'] + donnee['moi']
donnee['mr'] = donnee['dsi'] + donnee['dhi']
donnee['m'] = donnee['mm'] - donnee['mr']
if code_client not in self.sommes:
self.sommes[code_client] = {}
scl = self.sommes[code_client]
if id_compte not in scl:
scl[id_compte] = {}
sco = scl[id_compte]
if id_machine not in sco:
sco[id_machine] = {'duree_hp': donnee['duree_machine_hp'], 'duree_hc': donnee['duree_machine_hc']}
else:
sco[id_machine]["duree_hp"] += donnee['duree_machine_hp']
sco[id_machine]['duree_hc'] += donnee['duree_machine_hc']
donnees_list.append(donnee)
self.donnees = donnees_list
def est_coherent(self, coefmachines, coefprests, generaux):
"""
vérifie que les données du fichier importé sont cohérentes (code client unique,
classe tarif présente dans coefficients, type de labo dans paramètres), et efface les colonnes mois et année
:param coefmachines: coefficients machines importés
:param coefprests: coefficients prestations importés
:param generaux: paramètres généraux
:return: 1 s'il y a une erreur, 0 sinon
"""
if self.verifie_date == 0:
info = self.libelle + ". vous devez vérifier la date avant de vérifier la cohérence"
print(info)
Outils.affiche_message(info)
return 1
if self.verifie_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
classes = []
donnees_dict = {}
for donnee in self.donnees:
if donnee['id_classe_tarif'] == "":
msg += "la classe de tarif de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_classe_tarif'] not in classes:
classes.append(donnee['id_classe_tarif'])
if donnee['code_sap'] == "":
msg += "le code sap de la ligne " + str(ligne) + " ne peut être vide\n"
if donnee['code'] == "":
msg += "le code client de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['code'] not in self.codes:
self.codes.append(donnee['code'])
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['code']] = donnee
else:
msg += "le code client '" + donnee['code'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['type_labo'] == "":
msg += "le type de labo de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['type_labo'] not in generaux.obtenir_code_n():
msg += "le type de labo '" + donnee['type_labo'] + "' de la ligne " + str(ligne) +\
" n'existe pas dans les types N\n"
if (donnee['mode'] != "") and (donnee['mode'] not in generaux.obtenir_modes_envoi()):
msg += "le mode d'envoi '" + donnee['mode'] + "' de la ligne " + str(ligne) +\
" n'existe pas dans les modes d'envoi généraux\n"
if (donnee['email'] != "") and (not re.match("[^@]+@[^@]+\.[^@]+", donnee['email'])):
msg += "le format de l'e-mail '" + donnee['email'] + "' de la ligne " + str(ligne) +\
" n'est pas correct\n"
if not((donnee['emol_sans_activite'] == "NON") or (donnee['emol_sans_activite'] == "ZERO") or
(donnee['emol_sans_activite'] == "OUI")):
msg += "l'émolument à payer même sans activité de la ligne " + str(ligne) + " doit valoir ZERO, NON ou OUI\n"
donnee['emol_base_mens'], info = Outils.est_un_nombre(donnee['emol_base_mens'], "l'émolument de base",
ligne)
msg += info
donnee['emol_fixe'], info = Outils.est_un_nombre(donnee['emol_fixe'], "l'émolument fixe", ligne)
msg += info
donnee['coef'], info = Outils.est_un_nombre(donnee['coef'], "le coefficient a", ligne)
msg += info
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
for classe in classes:
if classe not in coefmachines.obtenir_classes():
msg += "la classe de tarif '" + classe + "' n'est pas présente dans les coefficients machines\n"
if classe not in coefprests.obtenir_classes():
msg += "la classe de tarif '" + classe + "' n'est pas présente dans les coefficients prestations\n"
if msg != "":
msg = self.libelle + "\n" + msg
print("msg : " + msg)
Outils.affiche_message(msg)
return 1
return 0
def somme_par_client(self, clients, reservations):
"""
calcule les sommes par clients sous forme de dictionnaire : client->clés_sommes
:param clients: clients importés et vérifiés
:param reservations: réservations importées et vérifiées
"""
if self.verification.a_verifier != 0:
info = "Sommes : vous devez faire les vérifications avant de calculer les sommes"
print(info)
Outils.affiche_message(info)
return
if self.sca != 0:
spcl = {}
for code_client, spca_cl in self.sommes_categories.items():
spcl[code_client] = self.nouveau_somme(Sommes.cles_somme_client)
somme = spcl[code_client]
for cat, som_cat in spca_cl.items():
somme['somme_t_ai'] += som_cat['somme_k_ai']
somme['somme_t_bi'] += som_cat['somme_k_bi']
somme['somme_t_ci'] += som_cat['somme_k_ci']
somme['somme_t_oi'] += som_cat['somme_k_oi']
somme['mat'] += som_cat['somme_k_mai']
somme['mot'] += som_cat['somme_k_moi']
somme['dst'] += som_cat['somme_k_dsi']
somme['dht'] += som_cat['somme_k_dhi']
somme['somme_t_mm'] += som_cat['somme_k_mm']
somme['somme_t_mr'] += som_cat['somme_k_mr']
somme['mt'] += som_cat['mk']
for categorie in self.categories:
somme['sommes_cat_m'][categorie] += som_cat['sommes_cat_m'][categorie]
somme['sommes_cat_r'][categorie] += som_cat['sommes_cat_r'][categorie]
somme['tot_cat'][categorie] += som_cat['tot_cat'][categorie]
spco_cl = self.sommes_comptes[code_client]
somme['res'] = {}
somme['rm'] = 0
for id_co, spco_co in spco_cl.items():
for id_mach, mach in spco_co['res'].items():
if id_mach not in somme['res']:
somme['res'][id_mach] = {'pen_hp': 0, 'pen_hc': 0, 'm_hp': 0, 'm_hc': 0}
som_m = somme['res'][id_mach]
som_m['pen_hp'] += mach['pen_hp']
som_m['pen_hc'] += mach['pen_hc']
for id_mach, som_m in somme['res'].items():
if som_m['pen_hp'] > 0:
som_m['m_hp'] += som_m['pen_hp'] * reservations.sommes[code_client]['machines'][id_mach]['pu_hp']
somme['rm'] += som_m['m_hp']
if som_m['pen_hc'] > 0:
som_m['m_hc'] += som_m['pen_hc'] * reservations.sommes[code_client]['machines'][id_mach]['pu_hc']
somme['rm'] += som_m['m_hc']
somme['rr'] = Rabais.rabais_reservation_petit_montant(somme['rm'], self.min_fact_rese)
somme['r'] = somme['rm'] - somme['rr']
client = clients.donnees[code_client]
somme['somme_eq'], somme['somme_t'], somme['em'], somme['er0'], somme['er'] = \
Rabais.rabais_emolument(somme['r'], somme['mt'], somme['mot'], somme['tot_cat'],
client['emol_base_mens'], client['emol_fixe'], client['coef'],
client['emol_sans_activite'])
somme['e'] = somme['em'] - somme['er']
# print("")
# print("spcl")
# for code in spcl:
# if code != "220208":
# continue
# somme = spcl[code]
# print(code, somme['mat'])
self.calculees = 1
self.sommes_clients = spcl
else:
info = "Vous devez d'abord faire la somme par catégorie, avant la somme par client"
print(info)
Outils.affiche_message(info)
def bilan(dossier_destination, edition, sommes, clients, generaux, acces, reservations, livraisons,
comptes):
"""
création du bilan
:param dossier_destination: Une instance de la classe dossier.DossierDestination
:param edition: paramètres d'édition
:param sommes: sommes calculées
:param clients: clients importés
:param generaux: paramètres généraux
:param acces: accès importés
:param reservations: réservations importés
:param livraisons: livraisons importées
:param comptes: comptes importés
"""
if sommes.calculees == 0:
info = "Vous devez d'abord faire toutes les sommes avant de pouvoir créer le bilan mensuel"
print(info)
Outils.affiche_message(info)
return
nom = "bilan_" + str(edition.annee) + "_" + Outils.mois_string(edition.mois) + "_" + \
str(edition.version) + ".csv"
with dossier_destination.writer(nom) as fichier_writer:
ligne = ["année", "mois", "référence", "code client", "code client sap", "abrév. labo", "nom labo",
"type client", "nature client", "Em base", "somme EQ", "rabais Em", "règle", "nb utilisateurs",
"nb tot comptes", "nb comptes cat 1", "nb comptes cat 2", "nb comptes cat 3", "nb comptes cat 4",
"total M cat 1", "total M cat 2", "total M cat 3", "total M cat 4", "MAt", "MOt", "DSt", "DHt",
"Et", "Rt", "Mt"]
for categorie in generaux.codes_d3():
ligne.append(categorie + "t")
ligne.append("total facturé HT")
fichier_writer.writerow(ligne)
for code_client in sorted(sommes.sommes_clients.keys()):
scl = sommes.sommes_clients[code_client]
sca = sommes.sommes_categories[code_client]
client = clients.donnees[code_client]
nature = generaux.nature_client_par_code_n(client['type_labo'])
reference = nature + str(edition.annee)[2:] + Outils.mois_string(edition.mois) + "." + code_client
nb_u = len(BilanMensuel.utilisateurs(acces, livraisons, reservations, code_client))
cptes = BilanMensuel.comptes(acces, livraisons, reservations, code_client)
cat = {'1': 0, '2': 0, '3': 0, '4': 0}
nb_c = 0
for cpte in cptes:
nb_c += 1
cat[comptes.donnees[cpte]['categorie']] += 1
mk = {'1': 0, '2': 0, '3': 0, '4': 0}
for num in mk.keys():
if num in sca:
mk[num] = sca[num]['mk']
total = scl['somme_t'] + scl['e']
ligne = [edition.annee, edition.mois, reference, code_client, client['code_sap'], client['abrev_labo'],
client['nom_labo'], 'U', client['type_labo'], scl['em'], "%.2f" % scl['somme_eq'], scl['er'],
client['emol_sans_activite'], nb_u, nb_c, cat['1'], cat['2'], cat['3'], cat['4'],
"%.2f" % mk['1'], "%.2f" % mk['2'], "%.2f" % mk['3'], "%.2f" % mk['4'], "%.2f" % scl['mat'],
scl['mot'], scl['dst'], scl['dht'], scl['e'], scl['r'], "%.2f" % scl['mt']]
for categorie in generaux.codes_d3():
ligne.append(scl['tot_cat'][categorie])
ligne.append("%.2f" % total)
fichier_writer.writerow(ligne)
def sommes_par_projet(self, livraisons, acces, prestations, comptes):
"""
calcule les sommes par projets sous forme de dictionnaire : client->compte->projet->clés_sommes
:param livraisons: livraisons importées et vérifiées
:param acces: accès machines importés et vérifiés
:param prestations: prestations importées et vérifiées
:param comptes: comptes importés et vérifiés
"""
if self.verification.a_verifier != 0:
info = "Sommes : vous devez faire les vérifications avant de calculer les sommes"
print(info)
Outils.affiche_message(info)
return
spp = {}
for acce in acces.donnees:
id_compte = acce['id_compte']
code_client = comptes.donnees[id_compte]['code_client']
if code_client not in spp:
spp[code_client] = {}
spp_cl = spp[code_client]
if id_compte not in spp_cl:
spp_cl[id_compte] = {}
num_projet = acce['num_projet']
spp_co = spp_cl[id_compte]
if num_projet not in spp_co:
spp_co[num_projet] = self.nouveau_somme(Sommes.cles_somme_projet)
projet = spp_co[num_projet]
projet['intitule'] = acce['intitule_projet']
else:
projet = spp_co[num_projet]
projet['somme_p_ai'] += acce['ai']
projet['somme_p_bi'] += acce['bi']
projet['somme_p_ci'] += acce['ci']
projet['somme_p_oi'] += acce['oi']
projet['somme_p_mai'] += acce['mai']
projet['somme_p_moi'] += acce['moi']
projet['somme_p_dsi'] += acce['dsi']
projet['somme_p_dhi'] += acce['dhi']
projet['somme_p_mm'] += acce['mm']
projet['somme_p_mr'] += acce['mr']
projet['mp'] += acce['m']
for livraison in livraisons.donnees:
id_compte = livraison['id_compte']
code_client = comptes.donnees[id_compte]['code_client']
if code_client not in spp:
spp[code_client] = {}
spp_cl = spp[code_client]
if id_compte not in spp_cl:
spp_cl[id_compte] = {}
num_projet = livraison['num_projet']
spp_co = spp_cl[id_compte]
if num_projet not in spp_co:
spp_co[num_projet] = self.nouveau_somme(Sommes.cles_somme_projet)
projet = spp_co[num_projet]
projet['intitule'] = livraison['intitule_projet']
else:
projet = spp_co[num_projet]
id_prestation = livraison['id_prestation']
prestation = prestations.donnees[id_prestation]
projet['sommes_cat_m'][prestation['categorie']] += livraison['montant']
projet['sommes_cat_r'][prestation['categorie']] += livraison['rabais_r']
projet['tot_cat'][prestation['categorie']] += livraison['montant'] - livraison['rabais_r']
# print("spp")
# for code in spp:
# if code != "220208":
# continue
# print(code)
# spp_cl = spp[code]
# for id in spp_cl:
# print(" ", id)
# spp_co = spp_cl[id]
# for num in spp_co:
# projet = spp_co[num]
# print(" ", " ", num, projet['somme_p_mai'])
self.sp = 1
self.sommes_projets = spp
