def Importation(onlyNonVentiles=True, IDcompte_payeur=None): DB = GestionDB.DB() if IDcompte_payeur != None: conditionCompte = "WHERE IDcompte_payeur=%d" % IDcompte_payeur else: conditionCompte = "" # Récupère les comptes payeurs req = """SELECT IDcompte_payeur, IDfamille FROM comptes_payeurs %s ORDER BY IDcompte_payeur ;""" % conditionCompte DB.ExecuterReq(req) listeComptes = DB.ResultatReq() # Mémorise les IDfamille listeIDfamille = [IDfamille for temp, IDfamille in listeComptes] # Récupère la ventilation req = """SELECT IDcompte_payeur, SUM(montant) AS total_ventilations FROM ventilation %s GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" % conditionCompte DB.ExecuterReq(req) listeVentilations = DB.ResultatReq() dictVentilations = {} for IDcompte_payeur, total_ventilations in listeVentilations: dictVentilations[IDcompte_payeur] = total_ventilations # Récupère les prestations req = """SELECT IDcompte_payeur, SUM(montant) AS total_prestations FROM prestations %s GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" % conditionCompte DB.ExecuterReq(req) listePrestations = DB.ResultatReq() dictPrestations = {} for IDcompte_payeur, total_prestations in listePrestations: dictPrestations[IDcompte_payeur] = total_prestations # Récupère les règlements req = """SELECT IDcompte_payeur, SUM(montant) AS total_reglements FROM reglements %s GROUP BY IDcompte_payeur ORDER BY IDcompte_payeur ;""" % conditionCompte DB.ExecuterReq(req) listeReglements = DB.ResultatReq() dictReglements = {} for IDcompte_payeur, total_reglements in listeReglements: dictReglements[IDcompte_payeur] = total_reglements DB.Close() # Récupération des titulaires de familles dictTitulaires = UTILS_Titulaires.GetTitulaires( listeIDfamille=listeIDfamille) # Traitement des données listeListeView = [] for IDcompte_payeur, IDfamille in listeComptes: if IDcompte_payeur in dictVentilations: total_ventilations = FloatToDecimal( dictVentilations[IDcompte_payeur]) else: total_ventilations = FloatToDecimal(0.0) if IDcompte_payeur in dictPrestations: total_prestations = FloatToDecimal( dictPrestations[IDcompte_payeur]) else: total_prestations = FloatToDecimal(0.0) if IDcompte_payeur in dictReglements: total_reglements = FloatToDecimal(dictReglements[IDcompte_payeur]) else: total_reglements = FloatToDecimal(0.0) item = (IDcompte_payeur, IDfamille, total_ventilations, total_reglements, total_prestations) track = Track(dictTitulaires, item) if onlyNonVentiles == True: # Afficher seulement ceux qui sont mal ventilés if track.reste_a_ventiler > FloatToDecimal(0.0): listeListeView.append(track) else: # Afficher toute la liste listeListeView.append(track) return listeListeView
def GetListeFamilles(listview=None, listeActivites=None, presents=None, IDfamille=None, infosIndividus=None): """ Récupération des infos familles """ # Conditions Activites if listeActivites == None or listeActivites == []: conditionActivites = "" else: if len(listeActivites) == 1: conditionActivites = " AND inscriptions.IDactivite=%d" % listeActivites[ 0] else: conditionActivites = " AND inscriptions.IDactivite IN %s" % str( tuple(listeActivites)) # Conditions Présents conditionPresents = "" jointurePresents = "" if presents != None: conditionPresents = " AND (consommations.date>='%s' AND consommations.date<='%s' AND consommations.etat IN ('reservation', 'present'))" % ( str(presents[0]), str(presents[1])) jointurePresents = "LEFT JOIN consommations ON consommations.IDindividu = individus.IDindividu" # Condition Famille donnée conditionFamilles = "" if IDfamille != None: conditionFamilles = " AND familles.IDfamille=%d" % IDfamille # Récupération des régimes et num d'alloc pour chaque famille DB = GestionDB.DB() req = """ SELECT familles.IDfamille, regimes.nom, caisses.nom, num_allocataire FROM familles LEFT JOIN inscriptions ON inscriptions.IDfamille = familles.IDfamille LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu %s AND inscriptions.IDfamille = familles.IDfamille LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse LEFT JOIN regimes ON regimes.IDregime = caisses.IDregime WHERE familles.etat IS NULL AND inscriptions.statut='ok' AND (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s') %s %s %s GROUP BY familles.IDfamille ;""" % (jointurePresents, datetime.date.today(), conditionActivites, conditionPresents, conditionFamilles) DB.ExecuterReq(req) listeFamilles = DB.ResultatReq() DB.Close() # Formatage des données listeListeView = [] titulaires = UTILS_Titulaires.GetTitulaires() for IDfamille, nomRegime, nomCaisse, numAlloc in listeFamilles: dictTemp = {} if IDfamille != None and IDfamille in titulaires: nomTitulaires = titulaires[IDfamille]["titulairesSansCivilite"] rue = titulaires[IDfamille]["adresse"]["rue"] cp = titulaires[IDfamille]["adresse"]["cp"] ville = titulaires[IDfamille]["adresse"]["ville"] listeMails = titulaires[IDfamille]["listeMails"] secteur = titulaires[IDfamille]["adresse"]["nomSecteur"] else: nomTitulaires = _(u"Aucun titulaire") rue = u"" cp = u"" ville = u"" listeMails = [] dictTemp = { "IDfamille": IDfamille, "titulaires": nomTitulaires, "nomRegime": nomRegime, "nomCaisse": nomCaisse, "numAlloc": numAlloc, "secteur": secteur, "rue": rue, "cp": cp, "ville": ville, "listeMails": listeMails, } # Formatage sous forme de TRACK track = TrackFamille(listview, dictTemp, infosIndividus) listeListeView.append(track) return listeListeView
def SetListeDonnees(self, IDcompte_payeur=None): self.listeNoms = [] self.dictAdresses = {} self.dictDonnees = {} # Si on vient d'une fiche familiale : On affiche uniquement la famille en cours DB = GestionDB.DB() req = """SELECT IDrattachement, rattachements.IDindividu, rattachements.IDfamille, IDcategorie, titulaire, nom, prenom, IDcivilite, adresse_auto, rue_resid, cp_resid, ville_resid FROM rattachements LEFT JOIN individus ON individus.IDindividu = rattachements.IDindividu LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = rattachements.IDfamille WHERE comptes_payeurs.IDcompte_payeur=%d and titulaire=1 and IDcategorie=1 ORDER BY IDrattachement;""" % IDcompte_payeur DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeTitulaires = [] for IDrattachement, IDindividu, IDfamille, IDcategorie, titulaire, nom, prenom, IDcivilite, adresse_auto, rue_resid, cp_resid, ville_resid in listeDonnees: # Recherche du nom des titulaires civilite = self.GetCivilite(IDcivilite) nomIndividu = u"%s%s %s" % (civilite, nom, prenom) listeTitulaires.append((IDindividu, nomIndividu)) # Recherche de l'adresse adresseComplete = u"" if rue_resid != None: adresseComplete += rue_resid if cp_resid != None: adresseComplete += u" " + cp_resid if ville_resid != None: adresseComplete += u" " + ville_resid self.dictAdresses[IDindividu] = { "adresse_auto": adresse_auto, "adresseComplete": adresseComplete } nbreTitulaires = len(listeTitulaires) if nbreTitulaires == 0: nomTitulaires = _(u"Pas de titulaires !") if nbreTitulaires == 1: nomTitulaires = listeTitulaires[0][1] if nbreTitulaires == 2: nomTitulaires = _(u"%s et %s") % (listeTitulaires[0][1], listeTitulaires[1][1]) if nbreTitulaires > 2: nomTitulaires = "" for IDindividu, nomTitulaire in listeTitulaires[:-2]: nomTitulaires += u"%s, " % nomTitulaire nomTitulaires += listeTitulaires[-1][1] self.listeNoms.append(nomTitulaires) self.dictDonnees[0] = IDindividu index = 1 for IDindividu, nomTitulaire in listeTitulaires: if nomTitulaire != nomTitulaires: self.listeNoms.append(nomTitulaire) self.dictDonnees[index] = IDindividu index += 1 # Remplissage du contrôle self.SetItems(self.listeNoms) if len(self.listeNoms) > 0: self.Select(0)
def MAJ(self, forcerActualisation=False): condition = "" DB = GestionDB.DB() # Recherche des paramètres parametres = UTILS_Config.GetParametre( "nbre_inscrits_parametre_activites", defaut=None) if parametres != None: code, liste = parametres.split("###") if liste != "": listeID = [] for ID in liste.split(";"): listeID.append(int(ID)) if code == "liste_groupes_activites": req = """SELECT IDtype_groupe_activite, IDactivite FROM groupes_activites WHERE IDtype_groupe_activite IN %s ;""" % GestionDB.ConvertConditionChaine(listeID) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() listeActivites = [] for IDtype_groupe_activite, IDactivite in listeDonnees: listeActivites.append(IDactivite) condition = "AND activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine( listeActivites) if code == "liste_activites": condition = "AND activites.IDactivite IN %s" % GestionDB.ConvertConditionChaine( listeID) # Tri tri = UTILS_Config.GetParametre("nbre_inscrits_parametre_tri", 3) if tri == 0: tri = "activites.nom" elif tri == 1: tri = "activites.date_debut" elif tri == 2: tri = "activites.date_fin" else: tri = "activites.nom" # Sens sens = UTILS_Config.GetParametre("nbre_inscrits_parametre_sens", 1) if sens == 0: sens = "" else: sens = "DESC" # Seuil d'alerte self.seuil_alerte = UTILS_Config.GetParametre( "nbre_inscrits_parametre_alerte", 5) # Récupération des groupes req = """SELECT groupes.IDgroupe, groupes.IDactivite, groupes.nom, groupes.nbre_inscrits_max, COUNT(inscriptions.IDinscription) as nbre_inscriptions FROM groupes LEFT JOIN activites ON activites.IDactivite = groupes.IDactivite LEFT JOIN inscriptions ON inscriptions.IDgroupe = groupes.IDgroupe WHERE inscriptions.statut='ok' %s GROUP BY groupes.IDgroupe ORDER BY groupes.ordre ;""" % condition DB.ExecuterReq(req) listeGroupes = DB.ResultatReq() dictGroupes = {} for IDgroupe, IDactivite, nom, nbre_inscrits_max, nbre_inscrits in listeGroupes: if nbre_inscrits_max == None: nbre_inscrits_max = 0 if nbre_inscrits == None: nbre_inscrits = 0 if nom == None: nom = _(u"Sans nom !") if dictGroupes.has_key(IDactivite) == False: dictGroupes[IDactivite] = [] dictGroupes[IDactivite].append({ "IDgroupe": IDgroupe, "nom": nom, "nbre_inscrits_max": nbre_inscrits_max, "nbre_inscrits": nbre_inscrits, "IDactivite": IDactivite }) # Récupération des activités activite_ouverte = UTILS_Config.GetParametre( "nbre_inscrits_parametre_ouvert", 1) if activite_ouverte == 1: if condition == "": condition = "WHERE activites.date_fin>='%s'" % str( datetime.date.today()) else: condition += " AND activites.date_fin>='%s'" % str( datetime.date.today()) req = """SELECT activites.IDactivite, activites.nom, activites.nbre_inscrits_max FROM activites %s GROUP BY activites.IDactivite ;""" % condition DB.ExecuterReq(req) listeActivites = DB.ResultatReq() DB.Close() listeActivitesTemp = [] for IDactivite, nom, nbre_inscrits_max in listeActivites: if nbre_inscrits_max == None: nbre_inscrits_max = 0 if nom == None: nom = _(u"Sans nom !") liste_groupes = [] if dictGroupes.has_key(IDactivite): liste_groupes = dictGroupes[IDactivite] nbre_inscrits = 0 liste_infos = [ nom, ] for dictGroupe in liste_groupes: nbre_inscrits += dictGroupe["nbre_inscrits"] liste_infos.append(dictGroupe["nom"]) listeActivitesTemp.append({ "IDactivite": IDactivite, "nom": nom, "nbre_inscrits_max": nbre_inscrits_max, "nbre_inscrits": nbre_inscrits, "liste_groupes": liste_groupes, "infos": " ".join(liste_infos) }) # Pour éviter l'actualisation de l'affichage si aucune modification des données if self.listeActivites != listeActivitesTemp or forcerActualisation == True: self.listeActivites = listeActivitesTemp else: return # MAJ du contrôle self.Freeze() self.DeleteAllItems() self.dictRenderers = {} index = 0 for dictActivite in self.listeActivites: if self.filtre == None or (self.filtre.lower() in dictActivite["infos"].lower()): couleur_fond = UTILS_Interface.GetValeur( "couleur_tres_claire", wx.Colour(214, 250, 199)) # Colonne Activité label = u" " + dictActivite["nom"] self.InsertStringItem(index, label) self.SetItemPyData(index, dictActivite) self.SetItemBackgroundColour(index, couleur_fond) item = self.GetItem(index, 0) font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT) font.SetWeight(wx.BOLD) item.SetFont(font) self.SetItem(item) # Colonne Gauge renderer = Renderer_gauge(self) renderer.SetValeurs( mode="activite", couleur_fond=couleur_fond, nbre_inscrits=dictActivite["nbre_inscrits"], nbre_inscrits_max=dictActivite["nbre_inscrits_max"]) self.dictRenderers[index] = renderer self.SetItemCustomRenderer(index, 1, renderer) index += 1 for dictGroupe in dictActivite["liste_groupes"]: label = u" " + dictGroupe["nom"] self.InsertStringItem(index, label) self.SetItemPyData(index, dictGroupe) # Colonne Gauge renderer = Renderer_gauge(self) renderer.SetValeurs( mode="groupe", nbre_inscrits=dictGroupe["nbre_inscrits"], nbre_inscrits_max=dictGroupe["nbre_inscrits_max"]) self.dictRenderers[index] = renderer self.SetItemCustomRenderer(index, 1, renderer) index += 1 # Ajuste la taille des colonnes self.SetColumnWidth(0, wx.LIST_AUTOSIZE) self.SetColumnWidth(1, ULC.ULC_AUTOSIZE_FILL) # Actualiser l'affichage pour éviter bug de positionnement try: self.DoLayout() except: pass self.Thaw()
def EnvoiEmail(self, event=None): """ Envoi par Email des attestations fiscales """ # Validation des données saisies tracks = self.ctrl_attestations.GetTracksCoches() if len(tracks) == 0 : dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune attestation à imprimer !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Création des cotisations sélectionnées dictOptions = self.GetOptions() if dictOptions == False : return False x = UTILS_Attestations_fiscales.Attestations_fiscales() resultat = x.Impression(tracks=tracks, nomDoc=None, afficherDoc=False, dictOptions=dictOptions, repertoire=dictOptions["repertoire"], repertoireTemp=True) if resultat == False : return False dictChampsFusion, dictPieces = resultat def SupprimerFichiersTemp(): for IDcompte_payeur, fichier in dictPieces.iteritems() : os.remove(fichier) # Récupération de toutes les adresses Emails DB = GestionDB.DB() req = """SELECT IDindividu, mail, travail_mail FROM individus;""" DB.ExecuterReq(req) listeAdressesIndividus = DB.ResultatReq() DB.Close() dictAdressesIndividus = {} for IDindividu, mail, travail_mail in listeAdressesIndividus : dictAdressesIndividus[IDindividu] = {"perso" : mail, "travail" : travail_mail} # Récupération des données adresse + champs + pièces listeDonnees = [] listeAnomalies = [] listeEnvoiNonDemande = [] for track in tracks : adresse = UTILS_Envoi_email.GetAdresseFamille(track.IDfamille, choixMultiple=False, muet=True, nomTitulaires=track.nomsTitulaires) # Mémorisation des données if adresse not in (None, "", []) : if dictPieces.has_key(track.IDcompte_payeur) : fichier = dictPieces[track.IDcompte_payeur] champs = dictChampsFusion[track.IDcompte_payeur] listeDonnees.append({"adresse" : adresse, "pieces" : [fichier,], "champs" : champs}) else : listeAnomalies.append(track.nomsTitulaires) # Annonce les anomalies trouvées if len(listeAnomalies) > 0 : texte = _(u"%d des familles sélectionnées n'ont pas d'adresse Email.\n\n") % len(listeAnomalies) texte += _(u"Souhaitez-vous quand même continuer avec les %d autres familles ?") % len(listeDonnees) dlg = wx.MessageDialog(self, texte, _(u"Avertissement"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_EXCLAMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES : SupprimerFichiersTemp() return # Dernière vérification avant transfert if len(listeDonnees) == 0 : dlg = wx.MessageDialog(self, _(u"Il ne reste finalement aucune attestation fiscale à envoyer par Email !"), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() SupprimerFichiersTemp() return # Transfert des données vers DLG Mailer import DLG_Mailer dlg = DLG_Mailer.Dialog(self, categorie="attestation_fiscale") dlg.SetDonnees(listeDonnees, modificationAutorisee=False) dlg.ChargerModeleDefaut() dlg.ShowModal() dlg.Destroy() # Suppression des PDF temporaires SupprimerFichiersTemp()
def GetListeRappels(self): dictTitulaires = UTILS_Titulaires.GetTitulaires() DB = GestionDB.DB() # Conditions listeConditions = [] if self.IDcompte_payeur != None: listeConditions.append("rappels.IDcompte_payeur = %d" % self.IDcompte_payeur) # 1ère série de filtres if self.filtres != None: for filtre in self.filtres: # IDrappel_intervalle if filtre["type"] == "IDrappel_intervalle": listeConditions.append( "(rappels.IDrappel>=%d AND rappels.IDrappel<=%d)" % (filtre["IDrappel_min"], filtre["IDrappel_max"])) # IDrappel_liste if filtre["type"] == "IDrappel_liste": if len(filtre["liste"]) == 0: listeTemp = "()" elif len(filtre["liste"]) == 1: listeTemp = "(%d)" % filtre["liste"][0] else: listeTemp = str(tuple(filtre["liste"])) listeConditions.append("rappels.IDrappel IN %s" % listeTemp) # Lot de rappels if filtre["type"] == "lot": listeConditions.append("rappels.IDlot=%d" % filtre["IDlot"]) # Date d'émission if filtre["type"] == "date_emission": listeConditions.append( "(rappels.date_edition>='%s' AND rappels.date_edition<='%s')" % (filtre["date_min"], filtre["date_max"])) # Date de référence if filtre["type"] == "date_reference": listeConditions.append( "(rappels.date_reference>='%s' AND rappels.date_reference<='%s')" % (filtre["date_min"], filtre["date_max"])) # numero_intervalle if filtre["type"] == "numero_intervalle": listeConditions.append( "(rappels.numero>=%d AND rappels.numero<=%d)" % (filtre["numero_min"], filtre["numero_max"])) # numero_liste if filtre["type"] == "numero_liste": if len(filtre["liste"]) == 0: listeTemp = "()" elif len(filtre["liste"]) == 1: listeTemp = "(%d)" % filtre["liste"][0] else: listeTemp = str(tuple(filtre["liste"])) listeConditions.append("rappels.numero IN %s" % listeTemp) if len(listeConditions) > 0: conditions = "WHERE %s" % " AND ".join(listeConditions) else: conditions = "" # Récupération des rappels req = """ SELECT rappels.IDrappel, rappels.numero, rappels.IDcompte_payeur, rappels.date_edition, rappels.date_reference, rappels.IDutilisateur, rappels.date_min, rappels.date_max, rappels.solde, comptes_payeurs.IDfamille, rappels.IDlot, lots_rappels.nom, textes_rappels.IDtexte, textes_rappels.label FROM rappels LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = rappels.IDcompte_payeur LEFT JOIN lots_rappels ON lots_rappels.IDlot = rappels.IDlot LEFT JOIN textes_rappels ON textes_rappels.IDtexte = rappels.IDtexte %s ORDER BY rappels.date_edition ;""" % conditions DB.ExecuterReq(req) listeRappels = DB.ResultatReq() # Infos Prélèvement + Envoi par Email des factures if self.IDcompte_payeur != None: conditions = "WHERE comptes_payeurs.IDcompte_payeur = %d" % self.IDcompte_payeur else: conditions = "" req = """ SELECT prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque, prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville, email_factures, comptes_payeurs.IDcompte_payeur FROM familles LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = familles.IDfamille %s ;""" % conditions DB.ExecuterReq(req) listeInfosFamilles = DB.ResultatReq() dictInfosFamilles = {} for prelevement_activation, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_cle, prelevement_banque, prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville, email_factures, IDcompte_payeur in listeInfosFamilles: dictInfosFamilles[IDcompte_payeur] = { "prelevement_activation": prelevement_activation, "prelevement_etab": prelevement_etab, "prelevement_guichet": prelevement_guichet, "prelevement_numero": prelevement_numero, "prelevement_cle": prelevement_cle, "prelevement_banque": prelevement_banque, "prelevement_individu": prelevement_individu, "prelevement_nom": prelevement_nom, "prelevement_rue": prelevement_rue, "prelevement_cp": prelevement_cp, "prelevement_ville": prelevement_ville, "email_factures": email_factures, } DB.Close() listeResultats = [] for IDrappel, numero, IDcompte_payeur, date_edition, date_reference, IDutilisateur, date_min, date_max, solde, IDfamille, IDlot, nomLot, IDtexte, labeltexte in listeRappels: if numero == None: numero = 0 date_edition = UTILS_Dates.DateEngEnDateDD(date_edition) date_min = UTILS_Dates.DateEngEnDateDD(date_min) date_max = UTILS_Dates.DateEngEnDateDD(date_max) date_reference = UTILS_Dates.DateEngEnDateDD(date_reference) titulaires = dictTitulaires[IDfamille]["titulairesSansCivilite"] dictTemp = { "IDrappel": IDrappel, "numero": numero, "IDcompte_payeur": IDcompte_payeur, "date_edition": date_edition, "date_reference": date_reference, "IDutilisateur": IDutilisateur, "date_min": date_min, "date_max": date_max, "solde": solde, "IDfamille": IDfamille, "titulaires": titulaires, "IDlot": IDlot, "nomLot": nomLot, "IDtexte": IDtexte, "labelTexte": labeltexte, } if dictInfosFamilles.has_key(IDcompte_payeur): dictTemp.update(dictInfosFamilles[IDcompte_payeur]) valide = True # 2ème série de filtres if self.filtres != None: for filtre in self.filtres: # IDrappel_intervalle if filtre["type"] == "solde": if self.ComparateurFiltre(-solde, filtre["operateur"], filtre["montant"]) == False: valide = False if filtre["type"] == "email": if filtre["choix"] == True: if dictTemp["email_factures"] == None: valide = False else: if dictTemp["email_factures"] != None: valide = False # Mémorisation des valeurs if valide == True: listeResultats.append(dictTemp) return listeResultats
def ArchiverFichiers(self): """ Archivage des fichiers traités """ archiver = False # Récupère stats nbreTotal = 0 nbreTraites = 0 nbreNonTraites = 0 nbreOk = 0 nbreErreurs = 0 for track in self.ctrl_donnees.donnees: nbreTotal += 1 if track.statut != None: nbreTraites += 1 if track.statut == None: nbreNonTraites += 1 if track.statut == "ok": nbreOk += 1 if track.statut == "erreur": nbreErreurs += 1 #print nbreTotal, nbreTraites, nbreNonTraites, nbreOk, nbreErreurs # Si aucun traités if nbreTraites == 0: return True # Si des erreurs ont été trouvées if nbreErreurs > 0 or nbreNonTraites > 0: if nbreErreurs > 0 and nbreNonTraites == 0: intro = _( u"%d erreurs ont été trouvées lors de l'importation. " ) % nbreErreurs if nbreErreurs == 0 and nbreNonTraites > 0: intro = _( u"%d actions n'ont pas été traitées. ") % nbreNonTraites if nbreErreurs > 0 and nbreNonTraites > 0: intro = _( u"%d actions n'ont pas été traitées et %d erreurs ont été trouvées. " ) % (nbreErreurs, nbreNonTraites) dlg = wx.MessageDialog( self, _(u"%s\n\nConfirmez-vous tout de même l'archivage des fichiers de synchronisation traités ?\n(Si vous choisissez Non, les fichiers seront conservés)" ) % intro, _(u"Archivage"), wx.YES_NO | wx.CANCEL | wx.YES_DEFAULT | wx.ICON_QUESTION) reponse = dlg.ShowModal() dlg.Destroy() if reponse == wx.ID_CANCEL: return False if reponse == wx.ID_YES: archiver = True # Si tous ont été traités avec succès if nbreOk == nbreTotal: archiver = True # Archivage if archiver == True: # Récupération de la liste des fichiers if self.listeFichiers == None: listeFichiers = self.ctrl_donnees.listeFichiersTrouves else: listeFichiers = self.listeFichiers DB = GestionDB.DB() for nomFichier in listeFichiers: # Renommage et archivage if nomFichier.endswith(".archive") == False: # Renommage nomTemp = UTILS_Fichiers.GetRepSync( nomFichier.replace(".dat", ".archive")) if os.path.isfile(nomTemp) == True: os.remove(nomTemp) os.rename(UTILS_Fichiers.GetRepSync(nomFichier), nomTemp) # Mémorisation de l'archivage dans la base nomFichierTemp = nomFichier.replace(".dat", "").replace( ".archive", "") ID_appareil = self.ctrl_donnees.dictIDappareil[ nomFichierTemp] IDarchive = DB.ReqInsert("nomade_archivage", [("nom_fichier", nomFichierTemp), ("ID_appareil", ID_appareil), ("date", datetime.date.today())]) DB.Close()
def SauvegardeFactures(self): """ Sauvegarde des factures """ # Récupère Utilisateur en cours IDutilisateur = UTILS_Identification.GetIDutilisateur() # Génération des factures listeFacturesGenerees = [] # Tri par ordre alphabétique de la liste listeComptes = [] for track in self.ctrl_factures.GetTracksCoches(): listeComptes.append((track.nomSansCivilite, track.IDcompte_payeur)) listeComptes.sort() # ProgressBar dlgProgress = wx.ProgressDialog(_(u"Génération des factures"), _(u"Initialisation..."), maximum=len(listeComptes), parent=None, style=wx.PD_SMOOTH | wx.PD_AUTO_HIDE | wx.PD_APP_MODAL) # Sélection du prochain numéro de facture numero = self.parent.dictParametres["prochain_numero"] IDprefixe = self.parent.dictParametres["IDprefixe"] if numero == None: # Recherche du prochain numéro de facture si mode AUTO if IDprefixe == None: conditions = "WHERE IDprefixe IS NULL" else: conditions = "WHERE IDprefixe=%d" % IDprefixe DB = GestionDB.DB() req = """SELECT MAX(numero) FROM factures %s;""" % conditions DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if listeDonnees[0][0] == None: numero = 1 else: numero = listeDonnees[0][0] + 1 # Sauvegarde DB = GestionDB.DB() try: index = 0 for nomTitulaires, IDcompte_payeur in listeComptes: dictCompte = self.ctrl_factures.dictComptes[IDcompte_payeur] texte = _(u"Génération de la facture %d sur %d...") % ( index + 1, len(listeComptes)) self.EcritStatusbar(texte) dlgProgress.Update(index + 1, texte) listePrestations = dictCompte["listePrestations"] total = dictCompte["total"] regle = dictCompte["ventilation"] solde = total - regle # Date échéance date_echeance = dictCompte["date_echeance"] # Liste des activités texteActivites = "" for IDactivite in dictCompte["liste_activites"]: texteActivites += "%d;" % IDactivite if len(dictCompte["liste_activites"]) > 0: texteActivites = texteActivites[:-1] # Liste des individus texteIndividus = "" for IDindividu in list(dictCompte["individus"].keys()): texteIndividus += "%d;" % IDindividu if len(list(dictCompte["individus"].keys())) > 0: texteIndividus = texteIndividus[:-1] # Sauvegarde de la facture listeDonnees = [ ("IDprefixe", IDprefixe), ("numero", numero), ("IDcompte_payeur", IDcompte_payeur), ("date_edition", str(datetime.date.today())), ("date_echeance", date_echeance), ("activites", texteActivites), ("individus", texteIndividus), ("IDutilisateur", IDutilisateur), ("date_debut", str(dictCompte["date_debut"])), ("date_fin", str(dictCompte["date_fin"])), ("total", float(total)), ("regle", float(regle)), ("solde", float(solde)), ("IDlot", self.parent.dictParametres["IDlot"]), ("prestations", ";".join(self.parent.dictParametres["prestations"])), ("IDregie", self.parent.dictParametres["IDregie"]), ] IDfacture = DB.ReqInsert("factures", listeDonnees) # Attribution des IDfacture à chaque prestation for IDindividu, IDprestation in listePrestations: if dictCompte["individus"][IDindividu]["select"] == True: listeDonnees = [ ("IDfacture", IDfacture), ] DB.ReqMAJ("prestations", listeDonnees, "IDprestation", IDprestation) listeFacturesGenerees.append(IDfacture) numero += 1 index += 1 DB.Close() self.EcritStatusbar(u"") dlgProgress.Destroy() except Exception as err: DB.Close() dlgProgress.Destroy() traceback.print_exc(file=sys.stdout) dlg = wx.MessageDialog( self, _(u"Désolé, le problème suivant a été rencontré : \n\n%s" ) % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() self.EcritStatusbar(u"") return False self.EcritStatusbar(u"") return listeFacturesGenerees
def Supprimer(self, event): ## if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("parametrage_categories_comptables", "supprimer") == False : return if len(self.Selection()) == 0: dlg = wx.MessageDialog( self, _(u"Vous n'avez sélectionné aucune opération à supprimer dans la liste !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return track = self.Selection()[0] if track.IDvirement == None and track.IDreleve != None: dlg = wx.MessageDialog( self, _(u"Vous ne pouvez pas supprimer une opération pointée sur un relevé bancaire !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return if track.IDvirement != None: # Vérifie que les 2 opérations du virement ne sont pas sur un relevé DB = GestionDB.DB() req = """SELECT IDoperation, compta_operations.IDreleve, compta_releves.nom, comptes_bancaires.nom FROM compta_operations LEFT JOIN compta_releves ON compta_releves.IDreleve = compta_releves.IDreleve LEFT JOIN comptes_bancaires ON comptes_bancaires.IDcompte = compta_releves.IDcompte_bancaire WHERE IDvirement=%d ;""" % track.IDvirement DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() for IDoperation, IDreleve, nomReleve, nomCompte in listeDonnees: if IDreleve != None: dlg = wx.MessageDialog( self, _(u"Vous ne pouvez pas supprimer ce virement car il a déjà été pointé sur le relevé '%s' du compte '%s' !" ) % (nomReleve, nomCompte), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return # Suppression dlg = wx.MessageDialog( self, _(u"Souhaitez-vous vraiment supprimer cette opération ?"), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION) if dlg.ShowModal() == wx.ID_YES: DB = GestionDB.DB() if track.IDvirement == None: DB.ReqDEL("compta_operations", "IDoperation", track.IDoperation) DB.ReqDEL("compta_ventilation", "IDoperation", track.IDoperation) else: DB.ReqDEL("compta_virements", "IDvirement", track.IDvirement) DB.ReqDEL("compta_operations", "IDvirement", track.IDvirement) DB.Close() self.MAJ() dlg.Destroy()
def GetListeUtilisateurs(nomFichier=""): """ Récupère la liste des utilisateurs et de leurs droits """ DB = GestionDB.DB(nomFichier=nomFichier) # Droits req = """SELECT IDdroit, IDutilisateur, IDmodele, categorie, action, etat FROM droits;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictDroitsUtilisateurs = {} dictDroitsModeles = {} for IDdroit, IDutilisateur, IDmodele, categorie, action, etat in listeDonnees : key = (categorie, action) if IDutilisateur != None : if dictDroitsUtilisateurs.has_key(IDutilisateur) == False : dictDroitsUtilisateurs[IDutilisateur] = {} dictDroitsUtilisateurs[IDutilisateur][key] = etat if IDmodele != None : if dictDroitsModeles.has_key(IDmodele) == False : dictDroitsModeles[IDmodele] = {} dictDroitsModeles[IDmodele][key] = etat # Utilisateurs req = """SELECT IDutilisateur, sexe, nom, prenom, mdp, mdpcrypt, profil, actif FROM utilisateurs WHERE actif=1;""" resultat = DB.ExecuterReq(req) if resultat == 1 : listeDonnees = DB.ResultatReq() else : # Fonction provisoire pour pouvoir ouvrir Noethys avant la version 1.1.8.7. req = """SELECT IDutilisateur, sexe, nom, prenom, mdp, profil, actif FROM utilisateurs WHERE actif=1;""" DB.ExecuterReq(req) listeDonneesTemp = DB.ResultatReq() listeDonnees = [] for IDutilisateur, sexe, nom, prenom, mdp, profil, actif in listeDonneesTemp : if mdp < 60 : mdpcrypt = SHA256.new(mdp.encode('utf-8')).hexdigest() else : mdpcrypt = mdp listeDonnees.append((IDutilisateur, sexe, nom, prenom, mdp, mdpcrypt, profil, actif)) listeUtilisateurs = [] # chargement avatars try : req = """SELECT IDutilisateur, image FROM utilisateurs;""" DB.ExecuterReq(req) listeAvatars = DB.ResultatReq() except : pass dictAvatars = {} for IDutilisateur, image in listeAvatars : dictAvatars[IDutilisateur] = image for IDutilisateur, sexe, nom, prenom, mdp, mdpcrypt, profil, actif in listeDonnees : droits = None if profil.startswith("administrateur") : droits = None if profil.startswith("modele") : IDmodele = int(profil.split(":")[1]) if dictDroitsModeles.has_key(IDmodele) : droits = dictDroitsModeles[IDmodele] if profil.startswith("perso") : if dictDroitsUtilisateurs.has_key(IDutilisateur) : droits = dictDroitsUtilisateurs[IDutilisateur] # Avatar if dictAvatars.has_key(IDutilisateur) : image = dictAvatars[IDutilisateur] else : image = "Automatique" dictTemp = { "IDutilisateur":IDutilisateur, "nom":nom, "prenom":prenom, "sexe":sexe, "mdp":mdp, "mdpcrypt" : mdpcrypt, "profil":profil, "actif":actif, "image":image, "droits":droits } listeUtilisateurs.append(dictTemp) DB.Close() return listeUtilisateurs
def OnBoutonOk(self, event): dictOptions = self.ctrl_parametres.GetOptions() if dictOptions == False: return # Récupération des paramètres listeIDfactures = [] montantTotal = 0.0 for track in self.tracks: listeIDfactures.append(track.IDfacture) montantTotal += -track.solde if len(listeIDfactures) == 0: conditionFactures = "()" elif len(listeIDfactures) == 1: conditionFactures = "(%d)" % listeIDfactures[0] else: conditionFactures = str(tuple(listeIDfactures)) DB = GestionDB.DB() req = """ SELECT prestations.IDprestation, prestations.IDfacture, prestations.label, prestations.montant, prestations.IDindividu, individus.nom, individus.prenom, prestations.IDactivite, activites.nom FROM prestations LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite WHERE prestations.IDfacture IN %s GROUP BY prestations.IDprestation ORDER BY prestations.date ;""" % conditionFactures DB.ExecuterReq(req) listePrestations = DB.ResultatReq() # Récupération des prélèvements req = """SELECT prelevements.IDprelevement, prelevements.prelevement_iban, prelevements.IDfacture, lots_prelevements.date, prelevement_reference_mandat, titulaire FROM prelevements LEFT JOIN lots_prelevements ON lots_prelevements.IDlot = prelevements.IDlot WHERE prelevements.IDfacture IN %s ;""" % conditionFactures DB.ExecuterReq(req) listePrelevements = DB.ResultatReq() # Pièces PES ORMC req = """SELECT pes_pieces.IDpiece, pes_pieces.prelevement_iban, pes_pieces.IDfacture, pes_lots.date_prelevement, pes_pieces.prelevement_IDmandat, pes_pieces.prelevement_titulaire FROM pes_pieces LEFT JOIN pes_lots ON pes_lots.IDlot = pes_pieces.IDlot WHERE pes_pieces.prelevement_IDmandat IS NOT NULL AND pes_pieces.prelevement=1 AND pes_pieces.IDfacture IN %s ;""" % conditionFactures DB.ExecuterReq(req) listePieces = DB.ResultatReq() dictPrelevements = {} for listeDonneesPrel in (listePrelevements, listePieces): for IDprelevement, iban, IDfacture, datePrelevement, rum, titulaire in ( listeDonneesPrel): datePrelevement = UTILS_Dates.DateEngFr(datePrelevement) dictPrelevements[IDfacture] = { "IDprelevement": IDprelevement, "datePrelevement": datePrelevement, "iban": iban, "rum": rum, "titulaire": titulaire } DB.Close() # Calcul totaux prélèvements nbrFactPrelev = len(dictPrelevements) montantTotalPrelev = 0.0 for track in self.tracks: if dictPrelevements.has_key(track.IDfacture): montantTotalPrelev += -track.solde dictPrestations = {} dictIndividus = {} dictActivites = {} dictTotaux = {} for IDprestation, IDfacture, label, montant, IDindividu, nom, prenom, IDactivite, nomActivite in listePrestations: if dictActivites != None and dictActivites.has_key( IDactivite) == False: dictActivites[IDactivite] = nomActivite if IDindividu != None and dictIndividus.has_key( IDindividu) == False and prenom != None: dictIndividus[IDindividu] = u"%s %s" % (nom, prenom) if dictPrestations.has_key(IDfacture) == False: dictPrestations[IDfacture] = {} if dictPrestations[IDfacture].has_key(IDindividu) == False: dictPrestations[IDfacture][IDindividu] = {} if dictPrestations[IDfacture][IDindividu].has_key(label) == False: dictPrestations[IDfacture][IDindividu][label] = { "quantite": 0, "montant": 0.0, "IDactivite": IDactivite } if dictTotaux.has_key(IDactivite) == False: dictTotaux[IDactivite] = {} if dictTotaux[IDactivite].has_key(label) == False: dictTotaux[IDactivite][label] = {"quantite": 0, "montant": 0.0} dictTotaux[IDactivite][label]["quantite"] += 1 dictTotaux[IDactivite][label]["montant"] += montant dictPrestations[IDfacture][IDindividu][label]["quantite"] += 1 dictPrestations[IDfacture][IDindividu][label]["montant"] += montant # Création du PDF from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak from reportlab.platypus.flowables import ParagraphAndImage, Image from reportlab.rl_config import defaultPageSize from reportlab.lib.units import inch, cm from reportlab.lib.utils import ImageReader from reportlab.lib import colors from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle self.hauteur_page = defaultPageSize[1] self.largeur_page = defaultPageSize[0] # Initialisation du PDF PAGE_WIDTH, PAGE_HEIGHT = defaultPageSize nomDoc = FonctionsPerso.GenerationNomDoc("RECAP_FACTURES", "pdf") if sys.platform.startswith("win"): nomDoc = nomDoc.replace("/", "\\") doc = SimpleDocTemplate(nomDoc, topMargin=30, bottomMargin=30) story = [] largeurContenu = 520 # Création du titre du document def Header(): dataTableau = [] largeursColonnes = ((420, 100)) dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today())) dataTableau.append( (dictOptions["titre_texte"], _(u"%s\nEdité le %s") % (UTILS_Organisateur.GetNom(), dateDuJour))) style = TableStyle([ ('BOX', (0, 0), (-1, -1), 0.25, colors.black), ('VALIGN', (0, 0), (-1, -1), 'TOP'), ('ALIGN', (0, 0), (0, 0), ConvertAlignement1(dictOptions["titre_alignement"])), ('FONT', (0, 0), (0, 0), "Helvetica-Bold", dictOptions["titre_taille_texte"]), ('ALIGN', (1, 0), (1, 0), 'RIGHT'), ('FONT', (1, 0), (1, 0), "Helvetica", 6), ]) tableau = Table(dataTableau, largeursColonnes) tableau.setStyle(style) story.append(tableau) story.append(Spacer(0, 20)) # Insère un header Header() couleurFond1 = ConvertCouleurWXpourPDF(dictOptions["couleur_fond_1"]) couleurFond2 = ConvertCouleurWXpourPDF(dictOptions["couleur_fond_2"]) styleIntroduction = ParagraphStyle( name="introduction", fontName="Helvetica", alignment=ConvertAlignement2(dictOptions["intro_alignement"]), fontSize=dictOptions["intro_taille_texte"], spaceAfter=0, leading=8, spaceBefore=0) styleConclusion = ParagraphStyle( name="conclusion", fontName="Helvetica", alignment=ConvertAlignement2(dictOptions["conclusion_alignement"]), fontSize=dictOptions["conclusion_taille_texte"], spaceAfter=0, leading=8, spaceBefore=0) styleLabel = ParagraphStyle(name="label", fontName="Helvetica", alignment=1, fontSize=5, spaceAfter=0, leading=8, spaceBefore=0) styleTexte = ParagraphStyle(name="label", fontName="Helvetica", alignment=0, fontSize=7, spaceAfter=0, leading=8, spaceBefore=0) styleTexte2 = ParagraphStyle(name="label", fontName="Helvetica", alignment=1, fontSize=7, spaceAfter=0, leading=8, spaceBefore=0) styleMontant = ParagraphStyle(name="label", fontName="Helvetica", alignment=2, fontSize=7, spaceAfter=0, leading=8, spaceBefore=0) # Intro story.append(Paragraph(dictOptions["intro_texte"], styleIntroduction)) story.append(Spacer(0, 20)) # Factures if dictOptions["type_document"] in (0, 1): for track in self.tracks: numero = track.numero if track.etat == "annulation": numero = u"%s (Annulée)" % numero solde = track.solde if solde != 0.0: solde = -solde # Numéro de facture dataTableau = [] largeursColonnes = [100, 100, largeurContenu - 100 - 100] dataTableau.append(( _(u"Facture n°%s") % numero, u"%.2f %s" % (solde, SYMBOLE), _(u"Edité le %s | Echéance le %s | Période du %s au %s") % (UTILS_Dates.DateDDEnFr(track.date_edition), UTILS_Dates.DateDDEnFr(track.date_echeance), UTILS_Dates.DateDDEnFr(track.date_debut), UTILS_Dates.DateDDEnFr(track.date_fin)), )) tableau = Table(dataTableau, largeursColonnes) listeStyles = [ ('FONT', (0, 0), (1, -1), "Helvetica-Bold", 7), ('FONT', (2, -1), (2, -1), "Helvetica", 6), ('BACKGROUND', (0, 0), (-1, -1), couleurFond1), ('ALIGN', (2, -1), (2, -1), 'RIGHT'), ('BOX', (0, 0), (-1, -1), 0.25, colors.black), ] tableau.setStyle(TableStyle(listeStyles)) story.append(tableau) # Famille if track.prelevement == True: if dictPrelevements.has_key(track.IDfacture): textePrelevement = _( u"IBAN : %s | RUM : %s | Titulaire : %s | Le : %s " ) % (dictPrelevements[track.IDfacture]["iban"], dictPrelevements[track.IDfacture]["rum"], dictPrelevements[track.IDfacture]["titulaire"], dictPrelevements[ track.IDfacture]["datePrelevement"]) else: textePrelevement = _( u"N° Compte : %s | Etab : %s | Guichet : %s | Clé : %s | Titulaire : %s" ) % (track.prelevement_numero, track.prelevement_etab, track.prelevement_guichet, track.prelevement_cle, track.prelevement_payeur) else: textePrelevement = u"" if track.adresse_famille["rue"] != None: rue = track.adresse_famille["rue"] else: rue = u"" if track.adresse_famille["cp"] != None: cp = track.adresse_famille["cp"] else: cp = u"" if track.adresse_famille["ville"] != None: ville = track.adresse_famille["ville"] else: ville = u"" dataTableau = [ (Paragraph(_(u"Famille"), styleLabel), Paragraph(_(u"Adresse"), styleLabel), Paragraph(_(u"Prélèvement bancaire"), styleLabel)), ] largeursColonnes = [180, 140, largeurContenu - 320] dataTableau.append(( Paragraph(track.nomsTitulaires, styleTexte), (Paragraph(rue, styleTexte), Paragraph(u"%s %s" % (cp, ville), styleTexte)), Paragraph(textePrelevement, styleTexte), )) tableau = Table(dataTableau, largeursColonnes) listeStyles = [ ('TOPPADDING', (0, 0), (-1, 0), 0), ('BOTTOMPADDING', (0, 0), (-1, 0), -1), ('FONT', (0, -1), (-1, -1), "Helvetica", 7), ('GRID', (0, 0), (-1, 0), 0.25, colors.black), ('BOX', (0, 1), (-1, 1), 0.25, colors.black), ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), ('BACKGROUND', (0, 0), (-1, 0), couleurFond2), ] tableau.setStyle(TableStyle(listeStyles)) story.append(tableau) # Détail des prestations if dictOptions[ "type_document"] == 0 and dictPrestations.has_key( track.IDfacture): dataTableau = [ (Paragraph(_(u"Individu"), styleLabel), Paragraph(_(u"Activité"), styleLabel), Paragraph(_(u"Prestation"), styleLabel), Paragraph(_(u"Quantité"), styleLabel), Paragraph(_(u"Montant total"), styleLabel)), ] largeursColonnes = [130, 120, 185, 35, 50] for IDindividu, dictLabels in dictPrestations[ track.IDfacture].iteritems(): if dictIndividus.has_key(IDindividu): labelIndividu = dictIndividus[IDindividu] else: labelIndividu = u"" listeActivites = [] listeLabels = [] listeQuantites = [] listeMontants = [] for labelPrestation, dictTemp in dictLabels.iteritems( ): if dictTemp[ "IDactivite"] != None and dictActivites.has_key( dictTemp["IDactivite"]): labelActivite = dictActivites[ dictTemp["IDactivite"]] else: labelActivite = u"" listeActivites.append( Paragraph(labelActivite[:35], styleTexte2)) listeLabels.append( Paragraph(labelPrestation[:40], styleTexte2)) listeQuantites.append( Paragraph(str(dictTemp["quantite"]), styleTexte2)) listeMontants.append( Paragraph( u"%.2f %s" % (dictTemp["montant"], SYMBOLE), styleMontant)) dataTableau.append(( Paragraph(labelIndividu, styleTexte2), listeActivites, listeLabels, listeQuantites, listeMontants, )) tableau = Table(dataTableau, largeursColonnes) listeStyles = [ ('TOPPADDING', (0, 0), (-1, 0), 0), ('BOTTOMPADDING', (0, 0), (-1, 0), -1), ('FONT', (0, -1), (-1, -1), "Helvetica", 7), ('GRID', (0, 0), (-1, -1), 0.25, colors.black), ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), ('BACKGROUND', (0, 0), (-1, 0), couleurFond2), ] tableau.setStyle(TableStyle(listeStyles)) story.append(tableau) story.append(Spacer(0, 10)) # Totaux dataTableau = [ (_(u"Totaux par activités et prestations"), "", "", ""), (Paragraph(_(u"Activités"), styleLabel), Paragraph(_(u"Prestations"), styleLabel), Paragraph(_(u"Quantité"), styleLabel), Paragraph(_(u"Montant"), styleLabel)), ] largeursColonnes = [195, 240, 35, 50] for IDactivite, dictLabels in dictTotaux.iteritems(): if IDactivite == None: nomActivite = _(u"Prestations familiales") else: nomActivite = dictActivites[IDactivite] listeLabels = [] listeQuantites = [] listeMontants = [] quantiteActivite = 0 totalActivite = 0.0 for label, dictTemp in dictLabels.iteritems(): listeLabels.append(Paragraph(label, styleTexte2)) listeQuantites.append( Paragraph(str(dictTemp["quantite"]), styleTexte2)) listeMontants.append( Paragraph(u"%.2f %s" % (dictTemp["montant"], SYMBOLE), styleMontant)) quantiteActivite += dictTemp["quantite"] totalActivite += dictTemp["montant"] listeLabels.append( Paragraph(_(u"<b><i>Total de l'activité</i></b>"), styleTexte2)) listeQuantites.append( Paragraph("<b><i>%d</i></b>" % quantiteActivite, styleTexte2)) listeMontants.append( Paragraph(u"<b><i>%.2f %s</i></b>" % (totalActivite, SYMBOLE), styleMontant)) dataTableau.append(( Paragraph(nomActivite, styleTexte2), listeLabels, listeQuantites, listeMontants, )) tableau = Table(dataTableau, largeursColonnes) listeStyles = [ ('TOPPADDING', (0, 1), (-1, 1), 0), ('BOTTOMPADDING', (0, 1), (-1, 1), -1), ('FONT', (1, -1), (-1, -1), "Helvetica", 7), ('FONT', (0, 0), (0, 0), "Helvetica-Bold", 7), ('BOX', (0, 0), (-1, 0), 0.25, colors.black), ('GRID', (0, 1), (-1, -1), 0.25, colors.black), ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), ('BACKGROUND', (0, 0), (-1, 0), couleurFond1), ('BACKGROUND', (0, 1), (-1, 1), couleurFond2), ] tableau.setStyle(TableStyle(listeStyles)) story.append(tableau) story.append(Spacer(0, 10)) # Texte de conclusion conclusion_texte = dictOptions["conclusion_texte"] conclusion_texte = conclusion_texte.replace("{NBRE_FACTURES}", str(len(self.tracks))) conclusion_texte = conclusion_texte.replace( "{TOTAL_FACTURES}", u"%.2f %s" % (montantTotal, SYMBOLE)) conclusion_texte = conclusion_texte.replace("{NBRE_FACT_PRELEV}", str(nbrFactPrelev)) conclusion_texte = conclusion_texte.replace( "{TOTAL_FACT_PRELEV}", u"%.2f %s" % (montantTotalPrelev, SYMBOLE)) story.append(Paragraph(conclusion_texte, styleConclusion)) # Enregistrement et ouverture du PDF try: doc.build(story) except Exception, err: print "Erreur dans ouverture PDF :", err if "Permission denied" in err: dlg = wx.MessageDialog( None, _(u"Noethys ne peut pas créer le PDF.\n\nVeuillez vérifier qu'un autre PDF n'est pas déjà ouvert en arrière-plan..." ), _(u"Erreur d'édition"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return False
def MAJ(self): """ Importation des données """ if self.majEffectuee == True: return self.IDindividu = self.GetGrandParent().IDindividu if self.IDindividu == None: return # MAJ intiale des contrôles DB = GestionDB.DB() self.ctrl_adresse_auto.MAJ(DB=DB) self.ctrl_secteur.MAJ(DB=DB) self.ctrl_categorie.MAJ(DB=DB) self.listesDiffusionInitiale = [] self.dictDiffusionInitiale = {} self.ctrl_listesdiff.MAJ(DB=DB) if self.ctrl_adresse_auto.GetNbreItems() == 0: self.ctrl_adresse_auto.Enable(False) self.radio_adresse_auto.Enable(False) self.radio_adresse_manuelle.SetValue(True) # Si pas nouvelle fiche -> Importationd des données if self.GetGrandParent().nouvelleFiche == False: # Listes de diffusion req = """SELECT IDabonnement, IDliste FROM abonnements WHERE IDindividu=%d;""" % self.IDindividu DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() listeIDliste = [] for IDabonnement, IDliste in listeDonnees: listeIDliste.append(IDliste) self.listesDiffusionInitiale.append(IDliste) self.dictDiffusionInitiale[IDliste] = IDabonnement self.ctrl_listesdiff.SetIDcoches(listeIDliste) # Adresse req = """SELECT adresse_auto, rue_resid, cp_resid, ville_resid, IDcategorie_travail, profession, employeur, travail_tel, travail_fax, travail_mail, tel_domicile, tel_mobile, tel_fax, mail, IDsecteur, travail_tel_sms, tel_domicile_sms, tel_mobile_sms FROM individus WHERE IDindividu=%d;""" % self.IDindividu DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() if len(listeDonnees) > 0: individu = listeDonnees[0] if individu[0] != None: self.radio_adresse_auto.SetValue(True) self.ctrl_adresse_auto.SetID(individu[0]) else: self.radio_adresse_manuelle.SetValue(True) try: self.ctrl_rue.SetValue(individu[1]) except: pass self.ctrl_ville.SetValueCP(individu[2]) self.ctrl_ville.SetValueVille(individu[3]) self.ctrl_secteur.SetID(individu[14]) # Activité professionnelle self.ctrl_categorie.SetID(individu[4]) try: self.ctrl_profession.SetValue(individu[5]) except: pass try: self.ctrl_employeur.SetValue(individu[6]) except: pass self.ctrl_travail_tel.SetNumero(individu[7]) self.ctrl_travail_fax.SetNumero(individu[8]) self.ctrl_travail_mail.SetMail(individu[9]) # Coords self.ctrl_tel_domicile.SetNumero(individu[10]) self.ctrl_tel_mobile.SetNumero(individu[11]) self.ctrl_tel_fax.SetNumero(individu[12]) self.ctrl_mail.SetMail(individu[13]) self.bouton_tel_travail_sms.SetEtat(individu[15]) self.bouton_tel_domicile_sms.SetEtat(individu[16]) self.bouton_tel_mobile_sms.SetEtat(individu[17]) # Verrouillage utilisateurs if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel( "individus_coordonnees", "modifier", afficheMessage=False) == False: for ctrl in self.GetChildren(): ctrl.Enable(False) # MAJ controles self.OnRadioAdresse(None) DB.Close() self.majEffectuee = True
def OnBoutonOk(self, event): # Récupération et vérification des données saisies categorie = self.ctrl_categorie.GetCategorie() label = self.ctrl_label.GetValue() if label == "" : dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir un intitulé !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_label.SetFocus() return IDactivite = self.ctrl_activite.GetID() IDcategorie_tarif = self.ctrl_categorie_tarif.GetID() IDtarif = self.ctrl_tarif.GetID() code_comptable = self.ctrl_code_comptable.GetValue() if code_comptable == "" : code_comptable = None tva = self.ctrl_tva.GetValue() if tva == 0.0 : tva = None if self.radio_type_familiale.GetValue() == True : public = "famille" else : public = "individu" # Tarification IDtype_quotient = self.ctrl_tarification.GetTypeQuotient() # Validation de la tarification if self.ctrl_tarification.Validation() == False : return False # Sauvegarde de la prestation listeDonnees = [ ("categorie", categorie), ("label", label), ("IDactivite", IDactivite), ("IDtarif", IDtarif), ("IDcategorie_tarif", IDcategorie_tarif), ("code_compta", code_comptable), ("tva", tva), ("public", public), ("IDtype_quotient", IDtype_quotient), ] DB = GestionDB.DB() if self.IDmodele == None : self.IDmodele = DB.ReqInsert("modeles_prestations", listeDonnees) else: DB.ReqMAJ("modeles_prestations", listeDonnees, "IDmodele", self.IDmodele) # Sauvegarde des lignes de tarifs self.ctrl_tarification.Sauvegarde() listeFinaleID = [] for track_ligne in self.track_tarif.lignes: track_ligne.IDmodele = self.IDmodele listeDonnees = track_ligne.Get_listedonnees_pour_db() if track_ligne.IDligne == None: # Ci-dessous pour parer bug de Last_row_id de Sqlite if DB.isNetwork == False: req = """SELECT max(IDligne) FROM tarifs_lignes;""" DB.ExecuterReq(req) listeTemp = DB.ResultatReq() if listeTemp[0][0] == None: newID = 1 else: newID = listeTemp[0][0] + 1 listeDonnees.append(("IDligne", newID)) DB.ReqInsert("tarifs_lignes", listeDonnees) else: # Version MySQL DB.ReqInsert("tarifs_lignes", listeDonnees) else: # Modification DB.ReqMAJ("tarifs_lignes", listeDonnees, "IDligne", track_ligne.IDligne) listeFinaleID.append(track_ligne.IDligne) # Suppression des lignes supprimées for IDligne in self.listeInitialeIDlignes: if IDligne not in listeFinaleID: DB.ReqDEL("tarifs_lignes", "IDligne", IDligne) DB.Close() # Fermeture de la fenêtre self.EndModal(wx.ID_OK)
def OnBoutonOk(self, event): # Récupération et vérification des données saisies dictModele = self.ctrl_modele.GetDictValeurs() if dictModele == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner un modèle dans la liste !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return categorie = dictModele["categorie"] label = dictModele["label"] IDactivite = dictModele["IDactivite"] IDcategorie_tarif = dictModele["IDcategorie_tarif"] IDtarif = dictModele["IDtarif"] code_comptable = dictModele["code_compta"] if code_comptable == "": code_comptable = None tva = dictModele["tva"] if tva == 0.0: tva = None montant = self.ctrl_montant.GetMontant() if montant == None: dlg = wx.MessageDialog( self, _(u"Le montant que vous avez saisi ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_montant.SetFocus() return if self.ctrl_individu.IsEnabled() == True: IDindividu = self.ctrl_individu.GetID() if IDindividu == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner un individu !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_individu.SetFocus() return else: IDindividu = None date = self.ctrl_date.GetDate() if self.ctrl_date.Validation() == False: dlg = wx.MessageDialog(self, _(u"La date ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date.SetFocus() return # Récupération du IDcompte_payeur DB = GestionDB.DB() req = "SELECT IDcompte_payeur FROM familles WHERE IDfamille=%d" % self.IDfamille DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() IDcompte_payeur = listeDonnees[0][0] # Sauvegarde de la prestation listeDonnees = [ ("IDcompte_payeur", IDcompte_payeur), ("date", date), ("categorie", categorie), ("label", label), ("montant_initial", montant), ("montant", montant), ("IDactivite", IDactivite), ("IDtarif", IDtarif), ("IDfamille", self.IDfamille), ("IDindividu", IDindividu), ("temps_facture", None), ("IDcategorie_tarif", IDcategorie_tarif), ("code_compta", code_comptable), ("tva", tva), ] listeDonnees.append(("date_valeur", str(datetime.date.today()))) self.IDprestation = DB.ReqInsert("prestations", listeDonnees) DB.Close() # Fermeture de la fenêtre self.EndModal(wx.ID_OK)
def OnBoutonOk(self, event): date_debut = self.ctrl_date_debut.GetDate() date_fin = self.ctrl_date_fin.GetDate() IDniveau = self.ctrl_niveau.GetNiveau() listeIndividus = self.ctrl_individus.GetCoches() # Vérification de la saisie if date_debut == None : dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir une date de début de période !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date_debut.SetFocus() return if date_fin == None : dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir une date de fin de période !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date_fin.SetFocus() return if IDniveau == None : dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement sélectionner un niveau scolaire !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_niveau.SetFocus() return if len(listeIndividus) == 0 : dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucun individu !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return # Demande de confirmation d'enregistrement dlg = wx.MessageDialog(self, _(u"Confirmez-vous l'inscription de %d individus ?") % len(listeIndividus), _(u"Confirmation"), wx.YES_NO|wx.YES_DEFAULT|wx.CANCEL|wx.ICON_QUESTION) if dlg.ShowModal() != wx.ID_YES : dlg.Destroy() return dlg.Destroy() # Fenêtre d'attente dlgAttente = PBI.PyBusyInfo(_(u"Veuillez patienter durant la procédure d'inscription..."), parent=None, title=_(u"Inscriptions scolaires"), icon=wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Logo.png"), wx.BITMAP_TYPE_ANY)) wx.Yield() # Récupère infos pour historique DB = GestionDB.DB() req = """SELECT ecoles.nom, classes.nom, classes.date_debut, classes.date_fin FROM classes LEFT JOIN ecoles ON ecoles.IDecole = classes.IDecole WHERE classes.IDclasse=%d ;""" % self.IDclasse DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() nomEcole = listeDonnees[0][0] nomClasse = listeDonnees[0][1] date_debut_classe = listeDonnees[0][2] date_fin_classe = listeDonnees[0][3] nomClasse = _(u"%s (Du %s au %s)") % (nomClasse, DateEngFr(date_debut_classe), DateEngFr(date_fin_classe)) nomNiveau = self.ctrl_niveau.GetStringSelection() # Init Sauvegarde listeProblemes = [] nbreValides = 0 DB = GestionDB.DB() for IDindividu in listeIndividus : # Vérifie que l'individu n'est pas déjà inscrit dans une classe sur cette période donneesScolarite = self.parent.GetScolariteIndividu(IDindividu) valide = True for track in donneesScolarite : if date_debut <= track.dateFinDD and date_fin >= track.dateDebutDD : date_debut_temp = DateEngFr(track.date_debut) date_fin_temp = DateEngFr(track.date_fin) nomEcole_temp = track.nomEcole nomClasse_temp = track.nomClasse nomIndividu_temp = u"%s %s" % (track.prenom, track.nom) listeProblemes.append(_(u"- %s (déjà dans la classe de %s du %s au %s)\n") % (nomIndividu_temp, nomClasse_temp, date_debut_temp, date_fin_temp)) valide = False break if valide == True : nbreValides += 1 # Sauvegarde listeDonnees = [ ("IDindividu", IDindividu), ("date_debut", date_debut), ("date_fin", date_fin), ("IDecole", self.IDecole), ("IDclasse", self.IDclasse), ("IDniveau", IDniveau), ] IDscolarite = DB.ReqInsert("scolarite", listeDonnees) # Mémorisation dans l'historique UTILS_Historique.InsertActions([{ "IDindividu" : IDindividu, "IDfamille" : None, "IDcategorie" : 30, "action" : _(u"Inscription scolaire du %s au %s. Ecole : '%s'. Classe : '%s'. Niveau : '%s'") % (DateEngFr(str(date_debut)), DateEngFr(str(date_fin)), nomEcole, nomClasse, nomNiveau) },]) DB.Close() del dlgAttente # Informations if len(listeProblemes) > 0 : message = _(u"%d inscriptions ont été enregistrées sauf pour les individus suivants :\n\n%s") % (nbreValides, "".join(listeProblemes)) else: message = _(u"%d inscriptions ont été enregistrées avec succès.") % nbreValides dlg = wx.MessageDialog(self, message, _(u"Information"), wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() dlg.Destroy() # Fermeture self.EndModal(wx.ID_OK)
def GetTracks(self): """ Récupération des données """ if self.IDcompte_bancaire != None: conditions = "WHERE compta_operations.IDcompte_bancaire=%d" % self.IDcompte_bancaire else: conditions = "" db = GestionDB.DB() req = """SELECT IDoperation, type, date, libelle, compta_operations.IDtiers, compta_operations.IDmode, num_piece, ref_piece, compta_operations.IDcompte_bancaire, compta_operations.IDreleve, montant, compta_operations.observations, compta_operations.IDvirement, compta_tiers.nom, modes_reglements.label, comptes_bancaires.nom, compta_releves.nom FROM compta_operations LEFT JOIN compta_tiers ON compta_tiers.IDtiers = compta_operations.IDtiers LEFT JOIN modes_reglements ON modes_reglements.IDmode = compta_operations.IDmode LEFT JOIN comptes_bancaires ON comptes_bancaires.IDcompte = compta_operations.IDcompte_bancaire LEFT JOIN compta_releves ON compta_releves.IDreleve = compta_operations.IDreleve %s ORDER BY date, IDoperation ;""" % conditions db.ExecuterReq(req) listeDonnees = db.ResultatReq() db.Close() listeListeView = [] solde = 0.0 soldePointe = 0.0 soldeJour = 0.0 for IDoperation, typeOperation, date, libelle, IDtiers, IDmode, num_piece, ref_piece, IDcompte_bancaire, IDreleve, montant, observations, IDvirement, nomTiers, nomMode, nomCompte, nomReleve in listeDonnees: date = UTILS_Dates.DateEngEnDateDD(date) if typeOperation == "debit": montantTemp = -montant else: montantTemp = +montant solde += montantTemp if IDreleve != None: soldePointe += montantTemp if date <= datetime.date.today(): soldeJour += montantTemp dictTemp = { "IDoperation": IDoperation, "typeOperation": typeOperation, "date": date, "libelle": libelle, "IDtiers": IDtiers, "IDmode": IDmode, "num_piece": num_piece, "ref_piece": ref_piece, "IDcompte_bancaire": IDcompte_bancaire, "IDreleve": IDreleve, "montant": montant, "observations": observations, "IDvirement": IDvirement, "nomTiers": nomTiers, "nomMode": nomMode, "nomCompte": nomCompte, "nomReleve": nomReleve, "solde": solde, } track = Track(dictTemp) listeListeView.append(track) self.ctrl_soldes.label_solde_jour.SetLabel( _(u"Solde du jour : %.2f %s") % (soldeJour, SYMBOLE)) self.ctrl_soldes.label_solde_pointe.SetLabel( _(u"Solde pointé : %.2f %s") % (soldePointe, SYMBOLE)) self.ctrl_soldes.label_solde.SetLabel( _(u"Solde final : %.2f %s") % (solde, SYMBOLE)) self.ctrl_soldes.Layout() return listeListeView
def Supprimer(self, event): if self.IDcompte_payeur == None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel( "facturation_rappels", "supprimer") == False: return if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0: dlg = wx.MessageDialog( self, _(u"Vous n'avez sélectionné aucune lettre de rappel à supprimer dans la liste !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return if len(self.GetTracksCoches()) > 0: # Suppression multiple listeSelections = self.GetTracksCoches() dlg = wx.MessageDialog( self, _(u"Souhaitez-vous vraiment supprimer les %d lettres de rappel cochées ?" ) % len(listeSelections), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return else: # Suppression unique listeSelections = self.Selection() dlg = wx.MessageDialog( self, _(u"Souhaitez-vous vraiment supprimer la lettre de rappel n°%d ?" ) % listeSelections[0].numero, _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return # Suppression des lettres de rappel listeIDrappels = [] for track in listeSelections: listeIDrappels.append(track.IDrappel) dlgAttente = PBI.PyBusyInfo( _(u"Suppression des lettres de rappel en cours..."), parent=None, title=_(u"Veuillez patienter..."), icon=wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Logo.png"), wx.BITMAP_TYPE_ANY)) wx.Yield() DB = GestionDB.DB() for IDrappel in listeIDrappels: DB.ReqDEL("rappels", "IDrappel", IDrappel) DB.Close() del dlgAttente # MAJ du listeView self.MAJ() # Confirmation de suppression dlg = wx.MessageDialog( self, _(u"%d lettres(s) de rappel supprimée(s) avec succès.") % len(listeSelections), _(u"Suppression"), wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() dlg.Destroy()
def OnBoutonOk(self, event): # Validation nom = self.ctrl_nom.GetValue() if nom == "" : dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement saisir un nom pour ce modèle !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_nom.SetFocus() return False IDrestaurateur = self.ctrl_restaurateur.GetID() if IDrestaurateur == None : dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucun restaurateur.\n\nEtes-vous sûr de vouloir continuer ?"), _(u"Information"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES : return False if self.ctrl_colonnes.Validation() == False : return False colonnes = self.ctrl_colonnes.GetColonnes() # Récupération des données dictDonnees = self.GetDonnees() # Sauvegarde DB = GestionDB.DB() # Sauvegarde du modèle listeDonnees = [ ("nom", nom), ("IDrestaurateur", IDrestaurateur), ("parametres", None), ] if self.premierModele == True : listeDonnees.append(("defaut", 1)) if self.IDmodele == None : self.IDmodele = DB.ReqInsert("modeles_commandes", listeDonnees) else: DB.ReqMAJ("modeles_commandes", listeDonnees, "IDmodele", self.IDmodele) # Sauvegarde des colonnes index = 0 listeIDcolonne = [] dictCorrespondancesID = {} for dictColonne in colonnes : IDcolonne = dictColonne["IDcolonne"] listeDonnees = [ ("IDmodele", self.IDmodele), ("ordre", index), ("nom", dictColonne["nom"]), ("largeur", dictColonne["largeur"]), ("categorie", dictColonne["categorie"]), ("parametres", six.text_type(dictColonne["parametres"])), ] if IDcolonne == None or IDcolonne < 0 : newIDcolonne = DB.ReqInsert("modeles_commandes_colonnes", listeDonnees) dictCorrespondancesID[IDcolonne] = int(newIDcolonne) # Convertit l'IDnégatif en IDpositif dictColonne["IDcolonne"] = newIDcolonne else: DB.ReqMAJ("modeles_commandes_colonnes", listeDonnees, "IDcolonne", IDcolonne) listeIDcolonne.append(IDcolonne) index += 1 # Echange l'IDnégatif contre IDpositif dans les paramètres des colonnes de total if len(dictCorrespondancesID) > 0 : for dictColonne in colonnes: if dictColonne["categorie"] == "numerique_total" and ("colonnes" in dictColonne["parametres"]) == True : listeID = dictColonne["parametres"]["colonnes"] listeNewID = [] for IDcolonne in listeID: if IDcolonne < 0 : IDcolonne = dictCorrespondancesID[IDcolonne] listeNewID.append(IDcolonne) if listeID != listeNewID : dictColonne["parametres"]["colonnes"] = listeNewID listeDonnees = [("parametres", six.text_type(dictColonne["parametres"])),] DB.ReqMAJ("modeles_commandes_colonnes", listeDonnees, "IDcolonne", dictColonne["IDcolonne"]) # Suppression des colonnes obsolètes for IDcolonne in self.listeIDcolonnesImportees : if IDcolonne not in listeIDcolonne : DB.ReqDEL("modeles_commandes_colonnes", "IDcolonne", IDcolonne) DB.ReqDEL("commandes_valeurs", "IDcolonne", IDcolonne) # Clôture de la base DB.Close() # Fermeture de la fenêtre self.EndModal(wx.ID_OK)
def Validation(self): """ Validation des données saisies """ # Vérifie date début date_debut = self.ctrl_date_debut.GetDate() if self.ctrl_date_debut.FonctionValiderDate( ) == False or date_debut == None: dlg = wx.MessageDialog( self, _(u"La date de début de période ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date_debut.SetFocus() return False # Vérifie date fin date_fin = self.ctrl_date_fin.GetDate() if self.ctrl_date_fin.FonctionValiderDate( ) == False or date_fin == None: dlg = wx.MessageDialog( self, _(u"La date de fin de période ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date_fin.SetFocus() return False # Vérifie les deux dates if date_debut > date_fin: dlg = wx.MessageDialog( self, _(u"La date de début de période est supérieure à la date de fin !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date_fin.SetFocus() return False # Vérifie que la période sélectionnée n'est pas dans une période de gestion gestion = UTILS_Gestion.Gestion(None) if gestion.IsPeriodeinPeriodes("factures", date_debut, date_fin) == False: return False # Vérifier si lot de factures IDlot = self.ctrl_lot.GetID() nomLot = self.ctrl_lot.GetNom() if IDlot == None: dlg = wx.MessageDialog( self, _(u"Vous n'avez pas sélectionné de lot de factures à associer.\n\nSouhaitez-vous quand même continuer ?" ), _(u"Confirmation"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION) resultat = dlg.ShowModal() dlg.Destroy() if resultat != wx.ID_YES: return False # Préfixe de facture IDprefixe = self.ctrl_prefixe.GetID() prefixe = self.ctrl_prefixe.GetPrefixe() # Prochain numéro de facture if self.check_numero_auto.GetValue() == True: # Numéro auto prochain_numero = None else: # Numéro perso try: prochain_numero = int(self.ctrl_prochain_numero.GetValue()) except: prochain_numero = None if prochain_numero in (None, ""): dlg = wx.MessageDialog( self, _(u"Le prochain numéro de facture ne semble pas valide !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_prochain_numero.SetFocus() return False if prochain_numero < self.prochain_numero_defaut: dlg = wx.MessageDialog( self, _(u"Le prochain numéro de facture n'est pas valide : une facture générée porte déjà un numéro égal ou supérieur !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_prochain_numero.SetFocus() return False # Date d'émission date_emission = self.ctrl_date_emission.GetDate() if self.ctrl_date_emission.FonctionValiderDate( ) == False or date_emission == None: dlg = wx.MessageDialog( self, _(u"La date d'émission ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date_emission.SetFocus() return False # Date d'échéance date_echeance = self.ctrl_date_echeance.GetDate() if date_echeance == None: dlg = wx.MessageDialog( self, _(u"Vous n'avez pas saisi de date d'échéance. \n\nSouhaitez-vous quand même continuer ?" ), _(u"Confirmation"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION) resultat = dlg.ShowModal() dlg.Destroy() if resultat != wx.ID_YES: return False # Vérifier si lot de factures prestations = [] if self.check_consommations.GetValue() == True: prestations.append("consommation") if self.check_cotisations.GetValue() == True: prestations.append("cotisation") if self.check_locations.GetValue() == True: prestations.append("location") if self.check_autres.GetValue() == True: prestations.append("autre") if len(prestations) == 0: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement cocher au moins un type de prestation à facturer !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Familles if self.radio_familles_toutes.GetValue() == True: IDcompte_payeur_unique = None else: IDcompte_payeur_unique = self.ctrl_famille.GetIDcompte_payeur() if IDcompte_payeur_unique == None: dlg = wx.MessageDialog( self, _(u"Vous avez sélectionné l'option 'famille unique' mais sans sélectionner de famille dans la liste proposée !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Vérifie les activités sélectionnées listeActivites = self.ctrl_activites.GetActivites() if len(listeActivites) == 0: dlg = wx.MessageDialog( self, _(u"Vous n'avez sélectionné aucune activité.\n\nSouhaitez-vous quand même continuer ?" ), _(u"Avertissement"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_EXCLAMATION) resultat = dlg.ShowModal() dlg.Destroy() if resultat != wx.ID_YES: return False # Date antérieure date_anterieure = None if self.check_prestations_anterieures.GetValue() == True: date_anterieure = self.ctrl_date_anterieures.GetDate() if self.ctrl_date_anterieures.FonctionValiderDate( ) == False or date_anterieure == None: dlg = wx.MessageDialog( self, _(u"La date antérieure ne semble pas valide !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_date_anterieures.SetFocus() return False # Vérification droits utilisateurs for IDactivite in listeActivites: if UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel( "facturation_factures", "creer", IDactivite=IDactivite, afficheMessage=False) == False: dlg = wx.MessageDialog( self, _(u"Vous n'avez pas l'autorisation de générer des factures pour l'ensemble des activités sélectionnées !" ), _(u"Action non autorisée"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Vérifie la compatibilité des régies des activités sélectionnées IDregie = None if len(listeActivites) >= 1: listeAllRegies = [] for IDactivite in listeActivites: DB = GestionDB.DB() req = """SELECT regie FROM activites WHERE IDactivite = %d""" % IDactivite DB.ExecuterReq(req) listeresult = DB.ResultatReq() result = listeresult[0] listeAllRegies.append(result[0]) DB.Close() listeRegies = list(set(listeAllRegies)) if len(listeRegies) > 1: dlg = wx.MessageDialog( self, _(u"Vous ne pouvez pas générer des factures pour l'ensemble des activités sélectionnées !\n\nCertaines activités sont liées à des régies différentes" ), _(u"Régies différentes"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False else: IDregie = listeRegies[0] # Envoi des données à DLG_Factures_generation self.parent.dictParametres = { "date_debut": date_debut, "date_fin": date_fin, "IDlot": IDlot, "nomLot": nomLot, "date_emission": date_emission, "date_echeance": date_echeance, "prochain_numero": prochain_numero, "prestations": prestations, "IDcompte_payeur": IDcompte_payeur_unique, "listeActivites": listeActivites, "IDprefixe": IDprefixe, "prefixe": prefixe, "date_anterieure": date_anterieure, "IDregie": IDregie, "mention1": self.ctrl_mention1.GetValue(), "mention2": self.ctrl_mention2.GetValue(), "mention3": self.ctrl_mention3.GetValue(), } return True
def Supprimer(self, event): item = self.GetSelection() dictData = self.GetPyData(item) if dictData == None or dictData["IDetiquette"] == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner une étiquette à supprimer !" ), "Erreur de saisie", wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return IDetiquette = dictData["IDetiquette"] dictConsoAssociees = self.RechercheNbreConsoAssociees() if IDetiquette in dictConsoAssociees: if dictConsoAssociees[IDetiquette] > 0: dlg = wx.MessageDialog( self, _(u"Cette étiquette a déjà été associée à %d consommation(s) !\n\nVous ne pouvez donc pas la supprimer." % dictConsoAssociees[IDetiquette]), "Erreur de saisie", wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return # Confirmation de suppression des étiquettes enfants listeTousEnfants = [] if self.GetChildrenCount(item, recursively=True) > 0: # Récupère la liste des tous les items enfants (récursif) self.GetItemsEnfants(listeTousEnfants, item) # Va servir à vérifier les liens avec les autres tables : for dictDataTemp in listeTousEnfants: if dictDataTemp["IDetiquette"] in dictConsoAssociees: if dictConsoAssociees[dictDataTemp["IDetiquette"]] > 0: dlg = wx.MessageDialog( self, _(u"L'étiquette enfant '%s' qui dépend de l'étiquette sélectionnée a déjà été associée à %d consommation(s) !\n\nVous ne pouvez donc pas supprimer l'étiquette parent." % (dictDataTemp["label"], dictDataTemp["IDetiquette"])), "Erreur de saisie", wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return # Demande de confirmation dlg = wx.MessageDialog( self, _(u"Attention, cette étiquette comporte des étiquettes enfants.\n\nSouhaitez-vous vraiment supprimer cette étiquette ? Les étiquettes enfants seront également supprimées !" ), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return # Confirmation de suppression dlg = wx.MessageDialog( self, _(u"Souhaitez-vous vraiment supprimer cette étiquette ?"), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION) if dlg.ShowModal() == wx.ID_YES: DB = GestionDB.DB() # Suppression de l'étiquette DB.ReqDEL("etiquettes", "IDetiquette", dictData["IDetiquette"]) # Suppression des étiquettes enfants également for dictTemp in listeTousEnfants: DB.ReqDEL("etiquettes", "IDetiquette", dictTemp["IDetiquette"]) # Modification de l'ordre des étiquettes soeurs itemParent = self.GetItemParent(item) listeItemsSoeurs = [] self.GetItemsEnfants(liste=listeItemsSoeurs, item=itemParent, recursif=False) ordre = 1 for dictDataTemp in listeItemsSoeurs: if dictDataTemp["IDetiquette"] != dictData["IDetiquette"]: DB.ReqMAJ("etiquettes", [ ("ordre", ordre), ], "IDetiquette", dictDataTemp["IDetiquette"]) ordre += 1 DB.Close() self.MAJ() dlg.Destroy()
def run(self): nbre_tracks = len(self.parent.listeTracks) try: listeAnomalies = [] for track in self.parent.listeTracks: # Affichage texteIntro = u"[%d/%d] %s" % ( self.index + 1, len(self.parent.listeTracks), track.detail) self.parent.label_intro.SetLabel(texteIntro) self.parent.ctrl_gauge.SetValue(self.index + 1) # ------------------- Traitement d'une consommation ------------------- if track.categorie == "consommation": # Initialisation de la grille self.parent.ctrl_grille.InitGrille( IDindividu=track.IDindividu, IDfamille=track.IDfamille, IDactivite=track.IDactivite, date=track.date) wx.Yield() if track.etat == "reservation": mode, etat = "reservation", "reservation" if track.etat == "attente": mode, etat = "attente", "reservation" if track.etat == "refus": mode, etat = "refus", "reservation" if track.etat == "present": mode, etat = "reservation", "present" if track.etat == "absenti": mode, etat = "reservation", "absenti" if track.etat == "absentj": mode, etat = "reservation", "absentj" if track.action == "ajouter" or track.action == "modifier": resultat = self.parent.ctrl_grille.SaisieConso( IDunite=track.IDunite, mode=mode, etat=etat, heure_debut=track.heure_debut, heure_fin=track.heure_fin, quantite=track.quantite) if track.action == "supprimer": resultat = self.parent.ctrl_grille.SupprimeConso( IDunite=track.IDunite, date=track.date) # Sauvegarde de la grille des conso + Ecrit log if resultat == True: self.parent.ctrl_grille.Sauvegarde() self.parent.parent.EcritLog(track.detail + u" -> ok") self.parent.parent.SetStatut(track, "ok") else: texte = track.detail + u" -> " + resultat self.parent.parent.EcritLog(texte) self.parent.parent.SetStatut(track, "erreur") listeAnomalies.append(texte) # ------------------- Traitement d'un mémo journalier ------------------- if track.categorie == "memo_journee": DB = GestionDB.DB() req = """SELECT IDmemo, IDindividu, date, texte FROM memo_journee WHERE IDindividu=%d AND date='%s';""" % ( track.IDindividu, track.date) DB.ExecuterReq(req) listeMemos = DB.ResultatReq() if len(listeMemos) > 1: IDmemo = listeMemos[0][0] else: IDmemo = None listeDonnees = [ ("IDindividu", track.IDindividu), ("date", str(track.date)), ("texte", track.texte), ] if track.action == "ajouter" or track.action == "modifier": if IDmemo != None: DB.ReqMAJ("memo_journee", listeDonnees, "IDmemo", IDmemo) else: DB.ReqInsert("memo_journee", listeDonnees) if track.action == "supprimer" and IDmemo != None: DB.ReqDEL("memo_journee", "IDmemo", IDmemo) DB.Close() self.parent.parent.EcritLog(track.detail + u" -> ok") self.parent.parent.SetStatut(track, "ok") # Arrête le traitement si bouton arrêter enfoncé if self.stop: raise Abort time.sleep(0.2) self.index += 1 # Si fin self.succes = True raise Abort except Abort, KeyBoardInterrupt: if self.succes == True: self.parent.label_intro.SetLabel(_(u"Traitement terminé")) self.parent.parent.EcritLog(_(u"Traitement terminé")) self.parent.Fermer(forcer=True) else: #print "arrete a l'index", self.index self.parent.label_intro.SetLabel( _(u"Traitement interrompu par l'utilisateur")) self.parent.parent.EcritLog( _(u"Traitement interrompu par l'utilisateur")) self.parent.bouton_fermer.SetBitmap( wx.Bitmap( Chemins.GetStaticPath( u"Images/BoutonsImages/Fermer_L72.png"), wx.BITMAP_TYPE_ANY))
def OnBoutonOk(self, event): # Validation des données if self.ValidationDonnees() == False: return if self.ctrl_verrouillage.GetValue() == False: dlg = wx.MessageDialog( self, _(u"Pour clôturer le traitement d'un lot, vous devez valider ou refuser les pièces puis verrouiller le lot.\n\nSouhaitez-vous le faire maintenant ?" ), _(u"Information"), wx.YES_NO | wx.CANCEL | wx.NO_DEFAULT | wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_NO: return # Récupération des données nom = self.ctrl_nom.GetValue() observations = self.ctrl_observations.GetValue() if self.ctrl_verrouillage.GetValue() == True: verrouillage = 1 else: verrouillage = 0 exercice = self.ctrl_parametres.GetPropertyValue("exercice") mois = self.ctrl_parametres.GetPropertyValue("mois") objet_dette = self.ctrl_parametres.GetPropertyValue("objet_dette") if 'phoenix' in wx.PlatformInfo: date_emission = self.ctrl_parametres.GetPropertyValue( "date_emission").FormatISODate() date_prelevement = self.ctrl_parametres.GetPropertyValue( "date_prelevement").FormatISODate() date_envoi = self.ctrl_parametres.GetPropertyValue( "date_envoi").FormatISODate() else: date_emission = self.ctrl_parametres.GetPropertyValue( "date_emission").strftime("%Y-%m-%d") date_prelevement = self.ctrl_parametres.GetPropertyValue( "date_prelevement").strftime("%Y-%m-%d") date_envoi = self.ctrl_parametres.GetPropertyValue( "date_envoi").strftime("%Y-%m-%d") try: id_bordereau = self.ctrl_parametres.GetPropertyValue( "id_bordereau") except: id_bordereau = None id_poste = self.ctrl_parametres.GetPropertyValue("id_poste") try: id_collectivite = self.ctrl_parametres.GetPropertyValue( "id_collectivite") except: id_collectivite = None code_collectivite = self.ctrl_parametres.GetPropertyValue( "code_collectivite") code_budget = self.ctrl_parametres.GetPropertyValue("code_budget") code_prodloc = self.ctrl_parametres.GetPropertyValue("code_prodloc") try: code_etab = self.ctrl_parametres.GetPropertyValue("code_etab") except: code_etab = None reglement_auto = int( self.ctrl_parametres.GetPropertyValue("reglement_auto")) IDcompte = self.ctrl_parametres.GetPropertyValue("IDcompte") IDmode = self.ctrl_parametres.GetPropertyValue("IDmode") prelevement_libelle = self.ctrl_parametres.GetPropertyValue( "prelevement_libelle") objet_piece = self.ctrl_parametres.GetPropertyValue("objet_piece") # Sauvegarde du lot listeDonnees = [ ("nom", nom), ("verrouillage", verrouillage), ("observations", observations), ("reglement_auto", reglement_auto), ("IDcompte", IDcompte), ("IDmode", IDmode), ("exercice", exercice), ("mois", mois), ("objet_dette", objet_dette), ("date_emission", date_emission), ("date_prelevement", date_prelevement), ("date_envoi", date_envoi), ("id_bordereau", id_bordereau), ("id_poste", id_poste), ("id_collectivite", id_collectivite), ("code_collectivite", code_collectivite), ("code_budget", code_budget), ("code_prodloc", code_prodloc), ("code_etab", code_etab), ("prelevement_libelle", prelevement_libelle), ("objet_piece", objet_piece), ("format", self.format), ] DB = GestionDB.DB() if self.IDlot == None: # Ajout self.IDlot = DB.ReqInsert("pes_lots", listeDonnees) else: # Modification DB.ReqMAJ("pes_lots", listeDonnees, "IDlot", self.IDlot) DB.Close() # Sauvegarde des prélèvements du lot self.ctrl_pieces.Sauvegarde(IDlot=self.IDlot, datePrelevement=date_prelevement, IDcompte=IDcompte, IDmode=IDmode) # Mémorisation des préférences self.Memorisation_parametres() # Fermeture self.EndModal(wx.ID_OK)
def Sauvegarder(self): """ Sauvegarde des attestations """ # Demande la confirmation de sauvegarde dlg = wx.MessageDialog(self, _(u"Souhaitez-vous mémoriser les attestations ?\n\n(Cliquez NON si c'était juste un test sinon cliquez OUI)"), _(u"Sauvegarde"), wx.YES_NO|wx.YES_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES : return dlgAttente = wx.BusyInfo(_(u"Sauvegarde des attestations en cours..."), None) wx.Yield() DB = GestionDB.DB() try : for IDcompte_payeur, dictCompte in self.donnees.iteritems() : if dictCompte["select"] == True : numero = dictCompte["num_attestation"] IDfamille = dictCompte["IDfamille"] listePrestations = dictCompte["listePrestations"] total = dictCompte["total"] regle = dictCompte["ventilation"] solde = total - regle # Liste des activités texteActivites = "" for IDactivite in self.listeActivites : texteActivites += "%d;" % IDactivite if len(self.listeActivites) > 0 : texteActivites = texteActivites[:-1] # Liste des individus texteIndividus = "" for IDindividu in dictCompte["individus"].keys() : texteIndividus += "%d;" % IDindividu if len(dictCompte["individus"].keys()) > 0 : texteIndividus = texteIndividus[:-1] IDutilisateur = UTILS_Identification.GetIDutilisateur() # Sauvegarde de la facture listeDonnees = [ ("numero", numero), ("IDfamille", IDfamille), ("date_edition", str(datetime.date.today())), ("activites", texteActivites), ("individus", texteIndividus), ("IDutilisateur", IDutilisateur), ("date_debut", str(self.date_debut)), ("date_fin", str(self.date_fin)), ("total", float(total)), ("regle", float(regle)), ("solde", float(solde)), ] IDattestation = DB.ReqInsert("attestations", listeDonnees) # Mémorisation de l'action dans l'historique UTILS_Historique.InsertActions([{ "IDfamille" : IDfamille, "IDcategorie" : 27, "action" : _(u"Edition d'une attestation de présence pour la période du %s au %s pour un total de %.02f ¤ et un solde de %.02f ¤") % (DateEngFr(str(self.date_debut)), DateEngFr(str(self.date_fin)), total, solde), },]) DB.Close() del dlgAttente except Exception, err: DB.Close() del dlgAttente traceback.print_exc(file=sys.stdout) dlg = wx.MessageDialog(self, _(u"Désolé, le problème suivant a été rencontré dans la sauvegarde des attestations : \n\n%s") % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return False
def Importation(self): """ Importation des données """ if self.IDlot == None: # Données du dernier lot DB = GestionDB.DB() req = """SELECT reglement_auto, IDcompte, IDmode, exercice, mois, objet_dette, date_emission, date_prelevement, date_envoi, id_bordereau, id_poste, id_collectivite, code_collectivite, code_budget, code_prodloc, code_etab, prelevement_libelle, objet_piece, format, options FROM pes_lots WHERE format='%s' ORDER BY IDlot;""" % self.format DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0: return reglement_auto, IDcompte, IDmode, exercice, mois, objet_dette, date_emission, date_prelevement, date_envoi, id_bordereau, id_poste, id_collectivite, code_collectivite, code_budget, code_prodloc, code_etab, prelevement_libelle, objet_piece, format, options = listeDonnees[ -1] nom = u"" verrouillage = False observations = u"" else: # Importation DB = GestionDB.DB() req = """SELECT nom, verrouillage, observations, reglement_auto, IDcompte, IDmode, exercice, mois, objet_dette, date_emission, date_prelevement, date_envoi, id_bordereau, id_poste, id_collectivite, code_collectivite, code_budget, code_prodloc, code_etab, prelevement_libelle, objet_piece, format, options FROM pes_lots WHERE IDlot=%d ;""" % self.IDlot DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0: return nom, verrouillage, observations, reglement_auto, IDcompte, IDmode, exercice, mois, objet_dette, date_emission, date_prelevement, date_envoi, id_bordereau, id_poste, id_collectivite, code_collectivite, code_budget, code_prodloc, code_etab, prelevement_libelle, objet_piece, format, options = listeDonnees[ 0] # Attribution des données aux contrôles self.ctrl_nom.SetValue(nom) self.ctrl_verrouillage.SetValue(verrouillage) self.ctrl_observations.SetValue(observations) if reglement_auto == 1: self.ctrl_pieces.reglement_auto = True if prelevement_libelle in ("", None): prelevement_libelle = u"{NOM_ORGANISATEUR} - {LIBELLE_FACTURE}" if objet_piece in ("", None): objet_piece = _(u"FACTURE NUM{NUM_FACTURE} {MOIS_LETTRES} {ANNEE}") listeValeurs = [ ("exercice", exercice), ("mois", mois), ("objet_dette", objet_dette), ("date_emission", UTILS_Dates.DateEngEnDateDD(date_emission)), ("date_prelevement", UTILS_Dates.DateEngEnDateDD(date_prelevement)), ("date_envoi", UTILS_Dates.DateEngEnDateDD(date_envoi)), ("id_bordereau", id_bordereau), ("id_poste", id_poste), ("id_collectivite", id_collectivite), ("code_collectivite", code_collectivite), ("code_budget", code_budget), ("code_prodloc", code_prodloc), ("code_etab", code_etab), ("reglement_auto", reglement_auto), ("IDcompte", IDcompte), ("IDmode", IDmode), ("prelevement_libelle", prelevement_libelle), ("objet_piece", objet_piece), ] for code, valeur in listeValeurs: try: self.ctrl_parametres.SetPropertyValue(code, valeur) except: pass
def GetListeIndividus(listview=None, listeActivites=None, presents=None, IDindividu=None, infosIndividus=None): # Conditions Activites if listeActivites == None or listeActivites == []: conditionActivites = "" else: if len(listeActivites) == 1: conditionActivites = " AND inscriptions.IDactivite=%d AND inscriptions.statut='ok' AND (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s') " % ( listeActivites[0], datetime.date.today()) else: conditionActivites = " AND inscriptions.IDactivite IN %s AND inscriptions.statut='ok' AND (inscriptions.date_desinscription IS NULL OR inscriptions.date_desinscription>='%s') " % ( str(tuple(listeActivites)), datetime.date.today()) # Conditions Présents conditionPresents = "" jointurePresents = "" if presents != None: conditionPresents = " AND (consommations.date>='%s' AND consommations.date<='%s' AND consommations.etat IN ('reservation', 'present'))" % ( str(presents[0]), str(presents[1])) jointurePresents = "LEFT JOIN consommations ON consommations.IDindividu = individus.IDindividu" # Condition Individu donné conditionIndividus = "" if IDindividu != None: conditionIndividus = " AND individus.IDindividu=%d" % IDindividu # Récupération des individus listeChamps = ( "individus.IDindividu", "IDcivilite", "individus.nom", "prenom", "num_secu", "IDnationalite", "date_naiss", "IDpays_naiss", "cp_naiss", "ville_naiss", "adresse_auto", "rue_resid", "cp_resid", "ville_resid", "IDcategorie_travail", "profession", "employeur", "travail_tel", "travail_fax", "travail_mail", "tel_domicile", "tel_mobile", "tel_fax", "mail", "secteurs.nom", ) DB = GestionDB.DB() req = """ SELECT %s FROM individus LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu LEFT JOIN secteurs ON secteurs.IDsecteur = individus.IDsecteur %s WHERE individus.IDindividu>0 AND individus.deces != 1 AND individus.etat IS NULL %s %s %s GROUP BY individus.IDindividu ;""" % (",".join(listeChamps), jointurePresents, conditionActivites, conditionPresents, conditionIndividus) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() # Récupération des civilités dictCivilites = Civilites.GetDictCivilites() # Récupération des adresses auto GetDictInfosIndividus() listeListeView = [] for valeurs in listeDonnees: dictTemp = {} dictTemp["IDindividu"] = valeurs[0] # Infos de la table Individus for index in range(0, len(listeChamps)): nomChamp = listeChamps[index] dictTemp[nomChamp] = valeurs[index] # Infos sur la civilité if dictTemp["IDcivilite"] == None or dictTemp["IDcivilite"] == "": IDcivilite = 1 else: IDcivilite = dictTemp["IDcivilite"] dictTemp["genre"] = dictCivilites[IDcivilite]["sexe"] dictTemp["categorieCivilite"] = dictCivilites[IDcivilite]["categorie"] dictTemp["civiliteLong"] = dictCivilites[IDcivilite]["civiliteLong"] dictTemp["civiliteAbrege"] = dictCivilites[IDcivilite][ "civiliteAbrege"] dictTemp["nomImage"] = dictCivilites[IDcivilite]["nomImage"] if dictTemp["date_naiss"] == None: dictTemp["age"] = None else: datenaissDD = datetime.date(year=int(dictTemp["date_naiss"][:4]), month=int(dictTemp["date_naiss"][5:7]), day=int(dictTemp["date_naiss"][8:10])) datedujour = datetime.date.today() age = (datedujour.year - datenaissDD.year) - int( (datedujour.month, datedujour.day) < (datenaissDD.month, datenaissDD.day)) dictTemp["age"] = age # Formatage sous forme de TRACK track = TrackIndividu(listview, dictTemp, infosIndividus) listeListeView.append(track) return listeListeView
def ValidationDonnees(self): """ Vérifie que les données saisies sont exactes """ # Généralités nom = self.ctrl_nom.GetValue() if nom == "": dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir un nom de lot (Ex : 'Janvier 2013'...) !" ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_nom.SetFocus() return False for caract in nom: if caract in ("_", ): dlg = wx.MessageDialog( self, _(u"Le caractère '%s' n'est pas autorisé dans le nom du lot !" ) % caract, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_nom.SetFocus() return False # Vérifie que le nom n'est pas déjà attribué if self.IDlot == None: IDlotTemp = 0 else: IDlotTemp = self.IDlot DB = GestionDB.DB() req = """SELECT IDlot, nom FROM pes_lots WHERE nom='%s' AND IDlot!=%d;""" % (nom, IDlotTemp) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) > 0: dlg = wx.MessageDialog( self, _(u"Ce nom de lot a déjà été attribué à un autre lot.\n\nChaque lot doit avoir un nom unique. Changez le nom." ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_nom.SetFocus() return False observations = self.ctrl_observations.GetValue() if self.ctrl_verrouillage.GetValue() == True: verrouillage = 1 else: verrouillage = 0 # Récupération des données du CTRL Paramètres exercice = self.ctrl_parametres.GetPropertyValue("exercice") mois = self.ctrl_parametres.GetPropertyValue("mois") objet_dette = self.ctrl_parametres.GetPropertyValue("objet_dette") date_emission = self.ctrl_parametres.GetPropertyValue("date_emission") date_prelevement = self.ctrl_parametres.GetPropertyValue( "date_prelevement") date_envoi = self.ctrl_parametres.GetPropertyValue("date_envoi") id_bordereau = self.ctrl_parametres.GetPropertyValue("id_bordereau") id_poste = self.ctrl_parametres.GetPropertyValue("id_poste") id_collectivite = self.ctrl_parametres.GetPropertyValue( "id_collectivite") code_collectivite = self.ctrl_parametres.GetPropertyValue( "code_collectivite") code_budget = self.ctrl_parametres.GetPropertyValue("code_budget") code_prodloc = self.ctrl_parametres.GetPropertyValue("code_prodloc") code_etab = self.ctrl_parametres.GetPropertyValue("code_etab") reglement_auto = int( self.ctrl_parametres.GetPropertyValue("reglement_auto")) IDcompte = self.ctrl_parametres.GetPropertyValue("IDcompte") IDmode = self.ctrl_parametres.GetPropertyValue("IDmode") # Vérification du compte à créditer if reglement_auto == 1: if IDcompte == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner un compte à créditer !" ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False if IDmode == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner un mode de règlement pour le règlement automatique !" ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Vérification des paramètres du bordereau listeVerifications = [ (exercice, "exercice", _(u"l'année de l'exercice")), (mois, "mois", _(u"le mois")), (objet_dette, "objet_dette", _(u"l'objet de la dette")), (date_emission, "date_emission", _(u"la date d'émission")), (date_prelevement, "date_prelevement", _(u"la date souhaitée du prélèvement")), (date_envoi, "date_envoi", _(u"la date d'envoi")), (id_bordereau, "id_bordereau", _(u"l'ID bordereau")), (id_poste, "id_poste", _(u"l'ID poste")), (id_collectivite, "id_collectivite", _(u"l'ID collectivité")), (code_collectivite, "code_collectivite", _(u"le Code Collectivité")), (code_budget, "code_budget", _(u"le Code Bugdet")), (code_prodloc, "code_prodloc", _(u"le code Produit Local")), (code_etab, "code_etab", _(u"le code Etablissement")), ] for donnee, code, label in listeVerifications: if donnee == None or donnee == "": dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir %s dans les paramètres du lot !" ) % label, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False if code == "id_bordereau": try: test = int(donnee) except: dlg = wx.MessageDialog( self, _(u"Vous devez saisir une valeur numérique valide pour le paramètre de bordereau 'ID Bordereau' !" ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False if code == "id_collectivite": try: test = int(donnee) except: dlg = wx.MessageDialog( self, _(u"Vous devez saisir une valeur numérique valide pour le paramètre de bordereau 'ID Collectivité' !" ), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Vérification des pièces listeErreurs = [] listeTemp1 = [] for track in self.ctrl_pieces.GetObjects(): if track.analysePiece == False: listeErreurs.append( _(u"- Facture n°%s : %s") % (track.IDfacture, track.analysePieceTexte)) # Vérifie qu'un OOFF ou un FRST n'est pas attribué 2 fois à un seul mandat if track.prelevement == 1: if track.prelevement_sequence in ("OOFF", "FRST"): key = (track.prelevement_IDmandat, track.prelevement_sequence) if key in listeTemp1: if track.prelevement_sequence == "OOFF": listeErreurs.append( _(u"- Facture n°%s : Le mandat n°%s de type ponctuel a déjà été utilisé une fois !" ) % (track.IDfacture, track.prelevement_IDmandat)) if track.prelevement_sequence == "FRST": listeErreurs.append( _(u"- Facture n°%s : Mandat n°%s déjà initialisé. La séquence doit être définie sur 'RCUR' !" ) % (track.IDfacture, track.prelevement_IDmandat)) listeTemp1.append(key) if len(listeErreurs) > 0: message1 = _( u"Le bordereau ne peut être validé en raison des erreurs suivantes :" ) message2 = "\n".join(listeErreurs) dlg = dialogs.MultiMessageDialog(self, message1, caption=_(u"Erreur"), msg2=message2, style=wx.ICON_EXCLAMATION | wx.OK, icon=None, btnLabels={wx.ID_OK: _(u"Ok")}) reponse = dlg.ShowModal() dlg.Destroy() return False return True
def Importation(self): """ Importation des donnees de la base """ # Récupération des paramètres ORGANISME nom_organisme = UTILS_Parametres.Parametres(mode="get", categorie="don_oeuvres", nom="nom_organisme", valeur=u"") adresse_organisme = UTILS_Parametres.Parametres( mode="get", categorie="don_oeuvres", nom="adresse_organisme", valeur=u"") objet_organisme = UTILS_Parametres.Parametres(mode="get", categorie="don_oeuvres", nom="objet_organisme", valeur=u"") type_organisme = UTILS_Parametres.Parametres(mode="get", categorie="don_oeuvres", nom="type_organisme", valeur=u"") self.ctrl_nom_beneficiaire.SetValue(nom_organisme) self.ctrl_adresse_beneficiaire.SetValue(adresse_organisme) self.ctrl_objet.SetValue(objet_organisme) self.ctrl_type.SetValue(type_organisme) # Importation de la cotisation DB = GestionDB.DB() req = """SELECT IDfamille, IDindividu, cotisations.IDtype_cotisation, IDunite_cotisation, date_saisie, date_creation_carte, numero, date_debut, date_fin, IDprestation, types_cotisations.type, cotisations.observations FROM cotisations LEFT JOIN types_cotisations ON types_cotisations.IDtype_cotisation = cotisations.IDtype_cotisation WHERE IDcotisation=%d;""" % self.IDcotisation DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() if len(listeDonnees) == 0: DB.Close() return IDfamille, IDindividu, IDtype_cotisation, IDunite_cotisation, date_saisie, date_creation_carte, numero, date_debut, date_fin, IDprestation, typeCotisation, observations = listeDonnees[ 0] self.numero = numero if self.numero == None: self.numero = "" self.IDfamille = IDfamille # Prestation if IDprestation == None: self.montant = 0.00 else: # Importation des données de la prestation req = """SELECT IDcompte_payeur, label, montant FROM prestations WHERE IDprestation=%d;""" % IDprestation DB.ExecuterReq(req) listePrestations = DB.ResultatReq() if len(listePrestations) == 0: DB.Close() return IDcompte_payeur, label, montant = listePrestations[0] # Remplit les noms des payeurs self.ctrl_nom_auto.SetListeDonnees(IDcompte_payeur) self.OnChoixNom(None) if montant != None: self.montant = float(montant) # Importation des données sur le (ou les) règlement req = """SELECT reglements.IDreglement, reglements.date, reglements.IDmode, reglements.montant, ventilation.montant FROM reglements LEFT JOIN ventilation ON ventilation.IDreglement = reglements.IDreglement WHERE ventilation.IDprestation=%d;""" % IDprestation DB.ExecuterReq(req) listeReglements = DB.ResultatReq() listeDates = [] listeModes = [] totalVentilation = 0.0 for IDreglement, date, IDmode, montant_reglement, montant_ventilation in listeReglements: listeDates.append(date) listeModes.append((montant_reglement, IDmode)) totalVentilation += montant_ventilation listeDates.sort() listeModes.sort() if len(listeDates) > 0: self.ctrl_date_versement.SetDate(listeDates[-1]) if len(listeModes) > 0: IDmode = listeModes[-1][1] self.ctrl_mode_auto.SetID(IDmode) self.totalVentilation = totalVentilation DB.Close()
def GetListeDonnees(self): if self.IDecole == None or self.date_debut == None or self.date_fin == None : return [] DB = GestionDB.DB() req = """SELECT IDclasse, nom, date_debut, date_fin, niveaux FROM classes WHERE IDecole=%d AND date_debut<='%s' AND date_fin>='%s' ORDER BY nom; """ % (self.IDecole, self.date_debut, self.date_fin) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() # Tri des classes par niveau scolaire listeClasses = [] for IDclasse, nom, date_debut, date_fin, niveaux in listeDonnees : # Formatage des dates de la saison date_debut = DateEngEnDateDD(date_debut) date_fin = DateEngEnDateDD(date_fin) saison = (date_debut, date_fin) # Formatage du nom nom = _(u"%s (Du %s au %s)") % (nom, DateEngFr(str(date_debut)), DateEngFr(str(date_fin))) # Formatage des niveaux listeNiveaux = [] listeOrdresNiveaux = [] txtNiveaux = u"" if niveaux != None and niveaux != "" and niveaux != " " : listeTemp = niveaux.split(";") txtTemp = [] for niveau in listeTemp : IDniveau = int(niveau) if self.parent.dictNiveaux.has_key(IDniveau) : nomNiveau = self.parent.dictNiveaux[IDniveau]["abrege"] ordreNiveau = self.parent.dictNiveaux[IDniveau]["ordre"] listeNiveaux.append(IDniveau) txtTemp.append(nomNiveau) listeOrdresNiveaux.append(ordreNiveau) txtNiveaux = ", ".join(txtTemp) donnees = (listeOrdresNiveaux, nom, txtNiveaux, listeNiveaux, IDclasse) listeClasses.append(donnees) listeClasses.sort() # Création des items de liste if len(listeClasses) > 0 : listeItems = [_(u"-- Toutes les classes --")] self.dictClasses = {0 : None} index = 1 for listeOrdresNiveaux, nom, txtNiveaux, listeNiveaux, IDclasse in listeClasses : listeItems.append(nom) self.dictClasses[index] = {"IDclasse" : IDclasse, "nom" : nom, "listeOrdresNiveaux" : listeOrdresNiveaux, "txtNiveaux" : txtNiveaux, "listeNiveaux" : listeNiveaux,} index += 1 else: listeItems = [] self.dictClasses = {} return listeItems
def OnTextePerso(self, event): # Sauvegarde du texte perso texte = self.texte_perso.GetValue() DB = GestionDB.DB() DB.ReqMAJ("personnes", [("texte_photo", texte),], "IDpersonne", self.IDpersonne) DB.Close()
def VentilationAuto(IDcompte_payeur=None, IDreglement=None): """ Ventilation auto de tous les règlements d'un compte payeur ou d'un règlement spécifique """ DB = GestionDB.DB() if IDreglement != None: conditionReglement = "AND IDreglement=%d" % IDreglement else: conditionReglement = "" # Récupère la ventilation req = """SELECT IDventilation, IDreglement, IDprestation, montant FROM ventilation WHERE IDcompte_payeur=%d;""" % IDcompte_payeur DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictVentilations = {} dictVentilationsReglement = {} dictVentilationsPrestation = {} for IDventilation, IDreglement, IDprestation, montant in listeDonnees: dictVentilations[IDventilation] = { "IDreglement": IDreglement, "IDprestation": IDprestation, "montant": FloatToDecimal(montant) } if (IDreglement in dictVentilationsReglement) == False: dictVentilationsReglement[IDreglement] = [] dictVentilationsReglement[IDreglement].append(IDventilation) if (IDprestation in dictVentilationsPrestation) == False: dictVentilationsPrestation[IDprestation] = [] dictVentilationsPrestation[IDprestation].append(IDventilation) # Récupère les prestations req = """SELECT IDprestation, date, montant FROM prestations WHERE IDcompte_payeur=%d ORDER BY date;""" % IDcompte_payeur DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() listePrestations = [] for IDprestation, date, montant in listeDonnees: listePrestations.append({ "IDprestation": IDprestation, "date": date, "montant": FloatToDecimal(montant) }) # Vérifie qu'il n'y a pas de prestations négatives for dictPrestation in listePrestations: IDprestation = dictPrestation["IDprestation"] montantVentilation = FloatToDecimal(0.0) if IDprestation in dictVentilationsPrestation: for IDventilation in dictVentilationsPrestation[IDprestation]: montantVentilation += dictVentilations[IDventilation][ "montant"] ResteAVentiler = dictPrestation["montant"] - montantVentilation if ResteAVentiler < FloatToDecimal(0.0): dlg = wx.MessageDialog( None, _(u"Ventilation automatique impossible !\n\nLa ventilation automatique n'est pas compatible avec les prestations comportant un montant négatif ! Vous devez donc effectuer une ventilation manuelle." ), _(u"Information"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() DB.Close() return False # Récupère les règlements req = """SELECT IDreglement, date, montant FROM reglements WHERE IDcompte_payeur=%d %s ORDER BY date;""" % (IDcompte_payeur, conditionReglement) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() listeReglements = [] for IDreglement, date, montant in listeDonnees: listeReglements.append({ "IDreglement": IDreglement, "date": date, "montant": FloatToDecimal(montant) }) # Vérification de la ventilation de chaque règlement listeReglementsAVentiler = [] for dictReglement in listeReglements: IDreglement = dictReglement["IDreglement"] # Recherche s'il reste du crédit à ventiler dans ce règlement montantVentilation = FloatToDecimal(0.0) if IDreglement in dictVentilationsReglement: for IDventilation in dictVentilationsReglement[IDreglement]: montantVentilation += dictVentilations[IDventilation][ "montant"] credit = dictReglement["montant"] - montantVentilation if credit > FloatToDecimal(0.0): # Recherche s'il reste des prestations à ventiler pour cette famille listePrestationsAVentiler = [] for dictPrestation in listePrestations: IDprestation = dictPrestation["IDprestation"] montantVentilation = FloatToDecimal(0.0) if IDprestation in dictVentilationsPrestation: for IDventilation in dictVentilationsPrestation[ IDprestation]: montantVentilation += dictVentilations[IDventilation][ "montant"] ResteAVentiler = dictPrestation["montant"] - montantVentilation if ResteAVentiler > FloatToDecimal(0.0): # Calcul du montant qui peut être ventilé montant = ResteAVentiler if credit < montant: montant = credit if montant > FloatToDecimal(0.0): # Modification d'une ventilation existante ventilationTrouvee = False if IDprestation in dictVentilationsPrestation: for IDventilation in dictVentilationsPrestation[ IDprestation]: if dictVentilations[IDventilation][ "IDreglement"] == IDreglement: nouveauMontant = montant + montantVentilation DB.ReqMAJ("ventilation", [ ("montant", float(nouveauMontant)), ], "IDventilation", IDventilation) # Mémorisation du nouveau montant dictVentilations[IDventilation][ "montant"] = nouveauMontant ResteAVentiler -= montant credit -= montant ventilationTrouvee = True # Création d'une ventilation if ventilationTrouvee == False: listeDonnees = [ ("IDreglement", IDreglement), ("IDcompte_payeur", IDcompte_payeur), ("IDprestation", IDprestation), ("montant", float(montant)), ] IDventilation = DB.ReqInsert( "ventilation", listeDonnees) # Mémorisation de la nouvelle ventilation dictVentilations[IDventilation] = { "IDreglement": IDreglement, "IDprestation": IDprestation, "montant": montant } if (IDreglement in dictVentilationsReglement) == False: dictVentilationsReglement[IDreglement] = [] dictVentilationsReglement[IDreglement].append( IDventilation) if (IDprestation in dictVentilationsPrestation) == False: dictVentilationsPrestation[IDprestation] = [] dictVentilationsPrestation[IDprestation].append( IDventilation) ResteAVentiler -= montant credit -= montant DB.Close() return True