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 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 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 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 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 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 generer(self, trans_vals, paramtexte, dossier_destination, par_plate):
"""
génération du fichier de bilan des consommations à 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-good']:
donnee = []
for cle in range(2, len(self.cles) - 4):
donnee.append(base[self.cles[cle]])
goops = 0
extrops = 0
goint = 0
extrint = 0
for indice in tbtr:
val = trans_vals[indice]
net, info = Outils.est_un_nombre(val['valuation-net'],
"le net",
arrondi=2)
if info != "":
Outils.affiche_message(info)
if val['client-code'] == val['platf-code']:
if val['item-extra'] == "TRUE":
if val['proj-expl'] == "TRUE":
extrops += net
else:
extrint += net
else:
if val['proj-expl'] == "TRUE":
goops += net
else:
goint += net
if goops > 0 or extrops > 0 or goint > 0 or extrint > 0:
donnee += [
round(goops, 2),
round(extrops, 2),
round(goint, 2),
round(extrint, 2)
]
self.ajouter_valeur(donnee, ii)
ii += 1
self.csv(dossier_destination, paramtexte)
def est_coherent(self, generaux):
"""
vérifie que les données du fichier importé sont cohérentes,
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_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
donnees_dict = {}
natures = []
del self.donnees[0]
for donnee in self.donnees:
if donnee['nature'] == "":
msg += "la nature client de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['nature'] not in generaux.obtenir_code_n():
msg += "la nature client de la ligne " + str(
ligne) + " n'existe pas dans les codes N\n"
elif donnee['nature'] not in natures:
if donnee['nature'] not in natures:
natures.append(donnee['nature'])
else:
msg += "la nature '" + donnee['nature'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
donnee['emolument'], info = Outils.est_un_nombre(
donnee['emolument'], "l'émolument", ligne)
msg += info
donnees_dict[donnee['nature']] = 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, 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 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, generaux, coefprests, plateformes, machines):
"""
vérifie que les données du fichier importé sont cohérentes et efface les colonnes mois et année
:param generaux: paramètres généraux
:param coefprests: coefficients prestations importés
:param plateformes: plateformes importées
: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"
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_prestation'], info = Outils.est_un_alphanumerique(donnee['id_prestation'], "l'id prestation",
ligne)
msg += info
if info == "":
if donnee['id_prestation'] not in ids:
ids.append(donnee['id_prestation'])
else:
msg += "l'id prestation '" + donnee['id_prestation'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['no_prestation'] == "":
msg += "le numéro de prestation de la ligne " + str(ligne) + " ne peut être vide\n"
else:
donnee['no_prestation'], info = Outils.est_un_alphanumerique(donnee['no_prestation'],
"le no prestation", ligne)
msg += info
donnee['designation'], info = Outils.est_un_texte(donnee['designation'], "la désignation", ligne)
msg += info
donnee['unite_prest'], info = Outils.est_un_texte(donnee['unite_prest'], "l'unité prestation", ligne, True)
msg += info
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"
if donnee['id_plateforme'] == "":
msg += "l'id plateforme de la ligne " + str(ligne) + " ne peut être vide\n"
elif plateformes.contient_id(donnee['id_plateforme']) == 0:
msg += "l'id plateforme '" + donnee['id_plateforme'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
if donnee['id_machine'] == "":
msg += "l'id machine de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['id_machine'] != "0":
if machines.contient_id(donnee['id_machine']) == 0:
msg += "l'id machine '" + donnee['id_machine'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé ni égal à 0\n"
donnee['prix_unit'], info = Outils.est_un_nombre(donnee['prix_unit'], "le prix unitaire", ligne, 2, 0)
msg += info
del donnee['annee']
del donnee['mois']
donnees_dict[donnee['id_prestation']] = 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, 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
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_coherence == 1:
print(self.libelle + ": cohérence déjà vérifiée")
return 0
msg = ""
ligne = 1
categories = []
couples = []
donnees_dict = {}
natures = []
del self.donnees[0]
for donnee in self.donnees:
if donnee['nature'] == "":
msg += "la nature client de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['nature'] not in generaux.obtenir_code_n():
msg += "la nature client de la ligne " + str(
ligne) + " n'existe pas dans les codes N\n"
elif donnee['nature'] not in natures:
if donnee['nature'] not in natures:
natures.append(donnee['nature'])
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['categorie'] != "") and (donnee['nature'] != ""):
couple = [donnee['categorie'], donnee['nature']]
if couple not in couples:
couples.append(couple)
else:
msg += "Couple categorie '" + donnee['categorie'] + "' et nature '" + \
donnee['nature'] + "' de la ligne " + str(ligne) + " pas unique\n"
donnee['coefficient'], info = Outils.est_un_nombre(
donnee['coefficient'], "le coefficient", ligne)
msg += info
donnees_dict[donnee['nature'] + donnee['categorie']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
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 nature in natures:
couple = [categorie, nature]
if couple not in couples:
msg += "Couple categorie '" + categorie + "' et nature client '" + \
nature + "' n'existe pas\n"
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 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 __init__(self, dossier_source, prod2qual=None):
"""
initialisation et importation des données
:param dossier_source: Une instance de la classe dossier.DossierSource
:param prod2qual: Une instance de la classe Prod2Qual si on souhaite éditer
des factures et annexes avec les codes d'articles de
qualification
"""
self._donnees = {}
self.verifie_coherence = 0
try:
for ligne in dossier_source.reader(self.nom_fichier):
cle = ligne.pop(0)
if cle not in self.cles_autorisees:
Outils.fatal(ErreurConsistance(),
"Clé inconnue dans %s: %s" % (self.nom_fichier, cle))
if cle != "texte_sap":
while ligne[-1] == "":
del ligne[-1]
self._donnees[cle] = ligne
except IOError as e:
Outils.fatal(e, "impossible d'ouvrir le fichier : "+self.nom_fichier)
if prod2qual and 'code_sap_qas' in self._donnees:
self._donnees['code_sap'] = self._donnees['code_sap_qas']
erreurs = ""
for cle in self.cles_obligatoires:
if cle not in self._donnees:
erreurs += "\nClé manquante dans %s: %s" % (self.nom_fichier, cle)
self._donnees['centre'][1], err = Outils.est_un_texte(self._donnees['centre'][1], "le centre")
erreurs += err
self._donnees['origine'][1], err = Outils.est_un_alphanumerique(self._donnees['origine'][1], "l'origine")
erreurs += err
self._donnees['code_int'][1], err = Outils.est_un_alphanumerique(self._donnees['code_int'][1], "le code INT")
erreurs += err
self._donnees['code_ext'][1], err = Outils.est_un_alphanumerique(self._donnees['code_ext'][1], "le code EXT")
erreurs += err
self._donnees['commerciale'][1], err = Outils.est_un_alphanumerique(self._donnees['commerciale'][1], "le com.")
erreurs += err
self._donnees['canal'][1], err = Outils.est_un_alphanumerique(self._donnees['canal'][1], "le canal")
erreurs += err
self._donnees['secteur'][1], err = Outils.est_un_alphanumerique(self._donnees['secteur'][1], "le secteur")
erreurs += err
self._donnees['devise'][1], err = Outils.est_un_alphanumerique(self._donnees['devise'][1], "la devise")
erreurs += err
self._donnees['financier'][1], err = Outils.est_un_alphanumerique(self._donnees['financier'][1], "le financier")
erreurs += err
self._donnees['fonds'][1], err = Outils.est_un_alphanumerique(self._donnees['fonds'][1], "le fonds")
erreurs += err
self._donnees['entete'][1], err = Outils.est_un_texte(self._donnees['entete'][1], "l'entête", vide=True)
erreurs += err
self._donnees['poste_reservation'][1], err = Outils.est_un_entier(self._donnees['poste_reservation'][1],
"le poste réservation", min=1, max=9)
erreurs += err
self._donnees['lien'][1], err = Outils.est_un_chemin(self._donnees['lien'][1], "le lien")
erreurs += err
self._donnees['chemin'][1], err = Outils.est_un_chemin(self._donnees['chemin'][1], "le chemin")
erreurs += err
self._donnees['chemin_propre'][1], err = Outils.est_un_chemin(self._donnees['chemin_propre'][1],
"le chemin propre")
erreurs += err
self._donnees['chemin_filigrane'][1], err = Outils.est_un_chemin(self._donnees['chemin_filigrane'][1],
"le chemin filigrane")
erreurs += err
for intitule in self._donnees['intitule_n'][1:]:
intitule, err = Outils.est_un_texte(intitule, "l'intitulé N")
erreurs += err
for code_s in self._donnees['code_sap'][1:]:
code_s, err = Outils.est_un_entier(code_s, "le code sap", min=1)
erreurs += err
for code_sq in self._donnees['code_sap_qas'][1:]:
code_sq, err = Outils.est_un_entier(code_sq, "le code sap qas", min=1)
erreurs += err
for quantite in self._donnees['quantite'][1:]:
quantite, err = Outils.est_un_nombre(quantite, "la quantité", arrondi=3, min=0)
erreurs += err
for unite in self._donnees['unite'][1:]:
unite, err = Outils.est_un_texte(unite, "l'unité")
erreurs += err
for type_prix in self._donnees['type_prix'][1:]:
type_prix, err = Outils.est_un_alphanumerique(type_prix, "le type de prix")
erreurs += err
for type_rabais in self._donnees['type_rabais'][1:]:
type_rabais, err = Outils.est_un_alphanumerique(type_rabais, "le type de rabais")
erreurs += err
for texte_sap in self._donnees['texte_sap'][1:]:
texte_sap, err = Outils.est_un_texte(texte_sap, "le texte sap", vide=True)
erreurs += err
for intitule_long in self._donnees['intitule_long'][1:]:
intitule_long, err = Outils.est_un_texte(intitule_long, "l'intitulé long")
erreurs += err
for intitule_court in self._donnees['intitule_court'][1:]:
intitule_court, err = Outils.est_un_texte(intitule_court, "l'intitulé court")
erreurs += err
for modes in self._donnees['modes'][1:]:
modes, err = Outils.est_un_alphanumerique(modes, "le mode d'envoi", vide=True)
erreurs += err
self._donnees['min_fact_rese'][1], err = Outils.est_un_nombre(
self._donnees['min_fact_rese'][1], "le montant minimum pour des frais de facturation", arrondi=2, min=0)
erreurs += err
codes_n = []
for nn in self._donnees['code_n'][1:]:
nn, err = Outils.est_un_alphanumerique(nn, "le code N")
erreurs += err
if nn not in codes_n:
codes_n.append(nn)
else:
erreurs += "le code N '" + nn + "' n'est pas unique\n"
codes_d = []
for dd in self._donnees['code_d'][1:]:
dd, err = Outils.est_un_alphanumerique(dd, "le code D")
erreurs += err
if dd not in codes_d:
codes_d.append(dd)
else:
erreurs += "le code D '" + dd + "' n'est pas unique\n"
len_ok = True
if len(self._donnees['code_n']) != len(self._donnees['intitule_n']) or \
len(self._donnees['code_n']) != len(self._donnees['code_ref_fact']) or \
len(self._donnees['code_n']) != len(self._donnees['avantage_HC']) or \
len(self._donnees['code_n']) != len(self._donnees['subsides']) or \
len(self._donnees['code_n']) != len(self._donnees['rabais_excep']) or \
len(self._donnees['code_n']) != len(self._donnees['filtrer_article_nul']):
len_ok = False
erreurs += "le nombre de colonees doit être le même pour le code N, l'intitulé N, " \
"le code référence du client, l'avantage HC, le mode subsides, le mode rabais exceptionnel et " \
"le filtre articles nuls\n"
if len_ok:
for i in range(1, len(self._donnees['code_n'])):
if self._donnees['code_ref_fact'][i] != 'INT' and self._donnees['code_ref_fact'][i] != 'EXT':
erreurs += "le code référence client doit être INT ou EXT\n"
if self._donnees['avantage_HC'][i] != 'BONUS' and self._donnees['avantage_HC'][i] != 'RABAIS':
erreurs += "l'avantage HC doit être BONUS ou RABAIS\n"
if self._donnees['subsides'][i] != 'BONUS' and self._donnees['subsides'][i] != 'RABAIS':
erreurs += "le mode subsides doit être BONUS ou RABAIS\n"
if self._donnees['rabais_excep'][i] != 'BONUS' and self._donnees['rabais_excep'][i] != 'RABAIS':
erreurs += "le mode rabais exceptionnel doit être BONUS ou RABAIS\n"
if self._donnees['filtrer_article_nul'][i] != 'OUI' and self._donnees['filtrer_article_nul'][i] != 'NON':
erreurs += "le filtre articles nuls doit être OUI ou NON\n"
if len(self._donnees['code_d']) != len(self._donnees['code_sap']) or \
len(self._donnees['code_d']) != len(self._donnees['quantite']) or \
len(self._donnees['code_d']) != len(self._donnees['unite']) or \
len(self._donnees['code_d']) != len(self._donnees['type_prix']) or \
len(self._donnees['code_d']) != len(self._donnees['intitule_long']) or \
len(self._donnees['code_d']) != len(self._donnees['intitule_court']) or \
len(self._donnees['code_d']) != len(self._donnees['type_rabais']) or \
len(self._donnees['code_d']) != len(self._donnees['texte_sap']):
erreurs += "le nombre de colonnes doit être le même pour le code D, le code SAP, la quantité, l'unité, " \
"le type de prix, le type de rabais, le texte SAP, l'intitulé long et l'intitulé court\n"
if len(self._donnees['centre'][1]) > 70:
erreurs += "le string du paramètre centre est trop long"
if erreurs != "":
Outils.fatal(ErreurConsistance(), self.libelle + "\n" + erreurs)
def est_coherent(self, subgeneraux, subcomptes):
"""
vérifie que les données du fichier importé sont cohérentes
:param subgeneraux: paramètres généraux
: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
categories = []
couples = []
donnees_dict = {}
for donnee in self.donnees:
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"
if donnee['categorie'] == "":
msg += "la catégorie de la ligne " + str(ligne) + " ne peut être vide\n"
elif donnee['categorie'] not in subgeneraux.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['categorie'] != "") and (donnee['id_compte'] != ""):
couple = [donnee['categorie'], donnee['id_compte']]
if couple not in couples:
couples.append(couple)
else:
msg += "Couple categorie '" + donnee['categorie'] + "' et compte id '" + \
donnee['id_compte'] + "' de la ligne " + str(ligne) + " pas unique\n"
donnee['max_mois'], info = Outils.est_un_nombre(donnee['max_mois'], "le maximum mois", ligne)
msg += info
donnee['max_compte'], info = Outils.est_un_nombre(donnee['max_compte'], "le maximum compte", ligne)
msg += info
donnees_dict[donnee['id_compte'] + donnee['categorie']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
for categorie in subgeneraux.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 plafonds de prestations\n"
for categorie in categories:
for id_compte in subcomptes.obtenir_ids():
couple = [categorie, id_compte]
if couple not in couples:
msg += "Couple categorie '" + categorie + "' et compte id '" + \
id_compte + "' n'existe pas\n"
if msg != "":
msg = self.libelle + "\n" + 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 est_coherent(self, comptes, machines, 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 machines: machines importées
: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
donnees_list = []
for donnee in self.donnees:
if donnee['id_compte'] == "":
msg += "le id compte de la ligne " + str(ligne) + " ne peut être vide\n"
elif comptes.contient_id(donnee['id_compte']) == 0:
msg += "le id compte '" + donnee['id_compte'] + "' de la ligne " + str(ligne) + " n'est pas référencé\n"
elif donnee['id_compte'] not in self.comptes:
self.comptes.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"
if donnee['id_user'] == "":
msg += "le user id de la ligne " + str(ligne) + " ne peut être vide\n"
elif users.contient_id(donnee['id_user']) == 0:
msg += "le user id '" + donnee['id_user'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
if donnee['type'] == "":
msg += "HP/HC " + str(ligne) + " ne peut être vide\n"
elif donnee['type'] != "HP" and donnee['type'] != "HC":
msg += "HP/HC " + str(ligne) + " doit être égal à HP ou HC\n"
donnee['penalite'], info = Outils.est_un_nombre(donnee['penalite'], "la pénalité", ligne, 2, 0)
msg += info
donnee['date_debut'], info = Outils.est_une_date(donnee['date_debut'], "la date de début", 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
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self, generaux, couts):
"""
vérifie que les données du fichier importé sont cohérentes,
et efface les colonnes mois et année
:param generaux: paramètres généraux
:param couts: catégories coûts 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 = {}
natures = []
couples = []
ids = []
del self.donnees[0]
for donnee in self.donnees:
if donnee['nature'] == "":
msg += "la nature client de la ligne " + str(
ligne) + " ne peut être vide\n"
elif donnee['nature'] not in generaux.obtenir_code_n():
msg += "la nature client de la ligne " + str(
ligne) + " n'existe pas dans les codes N\n"
elif donnee['nature'] not in natures:
if donnee['nature'] not in natures:
natures.append(donnee['nature'])
else:
msg += "la nature '" + donnee['nature'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['id_cat_cout'] == "":
msg += "l'id cout " + str(ligne) + " ne peut être vide\n"
elif couts.contient_id(donnee['id_cat_cout']) == 0:
msg += "l'id cout de la ligne " + str(
ligne) + " n'existe pas dans les catégories coûts\n"
elif donnee['id_cat_cout'] not in ids:
ids.append(donnee['id_cat_cout'])
if (donnee['id_cat_cout'] != "") and (donnee['nature'] != ""):
couple = [donnee['id_cat_cout'], donnee['nature']]
if couple not in couples:
couples.append(couple)
else:
msg += "Couple id cout '" + donnee['id_cat_cout'] + "' et nature '" + \
donnee['nature'] + "' de la ligne " + str(ligne) + " pas unique\n"
donnee['prix_h_mach_p'], info = Outils.est_un_nombre(
donnee['prix_h_mach_p'], "le prix horaire machine ", ligne)
msg += info
donnee['prix_h_mo_o'], info = Outils.est_un_nombre(
donnee['prix_h_mo_o'], "le prix horaire main d'oeuvre", ligne)
msg += info
donnees_dict[donnee['nature'] + donnee['id_cat_cout']] = donnee
ligne += 1
self.donnees = donnees_dict
self.verifie_coherence = 1
for code_n in generaux.obtenir_code_n():
if code_n not in natures:
msg += "La nature '" + code_n + "' dans les paramètres généraux n'est pas présente dans " \
"les catégories prix\n"
for id_cout in ids:
for nature in natures:
couple = [id_cout, nature]
if couple not in couples:
msg += "Couple id cout '" + id_cout + "' et nature client '" + \
nature + "' n'existe pas\n"
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self, comptes, machines, 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 machines: machines importées
: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
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['id_compte'] not in self.comptes:
self.comptes.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"
if donnee['id_user'] == "":
msg += "le user id de la ligne " + str(
ligne) + " ne peut être vide\n"
elif users.contient_id(donnee['id_user']) == 0:
msg += "le user id '" + donnee['id_user'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
if donnee['id_op'] == "":
msg += "l'id opérateur de la ligne " + str(
ligne) + " ne peut être vide\n"
elif users.contient_id(donnee['id_op']) == 0:
msg += "l'id opérateur '" + donnee['id_op'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
donnee['duree_machine_hp'], info = Outils.est_un_nombre(
donnee['duree_machine_hp'], "la durée machine hp", ligne, 4, 0)
msg += info
donnee['duree_machine_hc'], info = Outils.est_un_nombre(
donnee['duree_machine_hc'], "la durée machine hc", ligne, 4, 0)
msg += info
donnee['duree_operateur'], info = Outils.est_un_nombre(
donnee['duree_operateur'], "la durée opérateur", ligne, 4, 0)
msg += info
donnee['date_login'], info = Outils.est_une_date(
donnee['date_login'], "la date de login", ligne)
msg += info
donnee['remarque_op'], info = Outils.est_un_texte(
donnee['remarque_op'], "la remarque opérateur", ligne, True)
msg += info
donnee['remarque_staff'], info = Outils.est_un_texte(
donnee['remarque_staff'], "la remarque staff", ligne, True)
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
Outils.affiche_message(msg)
return 1
return 0
def est_coherent(self, generaux, clients):
"""
vérifie que les données du fichier importé sont cohérentes
:param generaux: paramètres généraux
: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_list = []
for donnee in self.donnees:
if donnee['position'] == "":
msg += "la position de la ligne " + str(
ligne) + " ne peut être vide\n"
donnee['position'], info = Outils.est_un_nombre(
donnee['position'], "la position", ligne)
msg += info
donnee['position'] = int(donnee['position'])
if donnee['position'] < 1:
msg += " la position de la ligne " + str(
ligne) + " doit être un entier > 0\n"
if donnee['Annexe-pièces'] == "":
msg += "le annexe P.J. de la ligne " + str(
ligne) + " ne peut être vide\n"
if not (donnee['Annexe-pièces'] == "OUI"
or donnee['Annexe-pièces'] == "NON"):
msg += "le annexe P.J. de la ligne " + str(
ligne) + " doit être 'OUI' ou 'NON'\n"
if donnee['Annexe-interne'] == "":
msg += "le annexe Int de la ligne " + str(
ligne) + " ne peut être vide\n"
if not (donnee['Annexe-interne'] == "OUI"
or donnee['Annexe-interne'] == "NON"):
msg += "le annexe Int de la ligne " + str(
ligne) + " doit être 'OUI' ou 'NON'\n"
if donnee['nature'] != "" and donnee[
'nature'] not in generaux.obtenir_code_n():
msg += "la nature '" + donnee['nature'] + "' de la ligne " + str(ligne) +\
" n'existe pas dans les types N\n"
if donnee['code'] != "" and donnee[
'code'] not in clients.obtenir_codes():
msg += "le code client '" + donnee[
'code'] + "' de la ligne " + str(
ligne) + " n'est pas référencé\n"
donnee['chemin'] = Outils.chemin(
[self._chemin, donnee['nom'] + ".pdf"])
if not Outils.existe(donnee['chemin']):
msg += "le fichier PDF '" + donnee[
'nom'] + "' de la ligne " + str(ligne) + " n'existe pas\n"
donnees_list.append(donnee)
ligne += 1
self.donnees = donnees_list
self.verifie_coherence = 1
if msg != "":
msg = self.libelle + "\n" + msg
Outils.affiche_message(msg)
return 1
return 0
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 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
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_a'], info = Outils.est_un_nombre(
donnee['coef_a'], "le coefficient A", ligne)
msg += info
donnee['coef_b'], info = Outils.est_un_nombre(
donnee['coef_b'], "le coefficient B", ligne)
msg += info
donnee['coef_c'], info = Outils.est_un_nombre(
donnee['coef_c'], "le coefficient C", ligne)
msg += info
donnee['coef_d'], info = Outils.est_un_nombre(
donnee['coef_d'], "le coefficient D", ligne)
msg += info
donnee['coef_e'], info = Outils.est_un_nombre(
donnee['coef_e'], "le coefficient E", ligne)
msg += info
donnee['coef_mo'], info = Outils.est_un_nombre(
donnee['coef_mo'], "le coefficient MO", ligne)
msg += info
donnee['coef_r'], info = Outils.est_un_nombre(
donnee['coef_r'], "le coefficient R", 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, comptes, prestations, users):
"""
vérifie que les données du fichier importé sont cohérentes (id compte parmi comptes,
id prestation parmi prestations), et efface les colonnes mois et année
:param comptes: comptes importés
:param prestations: prestations importées
: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
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['id_compte'] not in self.comptes:
self.comptes.append(donnee['id_compte'])
if donnee['id_prestation'] == "":
msg += "le prestation id de la ligne " + str(ligne) + " ne peut être vide\n"
elif prestations.contient_id(donnee['id_prestation']) == 0:
msg += "le prestation id '" + donnee['id_prestation'] + "' 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 users.contient_id(donnee['id_user']) == 0:
msg += "le user id '" + donnee['id_user'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
donnee['quantite'], info = Outils.est_un_nombre(donnee['quantite'], "la quantité", ligne)
msg += info
donnee['rabais'], info = Outils.est_un_nombre(donnee['rabais'], "le rabais", 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
Outils.affiche_message(msg)
return 1
return 0
def generer(self, trans_vals, grants, plafonds, paramtexte, paramannexe, par_client, comptes, clients, subsides,
generaux):
"""
génération des fichiers d'annexes subsides à partir des transactions
:param trans_vals: valeurs des transactions générées
:param grants: grants importés
:param plafonds: plafonds importés
:param paramtexte: paramètres textuels
:param paramannexe: paramètres d'annexe
:param par_client: tri des transactions par client, par compte, par code D
:param comptes: comptes importés
:param clients: clients importés
:param subsides: subsides importés
:param generaux: paramètres généraux
"""
for donnee in paramannexe.donnees:
if donnee['nom'] == 'Annexe-détails':
self.chemin = donnee['chemin']
self.dossier = donnee['dossier']
dossier_destination = DossierDestination(self.chemin)
clients_comptes = {}
for id_compte in comptes.donnees.keys():
compte = comptes.donnees[id_compte]
if self.version > 0 and self.unique != compte['code_client']:
continue
type_s = compte['type_subside']
if type_s != "":
if type_s in subsides.donnees.keys():
subside = subsides.donnees[type_s]
if subside['debut'] != 'NULL':
debut, info = Outils.est_une_date(subside['debut'], "la date de début")
if info != "":
Outils.affiche_message(info)
else:
debut = 'NULL'
if subside['fin'] != 'NULL':
fin, info = Outils.est_une_date(subside['fin'], "la date de fin")
if info != "":
Outils.affiche_message(info)
else:
fin = 'NULL'
premier, dernier = calendar.monthrange(self.annee, self.mois)
if debut == "NULL" or debut <= datetime(self.annee, self.mois, dernier):
if fin == "NULL" or fin >= datetime(self.annee, self.mois, 1):
code_client = compte['code_client']
if code_client not in clients_comptes:
clients_comptes[code_client] = []
clients_comptes[code_client].append(id_compte)
for code in clients_comptes.keys():
cc = clients_comptes[code]
self.valeurs = {}
ii = 0
client = clients.donnees[code]
self.nom = self.prefixe + "_" + code + "_" + client['abrev_labo'] + ".csv"
for id_compte in cc:
compte = comptes.donnees[id_compte]
type_s = compte['type_subside']
subside = subsides.donnees[type_s]
for code_d in generaux.obtenir_code_d():
plaf = type_s + code_d
if plaf in plafonds.donnees.keys():
plafond = plafonds.donnees[plaf]
donnee = [client['code'], client['abrev_labo'], compte['id_compte'], compte['intitule'],
compte['type_subside'], code_d, generaux.intitule_long_par_code_d(code_d),
subside['intitule'], subside['debut'], subside['fin'], plafond['max_compte'],
plafond['max_mois']]
subs = 0
g_id = id_compte + code_d
if g_id in grants.donnees.keys():
grant, info = Outils.est_un_nombre(grants.donnees[g_id]['montant'], "le montant de grant",
min=0, arrondi=2)
if info != "":
Outils.affiche_message(info)
else:
grant = 0
if code in par_client and id_compte in par_client[code]['comptes']:
par_code = par_client[code]['comptes'][id_compte]
if code_d in par_code.keys():
tbtr = par_code[code_d]
for indice in tbtr:
val, info = Outils.est_un_nombre(trans_vals[indice]['subsid-CHF'], "le subside CHF",
arrondi=2)
subs += val
reste = plafond['max_compte'] - grant - subs
donnee += [round(grant, 2), round(subs, 2), round(reste, 2)]
self.ajouter_valeur(donnee, ii)
ii += 1
self.csv(dossier_destination, paramtexte)
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, 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 est_coherent(self, categories):
"""
vérifie que les données du fichier importé sont cohérentes (id machine unique, id catégorie cout référencé,
catégorie machine référencé dans les coefficients machines), 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:
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'])
else:
msg += "l'id machine '" + donnee['id_machine'] + "' de la ligne " + str(ligne) +\
" n'est pas unique\n"
if donnee['id_cat_mach'] == "":
msg += "l'id catégorie machine de la ligne " + str(ligne) + " ne peut être vide\n"
elif categories.contient_id(donnee['id_cat_mach']) == 0:
msg += "l'id catégorie machine '" + donnee['id_cat_mach'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
if donnee['id_cat_mo'] == "":
msg += "l'id catégorie opérateur de la ligne " + str(ligne) + " ne peut être vide\n"
elif categories.contient_id(donnee['id_cat_mo']) == 0:
msg += "l'id catégorie opérateur '" + donnee['id_cat_mo'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
if donnee['îd_cat_plat'] == "":
msg += "l'id catégorie plateforme de la ligne " + str(ligne) + " ne peut être vide\n"
elif categories.contient_id(donnee['îd_cat_plat']) == 0:
msg += "l'id catégorie plateforme '" + donnee['îd_cat_plat'] + "' de la ligne " + str(ligne) \
+ " n'est pas référencé\n"
if donnee['id_cat_cher'] == "":
msg += "l'id catégorie onéreux de la ligne " + str(ligne) + " ne peut être vide\n"
elif categories.contient_id(donnee['id_cat_cher']) == 0:
msg += "l'id catégorie onéreux '" + donnee['id_cat_cher'] + "' 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)
msg += info
if donnee['tx_rabais_hc'] < 0 or donnee['tx_rabais_hc'] > 100:
msg += "le rabais heures creuse '" + str(donnee['tx_rabais_hc']) + "' de la ligne " + str(ligne) \
+ " doit être entre 0 et 100\n"
donnee['tx_occ_eff_hp'], info = Outils.est_un_nombre(donnee['tx_occ_eff_hp'],
"le taux effectif d'occupation HP", ligne)
msg += info
if donnee['tx_occ_eff_hp'] < 0 or donnee['tx_occ_eff_hp'] > 100:
msg += "le taux effectif d'occupation HP '" + str(donnee['tx_occ_eff_hp']) + "' de la ligne " \
+ str(ligne) + " doit être entre 0 et 100\n"
donnee['tx_penalite_hp'], info = Outils.est_un_nombre(donnee['tx_penalite_hp'], "la pénalité HP", ligne)
msg += info
if donnee['tx_penalite_hp'] < 0 or donnee['tx_penalite_hp'] > 100:
msg += "la pénalité HP '" + str(donnee['tx_penalite_hp']) + "' de la ligne " + str(ligne) \
+ " doit être entre 0 et 100\n"
donnee['tx_occ_eff_hc'], info = Outils.est_un_nombre(donnee['tx_occ_eff_hc'],
"le taux effectif d'occupation HC", ligne)
msg += info
if donnee['tx_occ_eff_hc'] < 0 or donnee['tx_occ_eff_hc'] > 100:
msg += "le taux d'occupation HC '" + str(donnee['tx_occ_eff_hc']) + "' de la ligne " + str(ligne) \
+ " doit être entre 0 et 100\n"
donnee['tx_penalite_hc'], info = Outils.est_un_nombre(donnee['tx_penalite_hc'], "la pénalité HC", ligne)
msg += info
if donnee['tx_penalite_hc'] < 0 or donnee['tx_penalite_hc'] > 100:
msg += "la pénalité HC '" + str(donnee['tx_penalite_hc']) + "' de la ligne " + str(ligne) \
+ " doit être entre 0 et 100\n"
donnee['delai_sans_frais'], info = Outils.est_un_nombre(donnee['delai_sans_frais'], "le délai sans frais",
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, 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
