def Validation(self): creditAVentiler = FloatToDecimal(self.montant_reglement) - FloatToDecimal(self.total_ventilation) if self.validation == "ok" : return True if self.validation == "addition" : totalRestePrestationsAVentiler = FloatToDecimal(self.ctrl_ventilation.GetTotalRestePrestationsAVentiler()) if creditAVentiler > totalRestePrestationsAVentiler : creditAVentiler = totalRestePrestationsAVentiler if creditAVentiler > FloatToDecimal(0.0) : dlg = wx.MessageDialog(self, _(u"Vous devez encore ventiler %.2f %s.\n\nEtes-vous sûr de quand même vouloir valider et fermer ?") % (creditAVentiler, SYMBOLE), _(u"Confirmation"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_EXCLAMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES : return False if self.validation == "trop" : dlg = wx.MessageDialog(self, _(u"Vous avez ventilé %.2f %s en trop !") % (-creditAVentiler, SYMBOLE), _(u"Erreur de saisie"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return False if self.validation == "erreur" : dlg = wx.MessageDialog(self, _(u"La ventilation n'est pas valide. Veuillez la vérifier..."), _(u"Erreur de saisie"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return False return True
def SetMontantReglement(self, montant=FloatToDecimal(0.0)): if montant == None : return if type(montant) != decimal.Decimal : montant = FloatToDecimal(montant) self.montant_reglement = montant self.ctrl_ventilation.montant_reglement = montant self.MAJinfos()
def GetPrestations(self): DB = GestionDB.DB() # Recherche de la ventilation req = """SELECT IDprestation, SUM(ventilation.montant) AS total_ventilation FROM ventilation WHERE ventilation.IDreglement=%d GROUP BY IDprestation;""" % self.IDreglement DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() liste_prestations = [] dict_ventilation = {} for IDprestation, total_ventilation in listeDonnees: liste_prestations.append(IDprestation) dict_ventilation[IDprestation] = total_ventilation # Recherche des prestations if len(liste_prestations) == 0: condition_prestations = "()" elif len(liste_prestations) == 1: condition_prestations = "(%d)" % liste_prestations[0] else: condition_prestations = str(tuple(liste_prestations)) req = """SELECT IDprestation, date, categorie, label, activites.IDactivite, activites.nom, activites.abrege, individus.nom, individus.prenom, montant FROM prestations LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu WHERE IDprestation IN %s GROUP BY IDprestation ORDER BY date;""" % condition_prestations DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listePrestations = [] for IDprestation, date, categorie, label, IDactivite, nomActivite, abregeActivite, nomIndividu, prenomIndividu, montant in listeDonnees: dateDD = DateEngEnDateDD(date) if nomActivite == None: nomActivite = "" if abregeActivite == None: abregeActivite = "" if prenomIndividu == None: prenomIndividu = u"" montant = FloatToDecimal(montant) ventilation = FloatToDecimal(dict_ventilation[IDprestation]) dictTemp = { "IDprestation": IDprestation, "date": dateDD, "categorie": categorie, "label": label, "IDactivite": IDactivite, "nomActivite": nomActivite, "abregeActivite": abregeActivite, "prenomIndividu": prenomIndividu, "montant": montant, "ventilation": ventilation, } listePrestations.append(dictTemp) return listePrestations
def GetImageSoldeActuel(track): if track.etat == "annulation" : return self.imgAnnulation if track.soldeActuel == FloatToDecimal(0.0) : return self.imgVert if track.soldeActuel < FloatToDecimal(0.0) and track.soldeActuel != -track.total : return self.imgOrange return self.imgRouge
def FormateSolde(montant): if montant == None: FloatToDecimal(0.0) if montant == FloatToDecimal(0.0): return u"%.2f %s" % (montant, SYMBOLE) elif montant > FloatToDecimal(0.0): return u"- %.2f %s" % (montant, SYMBOLE) else: return u"+ %.2f %s" % (montant, SYMBOLE)
def MAJ(self, majTotaux=True): """ MAJ les données et l'affichage de la ligne """ # MAJ des données if type(self.ventilationActuelle) != decimal.Decimal: self.ventilationActuelle = FloatToDecimal(self.ventilationActuelle) self.resteAVentiler = self.montant - self.ventilationPassee - self.ventilationActuelle # Coche if self.ventilationActuelle != FloatToDecimal(0.0): etat = True else: etat = False self.grid.SetCellValue(self.numLigne, 0, str(int(etat))) # Label self.grid.SetCellValue(self.numLigne, 1, DateComplete(self.date)) # Individu self.grid.SetCellValue(self.numLigne, 2, self.prenomIndividu) # Label de la prestation self.grid.SetCellValue(self.numLigne, 3, self.label) # Facture self.grid.SetCellValue(self.numLigne, 4, self.label_facture) # Montant de la prestation self.grid.SetCellValue(self.numLigne, 5, six.text_type(self.montant)) # Montant déjà ventilé self.grid.SetCellValue(self.numLigne, 6, six.text_type(self.resteAVentiler)) if self.resteAVentiler == 0.0 and self.GetEtat() == True: self.grid.SetCellBackgroundColour(self.numLigne, 6, COULEUR_TOTAL) elif self.resteAVentiler == self.montant: self.grid.SetCellBackgroundColour(self.numLigne, 6, COULEUR_NUL) else: self.grid.SetCellBackgroundColour(self.numLigne, 6, COULEUR_PARTIEL) # Montant ventilé self.grid.SetCellValue(self.numLigne, 7, six.text_type(self.ventilationActuelle)) self.grid.SetReadOnly(self.numLigne, 7, not self.GetEtat()) if self.GetEtat() == True: self.grid.SetCellBackgroundColour(self.numLigne, 7, COULEUR_CASE_MODIFIABLE_ACTIVE) else: self.grid.SetCellBackgroundColour( self.numLigne, 7, COULEUR_CASE_MODIFIABLE_INACTIVE) # MAJ de la ligne de regroupement if majTotaux == True: self.ligneRegroupement.MAJ() self.grid.MAJbarreInfos()
def FormateSolde(montant): if montant == None : return u"" if montant == 0.0 : return u"%.2f %s" % (montant, SYMBOLE) if montant > FloatToDecimal(0.0) : return u"+ %.2f %s" % (montant, SYMBOLE) if montant < FloatToDecimal(0.0) : return u"- %.2f %s" % (-montant, SYMBOLE)
def ColoreLabelVentilationAuto(self): aVentiler = FloatToDecimal(0.0) for ligne in self.ctrl_ventilation.listeLignesPrestations : aVentiler += FloatToDecimal(ligne.montant) - FloatToDecimal(ligne.ventilationPassee) if self.montant_reglement == aVentiler : couleur = wx.Colour(0, 200, 0) else : couleur = "BLUE" self.hyper_automatique.SetColours(couleur, couleur, couleur) self.hyper_automatique.UpdateLink()
def VentilationAuto(self): """ Procédure de ventilation automatique """ # Vérifie qu'il n'y a pas de prestations négatives for ligne in self.ctrl_ventilation.listeLignesPrestations : if FloatToDecimal(ligne.montant) < 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() return False # Ventilation automatique totalVentilation = FloatToDecimal(self.ctrl_ventilation.GetTotalVentile()) resteVentilation = self.montant_reglement - totalVentilation if self.montant_reglement == FloatToDecimal(0.0) : dlg = wx.MessageDialog(self, _(u"Vous avez déjà saisir un montant pour ce règlement !"), _(u"Erreur"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return False if resteVentilation <= FloatToDecimal(0.0) : dlg = wx.MessageDialog(self, _(u"Vous avez déjà ventilé tout le crédit disponible !"), _(u"Erreur"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return False for ligne in self.ctrl_ventilation.listeLignesPrestations : aVentiler = resteVentilation if aVentiler > FloatToDecimal(ligne.resteAVentiler) : aVentiler = FloatToDecimal(ligne.resteAVentiler) if aVentiler > FloatToDecimal(0.0) : montant = aVentiler + ligne.ventilationActuelle ligne.SetEtat(etat=True, montant=montant, majTotaux=False) resteVentilation -= FloatToDecimal(aVentiler) self.ctrl_ventilation.MAJtotaux()
def MAJ(self): # Calcul des heures à facturer self.heures_a_facturer = self.heures_prevues - self.heures_absences_deductibles + self.heures_regularisation + self.duree_solde_rtt self.montant_a_facturer = FloatToDecimal( self.tarif_base * UTILS_Dates.DeltaEnFloat(self.heures_a_facturer)) # Calcul des dépassements self.montant_depassements = FloatToDecimal( self.tarif_depassement * UTILS_Dates.DeltaEnFloat(self.heures_depassements)) self.montant_a_facturer += self.montant_depassements self.heures_a_facturer += self.heures_depassements
def __init__(self, parent, IDcompte_payeur=None, IDreglement=None): wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL) self.parent = parent self.IDcompte_payeur = IDcompte_payeur self.IDreglement = IDreglement self.montant_reglement = FloatToDecimal(0.0) self.total_ventilation = FloatToDecimal(0.0) self.validation = True if "linux" in sys.platform : defaultFont = self.GetFont() defaultFont.SetPointSize(8) self.SetFont(defaultFont) # Regroupement self.label_regroupement = wx.StaticText(self, -1, _(u"Regrouper par :")) self.radio_periode = wx.RadioButton(self, -1, _(u"Mois"), style = wx.RB_GROUP) self.radio_facture = wx.RadioButton(self, -1, _(u"Facture")) self.radio_individu = wx.RadioButton(self, -1, _(u"Individu")) self.radio_date = wx.RadioButton(self, -1, _(u"Date")) # Commandes rapides self.label_hyperliens_1 = wx.StaticText(self, -1, _(u"Ventiler ")) self.hyper_automatique = Hyperlien(self, label=_(u"automatiquement"), infobulle=_(u"Cliquez ici pour ventiler automatiquement le crédit restant"), URL="automatique") self.label_hyperliens_2 = wx.StaticText(self, -1, u" | ") self.hyper_tout = Hyperlien(self, label=_(u"tout"), infobulle=_(u"Cliquez ici pour tout ventiler"), URL="tout") self.label_hyperliens_3 = wx.StaticText(self, -1, u" | ") self.hyper_rien = Hyperlien(self, label=_(u"rien"), infobulle=_(u"Cliquez ici pour ne rien ventiler"), URL="rien") # Liste de la ventilation self.ctrl_ventilation = CTRL_Ventilation(self, IDcompte_payeur, IDreglement) # Etat de la ventilation self.imgOk = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok4.png"), wx.BITMAP_TYPE_PNG) self.imgErreur = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Interdit2.png"), wx.BITMAP_TYPE_PNG) self.imgAddition = wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Addition.png"), wx.BITMAP_TYPE_PNG) self.ctrl_image = wx.StaticBitmap(self, -1, self.imgAddition) self.ctrl_info = wx.StaticText(self, -1, _(u"Vous pouvez encore ventiler 30.90 ¤")) self.ctrl_info.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD)) self.__do_layout() self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_periode) self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_facture) self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_individu) self.Bind(wx.EVT_RADIOBUTTON, self.OnRadioRegroupement, self.radio_date) # Init self.ctrl_ventilation.InitGrid()
def SetSolde(self, montant=FloatToDecimal(0.0)): """ MAJ integrale du controle avec MAJ des donnees """ if montant > FloatToDecimal(0.0): label = u"+ %.2f %s" % (montant, SYMBOLE) self.SetBackgroundColour("#C4BCFC") # Bleu elif montant == FloatToDecimal(0.0): label = u"0.00 %s" % SYMBOLE self.SetBackgroundColour("#5DF020") # Vert else: label = u"- %.2f %s" % (-montant, SYMBOLE) self.SetBackgroundColour("#F81515") # Rouge self.ctrl_solde.SetLabel(label) self.Layout() self.Refresh()
def __init__(self, grid=None, donnees={}): self.grid = grid self.type_ligne = "prestation" # Récupération des données self.IDprestation = donnees["IDprestation"] self.IDcompte_payeur = donnees["IDcompte_payeur"] self.date = donnees["date"] self.date_complete = DateComplete(self.date) self.mois = self.date.month self.annee = self.date.year self.periode = (self.annee, self.mois) self.periode_complete = PeriodeComplete(self.mois, self.annee) self.categorie = donnees["categorie"] self.label = donnees["label"] self.montant = donnees["montant"] self.IDactivite = donnees["IDactivite"] self.nomActivite = donnees["nomActivite"] self.IDtarif = donnees["IDtarif"] self.nomTarif = donnees["nomTarif"] self.nomCategorieTarif = donnees["nomCategorieTarif"] self.IDfacture = donnees["IDfacture"] if self.IDfacture == None or self.IDfacture == "": self.label_facture = _(u"Non facturé") else: IDprefixe = donnees["IDprefixe"] prefixe = donnees["prefixe"] num_facture = donnees["num_facture"] if IDprefixe != None: numeroStr = u"%s-%06d" % (prefixe, num_facture) else: numeroStr = u"%06d" % num_facture date_facture = donnees["date_facture"] self.label_facture = u"n°%s" % numeroStr self.IDfamille = donnees["IDfamille"] self.IDindividu = donnees["IDindividu"] self.nomIndividu = donnees["nomIndividu"] self.prenomIndividu = donnees["prenomIndividu"] if self.prenomIndividu == None: self.prenomIndividu = u"" if self.nomIndividu != None: self.nomCompletIndividu = u"%s %s" % (self.nomIndividu, self.prenomIndividu) else: self.nomCompletIndividu = u"" self.ventilationPassee = donnees["ventilationPassee"] if self.ventilationPassee == None: self.ventilationPassee = FloatToDecimal(0.0) self.ventilationActuelle = FloatToDecimal(0.0) self.resteAVentiler = self.montant - self.ventilationPassee - self.ventilationActuelle
def MAJ(self): # Calcul des totaux total_prestation = FloatToDecimal(0.0) total_aVentiler = FloatToDecimal(0.0) total_ventilationActuelle = FloatToDecimal(0.0) for ligne in self.listeLignesPrestations : total_prestation += ligne.montant total_aVentiler += ligne.resteAVentiler total_ventilationActuelle += ligne.ventilationActuelle # Affichage des totaux self.grid.SetCellValue(self.numLigne, 5, six.text_type(total_prestation)) self.grid.SetCellValue(self.numLigne, 6, six.text_type(total_aVentiler)) self.grid.SetCellValue(self.numLigne, 7, six.text_type(total_ventilationActuelle))
def GetTracks(self): # Récupération des données listeID = None DB = GestionDB.DB() req = """ SELECT IDprestation, prestations.IDindividu, IDfamille, IDcompte_payeur, date, montant, individus.nom, individus.prenom FROM prestations LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu WHERE date>='%s' AND date<='%s' AND IDactivite=%d AND categorie='consommation' GROUP BY IDprestation ;""" % (self.date_debut, self.date_fin, self.IDactivite) DB.ExecuterReq(req) listePrestations = DB.ResultatReq() # Recherche également les consommations req = """ SELECT IDconso, consommations.IDindividu, IDfamille, consommations.IDcompte_payeur, date, individus.nom, individus.prenom FROM consommations LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur WHERE date>='%s' AND date<='%s' AND IDactivite=%d ;""" % (self.date_debut, self.date_fin, self.IDactivite) DB.ExecuterReq(req) listeConsommations = DB.ResultatReq() DB.Close() dictResultats = {} # Traitement des prestations for IDprestation, IDindividu, IDfamille, IDcompte_payeur, date, montant, nomIndividu, prenomIndividu in listePrestations : date = UTILS_Dates.DateEngEnDateDD(date) montant = FloatToDecimal(montant) key = (IDindividu, IDfamille) if dictResultats.has_key(key) == False : dictResultats[key] = {"IDindividu" : IDindividu, "nomIndividu" : nomIndividu, "prenomIndividu" : prenomIndividu, "IDfamille" : IDfamille, "IDcompte_payeur" : IDcompte_payeur, "nbre_conso" : 0, "prestations" : [], "nbre_prestations" : 0, "montant" : FloatToDecimal(0.0)} dictResultats[key]["prestations"].append({"IDprestation" : IDprestation, "montant" : montant}) dictResultats[key]["montant"] += montant dictResultats[key]["nbre_prestations"] += 1 # Traitement des consommations for IDconso, IDindividu, IDfamille, IDcompte_payeur, date, nomIndividu, prenomIndividu in listeConsommations : date = UTILS_Dates.DateEngEnDateDD(date) key = (IDindividu, IDfamille) if dictResultats.has_key(key) == False : dictResultats[key] = {"IDindividu" : IDindividu, "nomIndividu" : nomIndividu, "prenomIndividu" : prenomIndividu, "IDfamille" : IDfamille, "IDcompte_payeur" : IDcompte_payeur, "nbre_conso" : 0, "prestations" : [], "nbre_prestations" : 0, "montant" : FloatToDecimal(0.0)} dictResultats[key]["nbre_conso"] += 1 listeListeView = [] for key, dictTemp in dictResultats.iteritems() : track = Track(self, dictTemp) listeListeView.append(track) return listeListeView
def Remplissage(self): # Regroupement self.dictRegroupements = {} listeKeys = [] nbreLignes = 0 for ligne_prestation in self.listeLignesPrestations : if self.KeyRegroupement == "individu" : key = ligne_prestation.IDindividu if key == 0 or key == None : label = _(u"Prestations diverses") else: label = ligne_prestation.nomCompletIndividu if self.KeyRegroupement == "facture" : key = ligne_prestation.IDfacture label = ligne_prestation.label_facture if self.KeyRegroupement == "date" : key = ligne_prestation.date label = ligne_prestation.date_complete if self.KeyRegroupement == "periode" : key = ligne_prestation.periode label = ligne_prestation.periode_complete if (key in self.dictRegroupements) == False : self.dictRegroupements[key] = { "label" : label, "total" : FloatToDecimal(0.0), "prestations" : [], "ligne_regroupement" : None} listeKeys.append(key) nbreLignes += 1 self.dictRegroupements[key]["prestations"].append(ligne_prestation) self.dictRegroupements[key]["total"] += ligne_prestation.montant nbreLignes += 1 # Tri des Keys listeKeys.sort() # Création des lignes self.AppendRows(nbreLignes) # Création des branches numLigne = 0 self.dictLignes = {} for key in listeKeys : # Niveau 1 : Regroupement dictRegroupement = self.dictRegroupements[key] ligne_regroupement = Ligne_regroupement(self, numLigne, dictRegroupement) self.dictLignes[numLigne] = ligne_regroupement self.dictRegroupements[key]["ligne_regroupement"] = ligne_regroupement numLigne += 1 # Niveau 2 : Prestations for ligne_prestation in self.dictRegroupements[key]["prestations"] : ligne_prestation.Draw(numLigne, ligne_regroupement) ligne_prestation.MAJ(majTotaux=False) ligne_regroupement.listeLignesPrestations.append(ligne_prestation) self.dictLignes[numLigne] = ligne_prestation numLigne += 1 # MAJ de tous les totaux self.MAJtotaux()
def ApplyEdit(self, row, col, grid): valeur = self._tc.GetMontant() grid.GetTable().SetValue(row, col, str(valeur)) self.startValue = '' self._tc.SetValue('') # MAJ de la ligne self.ligne.ventilationActuelle = FloatToDecimal(valeur) self.ligne.MAJ()
def FormateSolde(montant): if montant == None or montant == 0.0 or montant == FloatToDecimal( 0.0): return u"" if montant >= decimal.Decimal(str("0.0")): return u"+ %.2f %s" % (montant, SYMBOLE) else: return u"- %.2f %s" % (-montant, SYMBOLE)
def CocherPayes(self, event=None): for track in self.donnees: if track.montant_impaye == FloatToDecimal(0.0): self.Check(track) else: self.Uncheck(track) self.RefreshObject(track) self.MAJLabelListe()
def GetImageVentilation(track): if track.montant == track.montant_ventilation: return self.imgVert if track.montant_ventilation == FloatToDecimal( 0.0) or track.montant_ventilation == None: return self.imgRouge if track.montant_ventilation < track.montant: return self.imgOrange return self.imgRouge
def GetImageVentilation(track): if track.totalFacture == track.totalRegle: return self.imgVert if track.totalRegle == FloatToDecimal( 0.0) or track.totalRegle == None: return self.imgRouge if track.totalRegle < track.totalFacture: return self.imgOrange return self.imgRouge
def MAJinfos(self, erreur=None): """ Recherche l'état """ if self.montant_reglement == FloatToDecimal(0.0): self.validation = "erreur" self.ctrl_image.SetBitmap(self.imgErreur) self.ctrl_info.SetLabel( _(u"Vous devez déjà saisir un montant pour ce règlement !")) return ## if self.montant_reglement < FloatToDecimal(0.0) : ## self.validation = "ok" ## self.ctrl_image.SetBitmap(self.imgOk) ## self.ctrl_info.SetLabel(_(u"Ventilation non obligatoire")) ## return if erreur == True: self.validation = "erreur" self.ctrl_image.SetBitmap(self.imgErreur) self.ctrl_info.SetLabel( _(u"Vous avez saisi un montant non valide !")) return creditAVentiler = FloatToDecimal( self.montant_reglement) - FloatToDecimal(self.total_ventilation) totalRestePrestationsAVentiler = FloatToDecimal( self.ctrl_ventilation.GetTotalRestePrestationsAVentiler()) if creditAVentiler > totalRestePrestationsAVentiler: creditAVentiler = totalRestePrestationsAVentiler # Recherche de l'état if creditAVentiler == FloatToDecimal(0.0): self.validation = "ok" label = _(u"Le règlement a été correctement ventilé !") elif creditAVentiler > FloatToDecimal(0.0): self.validation = "addition" label = _(u"Vous devez encore ventiler %.2f %s !") % ( creditAVentiler, SYMBOLE) elif creditAVentiler < FloatToDecimal(0.0): self.validation = "trop" label = _(u"Vous avez ventilé %.2f %s en trop !") % ( -creditAVentiler, SYMBOLE) # Affiche l'image if self.validation == "ok": self.ctrl_image.SetBitmap(self.imgOk) if self.validation == "addition": self.ctrl_image.SetBitmap(self.imgAddition) if self.validation == "trop": self.ctrl_image.SetBitmap(self.imgErreur) # MAJ le label d'infos if label != self.ctrl_info.GetLabel(): self.ctrl_info.SetLabel(label) # Colore Label Ventilation Auto self.ColoreLabelVentilationAuto()
def GetImageVentilation(track): if track.montant < FloatToDecimal(0.0) : return None if track.montant_ventilation == None : return self.imgRouge resteAVentiler = FloatToDecimal(track.montant) - FloatToDecimal(track.montant_ventilation) if resteAVentiler == FloatToDecimal(0.0) : return self.imgVert if resteAVentiler > FloatToDecimal(0.0) : return self.imgOrange if resteAVentiler < FloatToDecimal(0.0) : return self.imgRouge
def EndEdit(self, row, col, grid, oldVal): changed = False valeur = self._tc.GetMontant() # Validation du montant saisi if self._tc.Validation() == False : valeur = None # Vérifie si montant saisi pas supérieur à montant à ventilé if valeur != None : resteAVentiler = self.ligne.montant - self.ligne.ventilationPassee - FloatToDecimal(valeur) if resteAVentiler < 0 : dlg = wx.MessageDialog(grid, _(u"Le montant saisi ne peut pas être supérieur au montant à ventiler !"), _(u"Erreur"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() valeur = None # Renvoie la valeur if valeur != oldVal: return valeur else: return None
def __init__(self, parent, IDcompte_payeur=None, IDreglement=None): gridlib.Grid.__init__(self, parent, -1, style=wx.WANTS_CHARS) self.parent = parent self.IDcompte_payeur = IDcompte_payeur self.IDreglement = IDreglement self.listeTracks = [] self.dictVentilation = {} self.dictVentilationInitiale = {} self.ventilationValide = True self.montant_reglement = FloatToDecimal(0.0) self.dictLignes = {} # Options self.bloquer_ventilation = False # Key de regroupement self.KeyRegroupement = "periode" # individu, facture, date, periode # Binds self.Bind(gridlib.EVT_GRID_CELL_LEFT_CLICK, self.OnLeftClick) ## self.Bind(gridlib.EVT_GRID_CELL_RIGHT_CLICK, self.OnRightClick) self.GetGridWindow().Bind(wx.EVT_MOTION, self.OnMouseOver)
def OnBoutonOk(self, event): dictOptions = self.ctrl_parametres.GetOptions() if dictOptions == False: return # Récupération des paramètres listeIDfactures = [] montantTotal = FloatToDecimal(0.0) for track in self.tracks: listeIDfactures.append(track.IDfacture) montantTotal += track.total 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 track.IDfacture in dictPrelevements: montantTotalPrelev += -track.solde dictPrestations = {} dictIndividus = {} dictActivites = {} dictTotaux = {} for IDprestation, IDfacture, label, montant, IDindividu, nom, prenom, IDactivite, nomActivite in listePrestations: if dictActivites != None and (IDactivite in dictActivites) == False: dictActivites[IDactivite] = nomActivite if IDindividu != None and ( IDindividu in dictIndividus) == False and prenom != None: dictIndividus[IDindividu] = u"%s %s" % (nom, prenom) if (IDfacture in dictPrestations) == False: dictPrestations[IDfacture] = {} if (IDindividu in dictPrestations[IDfacture]) == False: dictPrestations[IDfacture][IDindividu] = {} if (label in dictPrestations[IDfacture][IDindividu]) == False: dictPrestations[IDfacture][IDindividu][label] = { "quantite": 0, "montant": 0.0, "IDactivite": IDactivite } if (IDactivite in dictTotaux) == False: dictTotaux[IDactivite] = {} if (label in dictTotaux[IDactivite]) == 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 track.IDfacture in dictPrelevements: 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 = [] dataTableau.append( (Paragraph(_(u"Famille"), styleLabel), Paragraph(_(u"Adresse"), styleLabel), Paragraph(_(u"Prélèvement bancaire"), styleLabel))) dataTableau.append( (Paragraph(track.nomsTitulaires, styleTexte), (Paragraph(rue, styleTexte), Paragraph(u"%s %s" % (cp, ville), styleTexte)), Paragraph(textePrelevement, styleTexte))) largeursColonnes = [180, 140, largeurContenu - 320] 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) # Récupération des champs personnalisés dataTableau = [] label_1, label_2, label_3, question_1, question_2, question_3 = "", "", "", "", "", "" for dictReponse in self.Questionnaires.GetDonnees( track.IDfamille): if dictReponse["champ"] == dictOptions["question_1"]: label_1, question_1 = dictReponse[ "label"], dictReponse["reponse"] if dictReponse["champ"] == dictOptions["question_2"]: label_2, question_2 = dictReponse[ "label"], dictReponse["reponse"] if dictReponse["champ"] == dictOptions["question_3"]: label_3, question_3 = dictReponse[ "label"], dictReponse["reponse"] if len(label_1) > 0 or len(label_2) > 0 or len(label_3) > 0: dataTableau.append( (Paragraph(label_1, styleLabel), Paragraph(label_2, styleLabel), Paragraph(label_3, styleLabel))) dataTableau.append((Paragraph(question_1, styleTexte), Paragraph(question_2, styleTexte), Paragraph(question_3, styleTexte))) largeursColonnes = [ largeurContenu / 3.0, largeurContenu / 3.0, largeurContenu / 3.0 ] 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 track.IDfacture in dictPrestations: # Préparation des champs individuels supplémentaires liste_champs_ind = [] for key in ("champ_ind_1", "champ_ind_2", "champ_ind_3"): if dictOptions[key] not in ("non", "", None): liste_champs_ind.append(dictOptions[key]) if len(liste_champs_ind) == 0: 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] else: # On rajoute la colonne Infos individuelles : dataTableau = [ (Paragraph(_(u"Individu"), styleLabel), Paragraph(_(u"Informations"), styleLabel), Paragraph(_(u"Activité"), styleLabel), Paragraph(_(u"Prestation"), styleLabel), Paragraph(_(u"Quantité"), styleLabel), Paragraph(_(u"Montant total"), styleLabel)), ] largeursColonnes = [120, 110, 100, 105, 35, 50] for IDindividu, dictLabels in dictPrestations[ track.IDfacture].items(): if IDindividu in dictIndividus: labelIndividu = dictIndividus[IDindividu] else: labelIndividu = u"" listeActivites = [] listeLabels = [] listeQuantites = [] listeMontants = [] for labelPrestation, dictTemp in dictLabels.items(): if dictTemp["IDactivite"] != None and dictTemp[ "IDactivite"] in dictActivites: 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)) ligne = [ Paragraph(labelIndividu, styleTexte2), listeActivites, listeLabels, listeQuantites, listeMontants, ] # Récupération des infos individuelles if len(liste_champs_ind) > 0: liste_textes_ind = [] for key in liste_champs_ind: # Ecole if "ecole" in key or "classe" in key or "niveau" in key: if "date_debut" in key: date_reference = track.date_debut else: date_reference = track.date_fin infosIndividus = UTILS_Infos_individus.Informations( date_reference=date_reference, qf=False, inscriptions=False, messages=False, infosMedicales=False, cotisationsManquantes=False, piecesManquantes=False, questionnaires=False, scolarite=True) dictInfosIndividus = infosIndividus.GetDictValeurs( mode="individu", ID=IDindividu, formatChamp=False) texte = "" if "ecole" in key and "SCOLARITE_NOM_ECOLE" in dictInfosIndividus: texte = dictInfosIndividus[ "SCOLARITE_NOM_ECOLE"] if "classe" in key and "SCOLARITE_NOM_CLASSE" in dictInfosIndividus: texte = dictInfosIndividus[ "SCOLARITE_NOM_CLASSE"] if "niveau" in key and "SCOLARITE_NOM_NIVEAU" in dictInfosIndividus: texte = dictInfosIndividus[ "SCOLARITE_NOM_NIVEAU"] liste_textes_ind.append( Paragraph(texte, styleTexte2)) ligne.insert(1, liste_textes_ind) # Insertion de la ligne dans le tableau dataTableau.append(ligne) 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.items(): if IDactivite == None: nomActivite = _(u"Prestations diverses") else: nomActivite = dictActivites[IDactivite] listeLabels = [] listeQuantites = [] listeMontants = [] quantiteActivite = 0 totalActivite = 0.0 for label, dictTemp in dictLabels.items(): 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 as 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 FonctionsPerso.LanceFichierExterne(nomDoc)
def __init__(self, donnees): self.IDfacture = donnees["IDfacture"] self.IDprefixe = donnees["IDprefixe"] self.prefixe = donnees["prefixe"] self.numero = donnees["numero"] if self.numero == None : self.numero = 0 self.numero_int = int(self.numero) if self.IDprefixe != None : self.numero = u"%s-%06d" % (self.prefixe, self.numero) else : self.numero = u"%06d" % self.numero self.IDcompte_payeur = donnees["IDcompte_payeur"] self.etat = donnees["etat"] self.date_edition = donnees["date_edition"] self.date_echeance = donnees["date_echeance"] self.IDutilisateur = donnees["IDutilisateur"] self.date_debut = donnees["date_debut"] self.date_fin = donnees["date_fin"] self.total = donnees["total"] self.regle = donnees["regle"] self.solde = donnees["solde"] if self.solde != FloatToDecimal(0.0) : self.solde = -self.solde self.totalPrestations = donnees["totalPrestations"] self.totalVentilation = donnees["totalVentilation"] if self.totalVentilation == None : self.totalVentilation = FloatToDecimal(0.0) self.soldeActuel = self.totalVentilation - self.totalPrestations if self.etat == "annulation" : self.soldeActuel = None self.IDfamille = donnees["IDfamille"] self.nomsTitulaires = donnees["titulaires"] self.IDlot = donnees["IDlot"] self.nomLot = donnees["nomLot"] self.adresse_famille = donnees["adresse_famille"] self.titulaire_helios = donnees["titulaire_helios"] # Prélèvement self.prelevement_activation = donnees["prelevement_activation"] self.prelevement_etab = donnees["prelevement_etab"] self.prelevement_guichet = donnees["prelevement_guichet"] self.prelevement_numero = donnees["prelevement_numero"] self.prelevement_cle = donnees["prelevement_cle"] self.prelevement_banque = donnees["prelevement_banque"] self.prelevement_individu = donnees["prelevement_individu"] self.prelevement_nom = donnees["prelevement_nom"] self.prelevement_rue = donnees["prelevement_rue"] self.prelevement_cp = donnees["prelevement_cp"] self.prelevement_ville = donnees["prelevement_ville"] self.prelevement_cle_iban = donnees["prelevement_cle_iban"] self.prelevement_iban = donnees["prelevement_iban"] self.prelevement_bic = donnees["prelevement_bic"] self.prelevement_reference_mandat = donnees["prelevement_reference_mandat"] self.prelevement_date_mandat = donnees["prelevement_date_mandat"] if self.prelevement_activation == 1 : self.prelevement = True else : self.prelevement = False self.nomPayeur = donnees["nomPayeur"] self.prenomPayeur = donnees["prenomPayeur"] if self.nomPayeur == None : self.nomPayeur = u"" if self.prenomPayeur == None : self.prenomPayeur = u"" if self.prelevement_individu == None : self.prelevement_payeur = self.prelevement_nom else : self.prelevement_payeur = u"%s %s" % (self.nomPayeur, self.prenomPayeur) # Envoi par Email self.email_factures = donnees["email_factures"] if self.email_factures != None : self.email = True else : self.email = False
def GetListeFactures(self): dictTitulaires = UTILS_Titulaires.GetTitulaires() DB = GestionDB.DB() # Conditions listeConditions = [] if self.IDcompte_payeur != None : listeConditions.append("prestations.IDcompte_payeur = %d" % self.IDcompte_payeur) # 1ère série de filtres if self.filtres != None : for filtre in self.filtres : # IDfacture_intervalle if filtre["type"] == "IDfacture_intervalle" : listeConditions.append( "(factures.IDfacture>=%d AND factures.IDfacture<=%d)" % (filtre["IDfacture_min"], filtre["IDfacture_max"]) ) # IDfacture_liste if filtre["type"] == "IDfacture_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( "factures.IDfacture IN %s" % listeTemp) # Préfixe if filtre["type"] == "prefixe" : if filtre["IDprefixe"] == None : listeConditions.append( "factures.IDprefixe IS NULL") else : listeConditions.append( "factures.IDprefixe=%d" % filtre["IDprefixe"]) # Lot de factures if filtre["type"] == "lot" : listeConditions.append( "factures.IDlot=%d" % filtre["IDlot"]) # Date d'émission if filtre["type"] == "date_emission" : listeConditions.append( "(factures.date_edition>='%s' AND factures.date_edition<='%s')" % (filtre["date_min"], filtre["date_max"]) ) # Date d'échéance if filtre["type"] == "date_echeance" : listeConditions.append( "(factures.date_echeance>='%s' AND factures.date_echeance<='%s')" % (filtre["date_min"], filtre["date_max"]) ) # numero_intervalle if filtre["type"] == "numero_intervalle" : listeConditions.append( "(factures.numero>=%d AND factures.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( "factures.numero IN %s" % listeTemp) if len(listeConditions) > 0 : conditions = "WHERE %s" % " AND ".join(listeConditions) else : conditions = "" # Récupération des totaux des prestations pour chaque facture req = """ SELECT prestations.IDfacture, SUM(prestations.montant) FROM prestations LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture %s GROUP BY prestations.IDfacture ;""" % conditions DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictPrestations = {} for IDfacture, totalPrestations in listeDonnees : if IDfacture != None : dictPrestations[IDfacture] = totalPrestations # Récupération des factures req = """ SELECT factures.IDfacture, factures.IDprefixe, factures_prefixes.prefixe, factures.numero, factures.IDcompte_payeur, factures.date_edition, factures.date_echeance, factures.IDutilisateur, factures.date_debut, factures.date_fin, factures.total, factures.regle, factures.solde, comptes_payeurs.IDfamille, factures.IDlot, lots_factures.nom, factures.etat FROM factures LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur LEFT JOIN lots_factures ON lots_factures.IDlot = factures.IDlot LEFT JOIN factures_prefixes ON factures_prefixes.IDprefixe = factures.IDprefixe %s ORDER BY factures.date_edition ;""" % conditions.replace("prestations.IDcompte_payeur", "comptes_payeurs.IDcompte_payeur") DB.ExecuterReq(req) listeFactures = DB.ResultatReq() # Récupération de la ventilation req = """ SELECT prestations.IDfacture, SUM(ventilation.montant) FROM ventilation LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = prestations.IDcompte_payeur LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture %s GROUP BY prestations.IDfacture ;""" % conditions DB.ExecuterReq(req) listeVentilation = DB.ResultatReq() dictVentilation = {} for IDfacture, montantVentilation in listeVentilation : if IDfacture != None : dictVentilation[IDfacture] = montantVentilation # 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, prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat, email_factures, comptes_payeurs.IDcompte_payeur, individus.nom, individus.prenom, titulaire_helios FROM familles LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = familles.IDfamille LEFT JOIN individus ON individus.IDindividu = prelevement_individu %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, prelevement_cle_iban, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat, email_factures, IDcompte_payeur, nomPayeur, prenomPayeur, titulaire_helios in listeInfosFamilles : prelevement_date_mandat = UTILS_Dates.DateEngEnDateDD(prelevement_date_mandat) 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, "prelevement_cle_iban" : prelevement_cle_iban, "prelevement_iban" : prelevement_iban, "prelevement_bic" : prelevement_bic, "prelevement_reference_mandat" : prelevement_reference_mandat, "prelevement_date_mandat" : prelevement_date_mandat, "email_factures" : email_factures, "nomPayeur" : nomPayeur, "prenomPayeur" : prenomPayeur, "titulaire_helios" : titulaire_helios, } DB.Close() listeResultats = [] for IDfacture, IDprefixe, prefixe, numero, IDcompte_payeur, date_edition, date_echeance, IDutilisateur, date_debut, date_fin, total, regle, solde, IDfamille, IDlot, nomLot, etat in listeFactures : if numero == None : numero = 0 date_edition = UTILS_Dates.DateEngEnDateDD(date_edition) date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) date_echeance = UTILS_Dates.DateEngEnDateDD(date_echeance) total = FloatToDecimal(total) if IDfacture in dictVentilation : totalVentilation = FloatToDecimal(dictVentilation[IDfacture]) else : totalVentilation = FloatToDecimal(0.0) if IDfacture in dictPrestations : totalPrestations = FloatToDecimal(dictPrestations[IDfacture]) else : totalPrestations = FloatToDecimal(0.0) solde_actuel = totalPrestations - totalVentilation if (IDfamille in dictTitulaires) == True : titulaires = dictTitulaires[IDfamille]["titulairesSansCivilite"] adresse_famille = dictTitulaires[IDfamille]["adresse"] dictTemp = { "IDfacture" : IDfacture, "IDprefixe" : IDprefixe, "prefixe" : prefixe, "numero" : numero, "IDcompte_payeur" : IDcompte_payeur, "date_edition" : date_edition, "date_echeance" : date_echeance, "IDutilisateur" : IDutilisateur, "date_debut" : date_debut, "date_fin" : date_fin, "total" : total, "regle" : regle, "solde" : solde, "totalPrestations" : totalPrestations, "totalVentilation" : totalVentilation, "IDfamille" : IDfamille, "titulaires" : titulaires, "IDlot" : IDlot, "nomLot" : nomLot, "adresse_famille" : adresse_famille, "etat" : etat, } if IDcompte_payeur in dictInfosFamilles : dictTemp.update(dictInfosFamilles[IDcompte_payeur]) valide = True # 2ème série de filtres if self.filtres != None : for filtre in self.filtres : # IDfacture_intervalle if filtre["type"] == "solde_initial" : if self.ComparateurFiltre(-solde, filtre["operateur"], filtre["montant"]) == False : valide = False if filtre["type"] == "solde_actuel" : if self.ComparateurFiltre(-solde_actuel, filtre["operateur"], filtre["montant"]) == False : valide = False if filtre["type"] == "prelevement" : if filtre["choix"] == True : if dictTemp["prelevement_activation"] == None : valide = False else : if dictTemp["prelevement_activation"] != None : 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 if etat == "annulation" and self.afficherAnnulations == False : valide = False # Mémorisation des valeurs if valide == True : listeResultats.append(dictTemp) return listeResultats
def OnBoutonOk(self, event): montant = self.ctrl_montant.GetMontant() if montant == 0.0: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir un montant !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_montant.SetFocus() return if montant < 0.0: dlg = wx.MessageDialog( self, _(u"Le montant doit obligatoirement être positif !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_montant.SetFocus() return if self.solde != None and FloatToDecimal(montant) > FloatToDecimal( self.solde): dlg = wx.MessageDialog( self, _(u"Le montant du remboursement ne doit pas être supérieur au solde du compte !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_montant.SetFocus() return IDcompte = self.ctrl_compte.GetID() if IDcompte == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner un compte bancaire !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_compte.SetFocus() IDpayeur = self.ctrl_payeur.GetID() if IDpayeur == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner un payeur !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_payeur.SetFocus() IDmode = self.ctrl_mode.GetID() if IDmode == None: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement sélectionner un mode de règlement !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() self.ctrl_mode.SetFocus() return observations = self.ctrl_observations.GetValue() DB = GestionDB.DB() # Récupère IDfamille req = """SELECT IDfamille FROM comptes_payeurs WHERE IDcompte_payeur=%d """ % self.IDcompte_payeur DB.ExecuterReq(req) IDfamille = DB.ResultatReq()[0][0] # Enregistrement de la prestation positive listeDonnees = [ ("IDcompte_payeur", self.IDcompte_payeur), ("date", str(datetime.date.today())), ("categorie", "autre"), ("label", _(u"Remboursement")), ("montant_initial", montant), ("montant", montant), ("IDfamille", IDfamille), ("date_valeur", str(datetime.date.today())), ] IDprestation_positive = DB.ReqInsert("prestations", listeDonnees) # Ventiler la prestation positive avec l'avoir VentilationAuto(self.IDcompte_payeur) # Enregistrement de la prestation négative listeDonnees = [ ("IDcompte_payeur", self.IDcompte_payeur), ("date", str(datetime.date.today())), ("categorie", "autre"), ("label", _(u"Remboursement")), ("montant_initial", -montant), ("montant", -montant), ("IDfamille", IDfamille), ("date_valeur", str(datetime.date.today())), ] IDprestation_negative = DB.ReqInsert("prestations", listeDonnees) # Enregistrement du règlement négatif listeDonnees = [ ("IDcompte_payeur", self.IDcompte_payeur), ("date", str(datetime.date.today())), ("IDmode", IDmode), ("montant", -montant), ("IDpayeur", IDpayeur), ("observations", observations), ("IDcompte", IDcompte), ("date_saisie", str(datetime.date.today())), ("IDutilisateur", UTILS_Identification.GetIDutilisateur()), ] IDreglement = DB.ReqInsert("reglements", listeDonnees) # Ventilation de la prestation négative sur le règlement listeDonnees = [ ("IDreglement", IDreglement), ("IDcompte_payeur", self.IDcompte_payeur), ("IDprestation", IDprestation_negative), ("montant", -montant), ] IDventilation = DB.ReqInsert("ventilation", listeDonnees) DB.Close() # Fermeture self.EndModal(wx.ID_OK)
def FormateMontant(montant): if montant in ("", None, FloatToDecimal(0.0)): return "" return u"%.2f %s" % (montant, SYMBOLE)