def FormatePeriode(periode): if periode != None and ";" in periode: date_fin, date_debut = periode.split(";") return _(u"Du %s au %s") % (UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)) else: return periode
def GetListeDonnees(self): self.dictDonnees = {} if self.IDactivite == None: return [] db = GestionDB.DB() req = """SELECT IDmodele, modeles_contrats.nom, modeles_contrats.IDactivite, modeles_contrats.date_debut, modeles_contrats.date_fin, IDtarif, donnees FROM modeles_contrats LEFT JOIN activites ON activites.IDactivite = modeles_contrats.IDactivite WHERE modeles_contrats.IDactivite=%d ORDER BY modeles_contrats.date_debut;""" % self.IDactivite db.ExecuterReq(req) listeDonnees = db.ResultatReq() db.Close() listeItems = [] index = 0 for IDmodele, nom, IDactivite, date_debut, date_fin, IDtarif, donnees in listeDonnees: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) donnees = cPickle.loads(str(donnees)) self.dictDonnees[index] = { "ID": IDmodele, "nom ": nom, "IDactivite": IDactivite, "date_debut": date_debut, "date_fin": date_fin, "IDtarif": IDtarif, "donnees": donnees } label = _(u"%s - du %s au %s") % ( nom, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)) listeItems.append(label) index += 1 return listeItems
def Suite(self): # Recherche des activites ressemblantes pour le recopiage de tarification DB = GestionDB.DB() req = """SELECT activites.IDactivite, activites.nom, activites.date_debut, activites.date_fin FROM activites LEFT JOIN tarifs ON tarifs.IDactivite = activites.IDactivite WHERE type='FORFAIT' AND forfait_saisie_auto=1 AND forfait_suppression_auto=1 AND activites.date_debut IS NOT NULL and activites.date_fin IS NOT NULL GROUP BY activites.IDactivite ORDER BY activites.date_debut DESC;""" DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) > 0: liste_activites = [ (None, _(u"Non")), ] for IDactivite, nom, date_debut, date_fin in listeDonnees: if date_debut != None: date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) if date_fin != None: date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) label = u"%s - Du %s au %s" % ( nom, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)) liste_activites.append((IDactivite, label)) self.parent.dict_valeurs[ "activites_ressemblantes"] = liste_activites return Page_recopier_tarifs self.parent.dict_valeurs["recopier_tarifs"] = None return Page_categories_tarifs
def MAJ(self): self.listeTarifs = self.Importation() listeItems = [] for dictTarif in self.listeTarifs: IDtarif = dictTarif["IDtarif"] nom = dictTarif["nomTarif"] date_debut = dictTarif["date_debut"] date_fin = dictTarif["date_fin"] if date_debut == None and date_fin == None: label = _(u"%s (Sans période de validité)") % nom if date_debut == None and date_fin != None: label = _(u"%s (Jusqu'au %s)") % ( nom, UTILS_Dates.DateDDEnFr(date_fin)) if date_debut != None and date_fin == None: label = _(u"%s (A partir du %s)") % ( nom, UTILS_Dates.DateDDEnFr(date_debut)) if date_debut != None and date_fin != None: label = _(u"%s (Du %s au %s)") % ( nom, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)) description = dictTarif["nomPrecisTarif"] + " --- " + " ou ".join( dictTarif["listeNomsCategories"]) listeItems.append({"label": label, "description": description}) self.SetDonnees(listeItems)
def FormateValidite(validite): if validite[0] == "periode": return _(u"Du %s au %s") % (UTILS_Dates.DateDDEnFr( validite[1]), UTILS_Dates.DateDDEnFr(validite[2])) if validite[0] == "duree": return _(u"%d jours / %d mois / %s années") % ( validite[3], validite[2], validite[1])
def GetLabelParametres(self): listeParametres = [] # Dates et Mode mode = self.ctrl_parametres.GetMode() date_debut = self.ctrl_parametres.ctrl_date_debut.GetDate() date_fin = self.ctrl_parametres.ctrl_date_fin.GetDate() if date_debut == None: date_debut = "---" if date_fin == None: date_fin = "---" if mode == "saisis": listeParametres.append( _(u"Règlements saisis du %s au %s") % (DateEngFr(str(date_debut)), DateEngFr(str(date_fin)))) if mode == "deposes": listeParametres.append( _(u"Règlements déposés du %s au %s") % (DateEngFr(str(date_debut)), DateEngFr(str(date_fin)))) if mode == "nondeposes": listeParametres.append(_(u"Règlements non déposés")) # Affichage listeAffichage = [] for filtre in self.ctrl_parametres.GetFiltres(): if filtre == "consommation": listeAffichage.append("Consommations") if filtre == "cotisation": listeAffichage.append("Cotisations") if filtre == "location": listeAffichage.append("Locations") if filtre == "autre": listeAffichage.append("Autres") if filtre == "avoir": listeAffichage.append("Avoirs") affichage = ", ".join(listeAffichage) listeParametres.append(_(u"Eléments affichés : %s") % affichage) # Activités activites = self.ctrl_parametres.GetLabelActivites() listeParametres.append(_(u"Activités : %s") % activites) # Année de ventilation ventilation = self.GetVentilation() if ventilation != None: if ventilation == 0: listeParametres.append( _(u"Uniquement des règlements non ventilés")) elif type(ventilation) == list: listeParametres.append( _(u"Uniquement des règlements ventilés sur la période du %s au %s" ) % (UTILS_Dates.DateDDEnFr(ventilation[0]), UTILS_Dates.DateDDEnFr(ventilation[1]))) else: listeParametres.append( _(u"Uniquement des règlements ventilés sur l'année %d") % ventilation) labelParametres = " | ".join(listeParametres) return labelParametres
def __init__(self, donnees={}, dictIndividus=None, dictUnites=None, dictParametres=None, nomFichier=""): self.nomFichier = nomFichier self.categorie = donnees["categorie"] self.nom_appareil = dictParametres["nom_appareil"] self.ID_appareil = dictParametres["ID_appareil"] self.statut = None self.appareil = u"%s (%s)" % (self.nom_appareil, self.ID_appareil) # Consommations if self.categorie == "consommation": self.IDconso = donnees["IDconso"] self.horodatage = donnees["horodatage"] self.action = donnees["action"] self.IDindividu = donnees["IDindividu"] self.IDactivite = donnees["IDactivite"] self.IDinscription = donnees["IDinscription"] self.date = donnees["date"] self.IDunite = donnees["IDunite"] self.IDgroupe = donnees["IDgroupe"] self.heure_debut = donnees["heure_debut"] self.heure_fin = donnees["heure_fin"] self.etat = donnees["etat"] self.date_saisie = donnees["date_saisie"] self.IDutilisateur = donnees["IDutilisateur"] self.IDcategorie_tarif = donnees["IDcategorie_tarif"] self.IDcompte_payeur = donnees["IDcompte_payeur"] self.quantite = donnees["quantite"] self.IDfamille = donnees["IDfamille"] self.nomUnite = dictUnites[self.IDunite] self.nomIndividu = dictIndividus[self.IDindividu] self.detail = _(u"%s %s le %s pour %s") % ( self.action.capitalize(), self.nomUnite, UTILS_Dates.DateDDEnFr(self.date), self.nomIndividu) # Consommations if self.categorie == "memo_journee": self.IDmemo = donnees["IDmemo"] self.horodatage = donnees["horodatage"] self.action = donnees["action"] self.IDindividu = donnees["IDindividu"] self.date = donnees["date"] self.texte = donnees["texte"] self.nomIndividu = dictIndividus[self.IDindividu] self.detail = _(u"%s le %s pour %s le texte '%s'") % ( self.action.capitalize(), UTILS_Dates.DateDDEnFr( self.date), self.nomIndividu, self.texte)
def FormateDateCourt(dateDD): if dateDD == None : return "" if dateDD == "2999-01-01" : return _(u"Illimitée") else: return UTILS_Dates.DateDDEnFr(dateDD)
def Remplissage(self): """ Remplissage """ self.dictItems = {} # Importation self.listeEvenements = self.Importation() # Création de la racine self.root = self.AddRoot(_(u"Evènements")) # Regroupement des données dictActivites = {} dictEvenements = {} for dictEvenement in self.listeEvenements : IDactivite = dictEvenement["IDactivite"] date = dictEvenement["date"] if dictEvenements.has_key(IDactivite) == False : dictEvenements[IDactivite] = {} dictActivites[IDactivite] = dictEvenement["nomActivite"] if dictEvenements[IDactivite].has_key(date) == False : dictEvenements[IDactivite][date] = [] dictEvenements[IDactivite][date].append(dictEvenement) # Tri des activités par ordre alpha listeActivites = [(dictActivites[IDactivite], IDactivite) for IDactivite in dictEvenements.keys()] listeActivites.sort() for nomActivite, IDactivite in listeActivites : niveauActivite = self.AppendItem(self.root, nomActivite) self.SetItemBold(niveauActivite) self.SetPyData(niveauActivite, {"type" : "activite", "IDactivite" : IDactivite}) # Tri des dates listeDates = dictEvenements[IDactivite].keys() listeDates.sort() for date in listeDates : niveauDate = self.AppendItem(niveauActivite, UTILS_Dates.DateDDEnFr(date)) for dictEvenement in dictEvenements[IDactivite][date] : IDevenement = dictEvenement["IDevenement"] label = dictEvenement["nom"] if dictEvenement["heure_debut"] != None and dictEvenement["heure_fin"] != None : label += u" (%s-%s)" % (dictEvenement["heure_debut"].replace(":", "h"), dictEvenement["heure_fin"].replace(":", "h")) if self.activeCheck == True : niveauEvenement = self.AppendItem(niveauDate, label, ct_type=1) else: niveauEvenement = self.AppendItem(niveauDate, label) self.SetPyData(niveauEvenement, {"type": "evenement", "IDevenement": IDevenement}) self.dictItems[IDevenement] = niveauEvenement self.ExpandAll() if self.activation == False : self.EnableChildren(self.root, False)
def __init__(self, donnees): self.IDindividu = donnees["IDindividu"] self.nom = donnees["nom"] self.prenom = donnees["prenom"] if self.prenom == None : self.prenom = u"" self.nomComplet = u"%s %s" % (self.nom, self.prenom) self.consommations = donnees["consommations"] # Création du label des consommations dictDates = {} for dictTemp in self.consommations : # Tri des consommations par date date = dictTemp["date"] if dictDates.has_key(date) == False : dictDates[date] = [] dictDates[date].append(dictTemp["abregeUnite"]) listeDates = dictDates.keys() listeDates.sort() self.nbreDates = len(listeDates) self.listeLabels = [] for date in listeDates : self.listeLabels.append(u"%s (%s)" % (UTILS_Dates.DateDDEnFr(date), "+".join(dictDates[date]))) self.labelConsommations = ", ".join(self.listeLabels)
def GetTexteDernierQF(self): DB = GestionDB.DB() req = """ SELECT date_debut, date_fin, quotient, revenu, types_quotients.nom FROM quotients LEFT JOIN types_quotients ON types_quotients.IDtype_quotient = quotients.IDtype_quotient WHERE IDfamille=%d ORDER BY date_fin DESC """ % self.IDfamille DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() texte = _(u"Aucun précédent QF") if len(listeDonnees) > 0 : date_debut, date_fin, quotient, revenu, nom_quotient = listeDonnees[0] date_debut = UTILS_Dates.DateEngEnDateDD(date_debut) date_fin = UTILS_Dates.DateEngEnDateDD(date_fin) if revenu == 0.0 : revenu = None if quotient != None and revenu == None : texte = _(u"Dernier quotient familial : %d du %s au %s (%s)") % (quotient, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin), nom_quotient) elif quotient == None and revenu != None : texte = _(u"Dernier revenu : %d du %s au %s (%s)") % (revenu, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin), nom_quotient) elif quotient != None and revenu != None : texte = _(u"Dernier quotient/revenu : %s/%s du %s au %s (%s)") % (quotient, revenu, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin), nom_quotient) return texte
def OnBoutonOk(self, event): # Validation des données tracks = self.ctrl_factures.GetTracksCoches() if len(tracks) == 0 : dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune facture à inclure dans votre lot de prélèvements !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False dictFacturesPrelevees = self.GetFacturesPrelevees() listeErreursSoldes = [] listeErreursRIB = [] for track in tracks : # Vérifie que la facture est bien impayée if track.soldeActuel >= 0.0 : listeErreursSoldes.append(track) # Vérifie que la famille a une autorisation de prélèvement if track.prelevement not in (True, 1) : listeErreursRIB.append(track) # Recherche si la facture n'est pas déjà dans un autre prélèvement listeAutresLots = [] if dictFacturesPrelevees.has_key(track.IDfacture) : for dictTemp in dictFacturesPrelevees[track.IDfacture] : if dictTemp["IDlot"] != self.IDlot : nomPrelevement = dictTemp["nomPrelevement"] datePrelevement = UTILS_Dates.DateDDEnFr(dictTemp["datePrelevement"]) statut = dictTemp["statut"] listeAutresLots.append(_(u"- %s (%s) avec le statut '%s'") % (nomPrelevement, datePrelevement, statut.capitalize())) if len(listeAutresLots) > 0 : message1 = _(u"La facture n°%s est déjà présente dans les autres lots de prélèvements suivants. Souhaitez-vous tout de même l'inclure de votre lot de prélèvements actuel ?") % track.numero message2 = "\n".join(listeAutresLots) dlg = dialogs.MultiMessageDialog(self, message1, caption=_(u"Avertissement"), msg2=message2, style = wx.ICON_QUESTION |wx.NO | wx.CANCEL | wx.YES | wx.YES_DEFAULT, icon=None, btnLabels={wx.ID_YES : _(u"Oui"), wx.ID_NO : _(u"Non"), wx.ID_CANCEL : _(u"Annuler")}) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES : return False if len(listeErreursSoldes) > 0 : dlg = wx.MessageDialog(self, _(u"Vous avez sélectionné %d factures qui ont déjà été payées !") % len(listeErreursSoldes), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False if len(listeErreursRIB) > 0 : dlg = wx.MessageDialog(self, _(u"Vous avez sélectionné %d factures pour des familles qui n'ont pas d'autorisation de prélèvement !") % len(listeErreursRIB), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Fermeture self.EndModal(wx.ID_OK)
def Supprimer(self, event): if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0: dlg = wx.MessageDialog( self, _(u"Vous n'avez sélectionné aucune consommation à 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 consommations cochées ?" ), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION) 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 consommation sélectionnée ?" ), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return # Suppression listeSuppressions = [] for track in listeSelections: if track.etat in ("present", "absenti", "absentj"): dlg = wx.MessageDialog( self, _(u"Vous ne pouvez pas supprimer la consommation '%s' du %s car elle est déjà pointée !" ) % (track.nomUnite, UTILS_Dates.DateDDEnFr(track.date)), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return listeSuppressions.append(track) # Suppression de la liste self.RemoveObjects(listeSuppressions) self.MAJ_label_page()
def OnBoutonOk(self, event): # Vérifie que la conversion de type est possible if self.IDunite != None: DB = GestionDB.DB() req = """SELECT IDindividu, date, COUNT(IDconso) FROM consommations WHERE IDunite=%d GROUP BY IDindividu, date ;""" % self.IDunite DB.ExecuterReq(req) listeConsommations = DB.ResultatReq() DB.Close() listeDates = [] for IDindividu, date, nbreConso in listeConsommations: if nbreConso > 1: dateDD = UTILS_Dates.DateEngEnDateDD(date) listeDates.append(dateDD) listeDates.sort() if len( listeDates ) > 0 and self.typeUnite == "Multihoraires" and self.ctrl_type.GetType( ) != "Multihoraires": periode = _(u"entre le %s et le %s") % (UTILS_Dates.DateDDEnFr( listeDates[0]), UTILS_Dates.DateDDEnFr(listeDates[-1])) dlg = wx.MessageDialog( self, _(u"Des consommations multiples ont déjà été saisies sur %d dates (%s) !\n\nIl est donc impossible de convertir cette unité multihoraire en un autre type d'unité." ) % (len(listeDates), periode), _(u"Erreur"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return # Sauvegarde etat = self.Sauvegarde() if etat == False: return # Fermeture de la fenêtre self.EndModal(wx.ID_OK)
def OnBoutonAfficher(self, event): """ Validation des données saisies """ listeParametres = [] # Vérifie période de référence 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 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 listeParametres.append(_(u"Période du %s au %s") % (UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin))) # 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é !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False activites = ", ".join(self.ctrl_activites.GetLabelActivites()) if activites == "" : activites = _(u"Aucune") listeParametres.append(_(u"Activités : %s") % activites) # Affichage if self.ctrl_affichage.GetSelection() == 0 : affichage = "absenti" listeParametres.append(_(u"Uniquement les absences injustifiées")) else : affichage = "absentj" listeParametres.append(_(u"Uniquement les absences justifiées")) labelParametres = " | ".join(listeParametres) # Envoi des données self.parent.MAJ(periode=(date_debut, date_fin), listeActivites=listeActivites, affichage=affichage, labelParametres=labelParametres) return True
def SetListeDonnees(self, listeTarifs=[]): self.listeNoms = [] self.listeTarifs = listeTarifs for dictTarif in listeTarifs: IDtarif = dictTarif["IDtarif"] nom = dictTarif["nomTarif"] if nom == None: nom = _(u"Sans nom") date_debut = dictTarif["date_debut"] date_fin = dictTarif["date_fin"] if date_debut == None and date_fin == None: label = _(u"%s (Sans période de validité)") % nom if date_debut == None and date_fin != None: label = _(u"%s (Jusqu'au %s)") % ( nom, UTILS_Dates.DateDDEnFr(date_fin)) if date_debut != None and date_fin == None: label = _(u"%s (A partir du %s)") % ( nom, UTILS_Dates.DateDDEnFr(date_debut)) if date_debut != None and date_fin != None: label = _(u"%s (Du %s au %s)") % ( nom, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)) self.listeNoms.append(label) self.SetItems(self.listeNoms)
def GetListeDonnees(self): self.dictDonnees = {} if self.IDactivite == None: return [] DB = GestionDB.DB() req = """SELECT contrats.IDcontrat, contrats.date_debut, contrats.date_fin, activites.nom, SUM(prestations.montant) as total, individus.nom, individus.prenom FROM contrats LEFT JOIN inscriptions ON inscriptions.IDinscription=contrats.IDinscription LEFT JOIN activites ON activites.IDactivite=inscriptions.IDactivite LEFT JOIN prestations ON prestations.IDcontrat = contrats.IDcontrat LEFT JOIN individus ON individus.IDindividu = contrats.IDindividu WHERE inscriptions.IDactivite=%d GROUP BY contrats.IDcontrat ORDER BY contrats.date_debut; """ % self.IDactivite DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() listeItems = [] index = 0 for IDcontrat, date_debut, date_fin, nomActivite, montant, nomIndividu, prenomIndividu in listeDonnees: if prenomIndividu == None: prenomIndividu = "" nomIndividu = u"%s %s" % (nomIndividu, prenomIndividu) if type(montant) != float: montant = 0.0 montantStr = u"%.2f %s" % (montant, SYMBOLE) self.dictDonnees[index] = { "ID": IDcontrat, "nomIndividu ": nomIndividu } label = _(u"%s - %s - %s - du %s au %s") % ( nomIndividu, nomActivite, montantStr, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)) listeItems.append(label) index += 1 return listeItems
def RechercheFormat(valeur): """ Recherche le type de la donnée """ if type(valeur) == decimal.Decimal: valeur = float(valeur) return (valeur, styleEuros) if type(valeur) == float: return (valeur, None) if type(valeur) == int: return (valeur, None) if type(valeur) == datetime.date: valeur = UTILS_Dates.DateDDEnFr(valeur) return (valeur, styleDate) if type(valeur) == datetime.timedelta: return (valeur, styleHeure) try: if len(valeur) > 3: if ":" in valeur: separateur = ":" elif "h" in valeur: separateur = "h" else: separateur = None if separateur != None: donnees = valeur.split(separateur) if len(donnees) == 2: heures, minutes = donnees if len(donnees) == 3: heures, minutes, secondes = donnees valeur = datetime.timedelta(minutes=int(heures) * 60 + int(minutes)) # valeur = datetime.time(hour=int(valeur.split(separateur)[0]), minute=int(valeur.split(separateur)[1])) return (valeur, styleHeure) except: pass if type(valeur) in (str, six.text_type): if len(valeur) == 10: if valeur[2] == "/" and valeur[5] == "/": return (valeur, styleDate) if valeur[4] == "-" and valeur[7] == "-": return (UTILS_Dates.DateEngFr(valeur), styleDate) return six.text_type(valeur), None
def PrestationsFantomes(self): labelProbleme = _(u"Prestations fantômes") labelCorrection = _(u"Supprimer la prestation fantôme") # Récupération des prestations from dateutil import relativedelta date_limite = datetime.date.today() + relativedelta.relativedelta( months=-2) req = """SELECT IDprestation, label, date, IDfamille, prestations.IDindividu, individus.nom, individus.prenom FROM prestations LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu WHERE categorie='consommation' AND forfait IS NULL AND IDfacture IS NULL AND date>='%s' ORDER BY date, prestations.IDfamille, prestations.IDindividu ;""" % date_limite self.DB.ExecuterReq(req) listePrestations = self.DB.ResultatReq() # Récupération des consommations req = """SELECT IDconso, IDprestation FROM consommations;""" self.DB.ExecuterReq(req) listeConsommations = self.DB.ResultatReq() # Analyse dictPrestations = {} for IDconso, IDprestation in listeConsommations: if (IDprestation in dictPrestations) == False: dictPrestations[IDprestation] = [] dictPrestations[IDprestation].append(IDconso) listeTemp = [] for IDprestation, label, date, IDfamille, IDindividu, nom, prenom in listePrestations: date = UTILS_Dates.DateEngEnDateDD(date) if (IDprestation in dictPrestations) == False: if nom != None and prenom != None: nomIndividu = u"%s %s" % (nom, prenom) else: nomIndividu = u"" label = u"Prestation ID%d du %s pour %s : %s" % ( IDprestation, UTILS_Dates.DateDDEnFr(date), nomIndividu, label) listeTemp.append( PrestationsFantomes(label=label, IDprestation=IDprestation)) self.listeResultats.append((labelProbleme, labelCorrection, listeTemp))
def MAJ_apercu(self): index = self.ctrl_adresse.GetSelection() if index == -1: return xml = self.texte_xml if xml == None: return # Remplacement des champs standards for motcle, valeur in CTRL_Editeur_email.GetChampsStandards().items(): xml = xml.replace(motcle, valeur) # Remplacement des champs spécifiques dictDonnee = self.donnees[index] for motcle, valeur in dictDonnee["champs"].items(): if valeur == None or valeur == "//None": valeur = "" if type(valeur) == int: valeur = str(valeur) if type(valeur) == datetime.date: valeur = UTILS_Dates.DateDDEnFr(valeur) xml = xml.replace(motcle, valeur) # MAJ éditeur self.ctrl_editeur.SetXML(xml)
def Envoyer(self, listeDestinataires=[], adresseTest=None): # Expéditeur dictExp = self.ctrl_exp.GetDonnees() if dictExp == None: dlg = wx.MessageDialog( self, _(u"Vous n'avez sélectionné aucune adresse d'expéditeur !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() if self.IsShown() == False: self.ShowModal() return # Accusé de réception accuseReception = self.check_accuseReception.GetValue() # Objet sujet = self.ctrl_objet.GetValue() if len(sujet) == 0: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir un objet pour ce message !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() if self.IsShown() == False: self.ShowModal() self.ctrl_objet.SetFocus() return # Destinataires if len(listeDestinataires) == 0: dlg = wx.MessageDialog( self, _(u"Vous devez sélectionner au moins un destinataire !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() if self.IsShown() == False: self.ShowModal() return nbreAnomalies = 0 for dest in listeDestinataires: if dest.adresse == None: nbreAnomalies += 1 if nbreAnomalies > 0: dlg = wx.MessageDialog( self, _(u"%d adresse(s) Email ne sont pas renseignées !") % nbreAnomalies, _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return # Texte if len(self.ctrl_editeur.GetValue()) == 0: dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement saisir un texte !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() if self.IsShown() == False: self.ShowModal() self.ctrl_editeur.SetFocus() return texteHTML, listeImages, handler = self.ctrl_editeur.GetHTML( imagesIncluses=True) # Vérifie la fusion des mots-clés if self.VerifieFusion(texteHTML, listeDestinataires) == False: if self.IsShown() == False: self.ShowModal() return # Pièces jointes listePiecesCommunes = self.ctrl_pieces.GetDonnees() # Demande de confirmation if adresseTest == None and self.afficher_confirmation_envoi == True: dlg = wx.MessageDialog( self, _(u"Confirmez-vous l'envoi de ce message pour %d destinataires ?\n\nAttention, l'envoi peut prendre quelques minutes..." ) % len(listeDestinataires), _(u"Confirmation"), wx.YES_NO | wx.YES_DEFAULT | wx.CANCEL | wx.ICON_QUESTION) if dlg.ShowModal() != wx.ID_YES: dlg.Destroy() if self.IsShown() == False: self.ShowModal() return dlg.Destroy() # Préparation des messages liste_messages = [] for track in listeDestinataires: adresse = track.adresse if adresseTest != None: adresse = adresseTest listePiecesPersonnelles = track.pieces dictChamps = track.champs # Pièces Personnelles + communes listePieces = listePiecesPersonnelles listePieces.extend(listePiecesCommunes) # Traitement des champs pour la fusion texte = copy.deepcopy(texteHTML) for motcle, valeur in CTRL_Editeur_email.GetChampsStandards( ).items(): texte = texte.replace(motcle, valeur) for motcle, valeur in dictChamps.items(): if valeur == None: valeur = u"" if type(valeur) == int: valeur = str(valeur) if type(valeur) == bool: valeur = str(valeur) if type(valeur) == datetime.date: valeur = UTILS_Dates.DateDDEnFr(valeur) texte = texte.replace(motcle, valeur) # Mémorisation du message message = UTILS_Envoi_email.Message( destinataires=[ adresse, ], sujet=sujet, texte_html=texte, fichiers=listePieces, images=listeImages, champs=dictChamps, ) liste_messages.append(message) # Connexion messagerie dlg_progress = wx.ProgressDialog( _(u"Envoi des mails"), _(u"Connexion au serveur de messagerie..."), maximum=len(liste_messages) + 1, parent=None) dlg_progress.SetSize((450, 140)) dlg_progress.CenterOnScreen() try: messagerie = UTILS_Envoi_email.Messagerie( backend=dictExp["moteur"], hote=dictExp["smtp"], port=dictExp["port"], utilisateur=dictExp["utilisateur"], motdepasse=dictExp["motdepasse"], email_exp=dictExp["adresse"], nom_exp=dictExp["nom_adresse"], timeout=20, use_tls=dictExp["startTLS"], parametres=dictExp["parametres"]) messagerie.Connecter() except Exception as err: dlg_progress.Destroy() err = str(err) intro = _( u"La connexion au serveur de messagerie est impossible :") conclusion = _( u"Vérifiez votre connexion internet ou les paramètres de votre adresse d'expédition." ) dlgErreur = DLG_Messagebox.Dialog(self, titre=_(u"Erreur"), introduction=intro, detail=err, conclusion=conclusion, icone=wx.ICON_ERROR, boutons=[ _(u"Ok"), ]) dlgErreur.ShowModal() dlgErreur.Destroy() return False # Envoi des messages self.listeSucces = messagerie.Envoyer_lot( messages=liste_messages, dlg_progress=dlg_progress, afficher_confirmation_envoi=self.afficher_confirmation_envoi) # Fermeture messagerie try: messagerie.Fermer() except: pass # Fermeture dlg_progress si besoin if dlg_progress != None: try: dlg_progress.Destroy() except: pass # Suppression des images temporaires incluses dans le message handler.DeleteTemporaryImages() # Mémorisation dans l'historique if self.listeSucces != False: for message in self.listeSucces: self.MemorisationHistorique(message.GetLabelDestinataires(), message.sujet)
def GetDonneesImpression(self, listeDemandes=[]): """ Impression des locations """ dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None) # Récupère les données de la facture if len(listeDemandes) == 0: conditions = "()" elif len(listeDemandes) == 1: conditions = "(%d)" % listeDemandes[0] else: conditions = str(tuple(listeDemandes)) DB = GestionDB.DB() # Importation des catégories de produits req = """SELECT IDcategorie, nom FROM produits_categories;""" DB.ExecuterReq(req) listeCategories = DB.ResultatReq() self.dictCategories = {} for IDcategorie, nom in listeCategories : self.dictCategories[IDcategorie] = nom # Importation des produits req = """SELECT IDproduit, nom FROM produits;""" DB.ExecuterReq(req) listeProduits = DB.ResultatReq() self.dictProduits = {} for IDproduit, nom in listeProduits : self.dictProduits[IDproduit] = nom # # Importation des critères # req = """SELECT IDfiltre, IDquestion, categorie, choix, criteres FROM questionnaire_filtres WHERE categorie='location_demande' AND IDdonnee IN %s;""" % conditions # DB.ExecuterReq(req) # listeFiltres = DB.ResultatReq() # # req = """SELECT IDquestion, label, controle # FROM questionnaire_questions;""" # DB.ExecuterReq(req) # listeQuestions = DB.ResultatReq() # DICT_QUESTIONS = {} # for IDquestion, label, controle in listeQuestions: # DICT_QUESTIONS[IDquestion] = {"label": label, "controle": controle} # # # Importation des choix # req = """SELECT IDchoix, IDquestion, label # FROM questionnaire_choix # ORDER BY ordre;""" # DB.ExecuterReq(req) # listeChoix = DB.ResultatReq() # DICT_CHOIX = {} # for IDchoix, IDquestion, label in listeChoix: # DICT_CHOIX[IDchoix] = {"label": label, "IDquestion": IDquestion, } # Recherche les locations req = """SELECT IDdemande, date, IDfamille, observations, categories, produits, statut, motif_refus, IDlocation FROM locations_demandes WHERE IDdemande IN %s;""" % conditions DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0: del dlgAttente return False dictDonnees = {} dictChampsFusion = {} for item in listeDonnees: IDdemande = item[0] date = item[1] IDfamille = item[2] observations = item[3] categories = item[4] produits = item[5] statut = item[6] motif_refus = item[7] IDlocation = item[8] # Date de la demande if isinstance(date, str) or isinstance(date, six.text_type): date = datetime.datetime.strptime(date, "%Y-%m-%d %H:%M:%S") date_texte = datetime.datetime.strftime(date, "%d/%m/%Y") heure_texte = datetime.datetime.strftime(date, "%Hh%M") # Catégories categories = UTILS_Texte.ConvertStrToListe(categories, siVide=[]) liste_labels = [] for IDcategorie in categories: if IDcategorie in self.dictCategories: liste_labels.append(self.dictCategories[IDcategorie]) texte_categories = ", ".join(liste_labels) # Produits produits = UTILS_Texte.ConvertStrToListe(produits, siVide=[]) liste_labels = [] for IDproduit in produits: if IDproduit in self.dictProduits: liste_labels.append(self.dictProduits[IDproduit]) texte_produits = ", ".join(liste_labels) # if IDindividu != None and self.dictIndividus.has_key(IDindividu): # beneficiaires = self.dictIndividus[IDindividu]["nom_complet"] # rue = self.dictIndividus[IDindividu]["rue"] # cp = self.dictIndividus[IDindividu]["cp"] # ville = self.dictIndividus[IDindividu]["ville"] # Famille if IDfamille != None: nomTitulaires = self.dictTitulaires[IDfamille]["titulairesAvecCivilite"] famille_rue = self.dictTitulaires[IDfamille]["adresse"]["rue"] famille_cp = self.dictTitulaires[IDfamille]["adresse"]["cp"] famille_ville = self.dictTitulaires[IDfamille]["adresse"]["ville"] else: nomTitulaires = "Famille inconnue" famille_rue = "" famille_cp = "" famille_ville = "" # Mémorisation des données dictDonnee = { "select": True, "{IDDEMANDE}": str(IDdemande), "{DATE}": date_texte, "{HEURE}": heure_texte, "{CATEGORIES}": texte_categories, "{PRODUITS}": texte_produits, "{NOTES}": observations, "{ORGANISATEUR_NOM}": self.dictOrganisme["nom"], "{ORGANISATEUR_RUE}": self.dictOrganisme["rue"], "{ORGANISATEUR_CP}": self.dictOrganisme["cp"], "{ORGANISATEUR_VILLE}": self.dictOrganisme["ville"], "{ORGANISATEUR_TEL}": self.dictOrganisme["tel"], "{ORGANISATEUR_FAX}": self.dictOrganisme["fax"], "{ORGANISATEUR_MAIL}": self.dictOrganisme["mail"], "{ORGANISATEUR_SITE}": self.dictOrganisme["site"], "{ORGANISATEUR_AGREMENT}": self.dictOrganisme["num_agrement"], "{ORGANISATEUR_SIRET}": self.dictOrganisme["num_siret"], "{ORGANISATEUR_APE}": self.dictOrganisme["code_ape"], "{DATE_EDITION_COURT}": UTILS_Dates.DateDDEnFr(datetime.date.today()), "{DATE_EDITION_LONG}": UTILS_Dates.DateComplete(datetime.date.today()), } # Ajoute les informations de base individus et familles # if IDindividu != None: # dictDonnee.update(self.infosIndividus.GetDictValeurs(mode="individu", ID=IDindividu, formatChamp=True)) if IDfamille != None: dictDonnee.update(self.infosIndividus.GetDictValeurs(mode="famille", ID=IDfamille, formatChamp=True)) # Ajoute les réponses des questionnaires for dictReponse in self.Questionnaires_familles.GetDonnees(IDfamille): dictDonnee[dictReponse["champ"]] = dictReponse["reponse"] if dictReponse["controle"] == "codebarres": dictDonnee["{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"] for dictReponse in self.Questionnaires_demandes.GetDonnees(IDdemande): dictDonnee[dictReponse["champ"]] = dictReponse["reponse"] if dictReponse["controle"] == "codebarres": dictDonnee["{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"] dictDonnees[IDdemande] = dictDonnee # Champs de fusion pour Email dictChampsFusion[IDdemande] = {} for key, valeur in dictDonnee.items(): if key[0] == "{": dictChampsFusion[IDdemande][key] = valeur del dlgAttente return dictDonnees, dictChampsFusion
def FormateDate(date): return UTILS_Dates.DateDDEnFr(date)
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 CreationPDF(self, nomDoc=FonctionsPerso.GenerationNomDoc( "COMMANDE_REPAS", "pdf"), afficherDoc=True): dictChampsFusion = {} # Récupération des données nom_commande = self.ctrl_nom.GetValue() date_debut = self.ctrl_date_debut.GetDate() date_fin = self.ctrl_date_fin.GetDate() observations = self.ctrl_observations.GetValue() dictDonnees = self.ctrl_repas.GetDonnees() # Récupération des options d'impression global DICT_INFOS_IMPRESSION DICT_INFOS_IMPRESSION = { "date_debut": date_debut, "date_fin": date_fin } dlg = DLG_Options_impression_pdf.Dialog(self, categorie="commande_repas", ctrl=CTRL_Options_impression) if dlg.ShowModal() == wx.ID_OK: dictOptions = dlg.GetOptions() dlg.Destroy() else: dlg.Destroy() return False # Création du PDF from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle from reportlab.platypus.flowables import ParagraphAndImage, Image from reportlab.lib.pagesizes import A4 from reportlab.lib import colors from reportlab.lib.styles import ParagraphStyle if dictOptions["orientation"] == "portrait": largeur_page, hauteur_page = A4 else: hauteur_page, largeur_page = A4 # Initialisation du PDF if sys.platform.startswith("win"): nomDoc = nomDoc.replace("/", "\\") doc = SimpleDocTemplate(nomDoc, pagesize=(largeur_page, hauteur_page), topMargin=30, bottomMargin=30) story = [] largeurContenu = largeur_page - 75 # Création du titre du document def Header(): dataTableau = [] largeursColonnes = ((largeurContenu - 100, 100)) dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today())) dataTableau.append( (_(u"Commande des repas"), _(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), 'LEFT'), ('FONT', (0, 0), (0, 0), "Helvetica-Bold", 16), ('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, 10)) # Insère un header Header() # Insère le nom et la période de la commande style_titre_commande = ParagraphStyle( name="1", alignment=1, fontName="Helvetica-Bold", fontSize=dictOptions["taille_texte_titre"], leading=8, spaceAfter=14) story.append( Paragraph( _(u"<para>%s - Du %s au %s</para>") % (nom_commande, UTILS_Dates.DateDDEnFr(date_debut), UTILS_Dates.DateDDEnFr(date_fin)), style_titre_commande)) # Styles style_entete = ParagraphStyle(name="1", alignment=1, fontName="Helvetica-Bold", fontSize=dictOptions["taille_texte"], leading=8, spaceAfter=2) style_numerique = ParagraphStyle(name="2", alignment=2, fontName="Helvetica", fontSize=dictOptions["taille_texte"], leading=8, spaceAfter=2) style_total = ParagraphStyle(name="3", alignment=2, fontName="Helvetica-Bold", fontSize=dictOptions["taille_texte"], leading=8, spaceAfter=2) style_texte = ParagraphStyle(name="4", alignment=0, fontName="Helvetica", fontSize=dictOptions["taille_texte"], leading=8, spaceAfter=2) # Calcule des largeurs de colonne largeur_colonne_date = dictOptions["largeur_colonne_date"] largeur_colonnes = largeurContenu - largeur_colonne_date dictLargeurs = {} if dictOptions["largeur_colonnes_auto"] == True: total_largeurs_colonnes = 0 for dictColonne in dictDonnees["liste_colonnes"]: total_largeurs_colonnes += dictColonne["largeur"] for dictColonne in dictDonnees["liste_colonnes"]: dictLargeurs[dictColonne["IDcolonne"]] = 1.0 * dictColonne[ "largeur"] / total_largeurs_colonnes * largeur_colonnes # Dessin du tableau de données dataTableau = [] largeursColonnes = [ largeur_colonne_date, ] # Dessin des noms de colonnes ligne = [ Paragraph(_(u"Date"), style_entete), ] for dictColonne in dictDonnees["liste_colonnes"]: valeur = dictColonne["nom_colonne"] ligne.append(Paragraph(valeur, style_entete)) if dictColonne["IDcolonne"] in dictLargeurs: largeur = dictLargeurs[dictColonne["IDcolonne"]] else: largeur = dictColonne["largeur"] / 1.5 largeursColonnes.append(largeur) dataTableau.append(ligne) # Dessin des lignes dict_totaux_colonnes = {} for numLigne in range(0, len(dictDonnees["liste_dates"])): ligne = [] # Ajout de la date à la ligne date = dictDonnees["liste_dates"][numLigne] afficher_ligne = True if dictOptions["masquer_dates_anciennes"] == True and type( date) == datetime.date and date < datetime.date.today(): afficher_ligne = False if afficher_ligne == True: if type(date) == datetime.date: valeur = UTILS_Dates.DateComplete(date) else: valeur = date ligne.append(Paragraph(valeur, style_entete)) # Ajout des cases à la ligne numColonne = 0 for dictColonne in dictDonnees["liste_colonnes"]: # Recherche la valeur valeur = "" if (numLigne, numColonne) in dictDonnees["cases"]: case = dictDonnees["cases"][(numLigne, numColonne)] valeur = case.GetValeur() # Recherche le style à appliquer if "numerique" in case.categorieColonne: style = style_numerique # Définit le style de la case total if "total" in case.categorieColonne or numLigne == len( dictDonnees["liste_dates"]) - 1: style = style_total if numLigne == len(dictDonnees["liste_dates"]) - 1: # Récupère la valeur total de la colonne valeur = dict_totaux_colonnes.get( numColonne, 0) else: # Mémorise total de la colonne numérique if (numColonne in dict_totaux_colonnes) == False: dict_totaux_colonnes[numColonne] = 0 dict_totaux_colonnes[numColonne] += valeur else: style = style_texte valeur = valeur.replace("\n", "<br/>") ligne.append(Paragraph(six.text_type(valeur), style)) numColonne += 1 # Ajout de la ligne au tableau dataTableau.append(ligne)
fontName="Helvetica", fontSize=dictOptions["taille_texte"], leading=8, spaceBefore=10) story.append(Paragraph(observations, style=style_observations)) # Enregistrement du PDF doc.build(story) # Affichage du PDF if afficherDoc == True: FonctionsPerso.LanceFichierExterne(nomDoc) # Mémorisation des champs de fusion dictChampsFusion["{NOM_COMMANDE}"] = nom_commande dictChampsFusion["{DATE_DEBUT}"] = UTILS_Dates.DateDDEnFr(date_debut) dictChampsFusion["{DATE_FIN}"] = UTILS_Dates.DateDDEnFr(date_fin) return dictChampsFusion class CTRL_Options_impression(DLG_Options_impression_pdf.CTRL_Parametres): def __init__(self, parent): DLG_Options_impression_pdf.CTRL_Parametres.__init__(self, parent) def Remplissage(self): # Affichage self.Append(wxpg.PropertyCategory(_(u"Affichage"))) # Période à afficher # date_debut = DICT_INFOS_IMPRESSION["date_debut"]
def FormateDate(dateDD): if dateDD == None: return "" else: return UTILS_Dates.DateDDEnFr(dateDD)
def Supprimer(self, event): if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0: dlg = wx.MessageDialog( self, _(u"Vous n'avez sélectionné aucune consommation à 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 consommations cochées ?" ), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION) 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 consommation sélectionnée ?" ), _(u"Suppression"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_QUESTION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return # Suppression listeSuppressions = [] for track in listeSelections: if track.etat in ("present", "absenti", "absentj"): dlg = wx.MessageDialog( self, _(u"Vous ne pouvez pas supprimer la consommation '%s' du %s car elle est déjà pointée !" ) % (track.nomUnite, UTILS_Dates.DateDDEnFr(track.date)), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return listeSuppressions.append(track.index) if track.IDconso != None: self.GetGrandParent().GetGrandParent().GetParent( ).listeSuppressionConso.append(track.IDconso) nouvelleListe = [] index = 0 for dictConso in self.listeDonnees: if index not in listeSuppressions: nouvelleListe.append(dictConso) index += 1 self.listeDonnees = nouvelleListe self.MAJ()
def InitGrid(self): self.ResetGrid() # Récupération des données dictResultats, listeUnites, listeGroupes = self.Importation() if self.affichage_donnees == "quantite": defaut = 0 else: defaut = datetime.timedelta(hours=0, minutes=0) listeGroupesUtilises = [] listeUnitesUtilises = [] listeRegroupement = [] dictTotaux = {"lignes": {}, "colonnes": {}} for IDgroupe, dictGroupe in dictResultats.iteritems(): if IDgroupe not in listeGroupesUtilises: listeGroupesUtilises.append(IDgroupe) for IDunite, dictUnite in dictGroupe.iteritems(): if IDunite not in listeUnitesUtilises: listeUnitesUtilises.append(IDunite) for regroupement, valeur in dictUnite.iteritems(): if regroupement not in listeRegroupement: listeRegroupement.append(regroupement) # Calcul des totaux if dictTotaux["lignes"].has_key( (IDgroupe, IDunite)) == False: dictTotaux["lignes"][(IDgroupe, IDunite)] = defaut dictTotaux["lignes"][(IDgroupe, IDunite)] += valeur if dictTotaux["colonnes"].has_key(regroupement) == False: dictTotaux["colonnes"][regroupement] = defaut dictTotaux["colonnes"][regroupement] += valeur # Création des colonnes largeur_colonne = 80 dictColonnes = {} if self.detail_groupes == True: self.AppendCols(len(listeGroupes) * len(listeUnites)) index = 0 for IDunite, nomUnite, abregeUnite in listeUnites: for IDgroupe, nomGroupe, abregeGroupe in listeGroupes: self.SetColSize(index, largeur_colonne) if abregeGroupe == "" or abregeGroupe == None: abregeGroupe = nomGroupe if abregeUnite == "" or abregeUnite == None: abregeUnite = nomUnite self.SetColLabelValue( index, u"%s\n%s" % (abregeGroupe, abregeUnite)) dictColonnes[(IDgroupe, IDunite)] = index index += 1 else: self.AppendCols(len(listeUnites)) index = 0 for IDunite, nomUnite, abregeUnite in listeUnites: if abregeUnite == "" or abregeUnite == None: abregeUnite = nomUnite self.SetColSize(index, largeur_colonne) self.SetColLabelValue(index, u"%s" % abregeUnite) dictColonnes[(None, IDunite)] = index index += 1 # Colonne Total self.AppendCols(1) self.SetColSize(index, largeur_colonne) self.SetColLabelValue(index, _(u"TOTAL")) dictColonnes["total"] = index # Création des lignes listeRegroupement.sort() self.AppendRows(len(listeRegroupement)) index = 0 dictLignes = {} for regroupement in listeRegroupement: if self.affichage_regroupement == "jour": label = DateComplete(regroupement) elif self.affichage_regroupement == "mois": label = FormateMois(regroupement) elif self.affichage_regroupement == "annee": label = str(regroupement) elif self.affichage_regroupement == "evenement" and self.dictEvenements.has_key( regroupement): label = self.dictEvenements[regroupement]["nom"] elif self.affichage_regroupement == "evenement_date" and self.dictEvenements.has_key( regroupement): label = u"%s (%s)" % ( self.dictEvenements[regroupement]["nom"], UTILS_Dates.DateDDEnFr( self.dictEvenements[regroupement]["date"])) elif self.affichage_regroupement == "qf" and type( regroupement) == tuple: label = u"%d-%d" % regroupement else: label = unicode(regroupement) self.SetRowLabelValue(index, label) self.SetRowSize(index, 30) dictLignes[regroupement] = index index += 1 # Ligne Total self.AppendRows(1) self.SetRowLabelValue(index, _(u"TOTAL")) self.SetRowSize(index, 30) dictLignes["total"] = index # Remplissage des valeurs for IDgroupe, dictGroupe in dictResultats.iteritems(): for IDunite, dictUnite in dictGroupe.iteritems(): for regroupement, valeur in dictUnite.iteritems(): label = FormateValeur(valeur, self.affichage_donnees) numLigne = dictLignes[regroupement] numColonne = dictColonnes[(IDgroupe, IDunite)] self.SetCellValue(numLigne, numColonne, label) self.SetCellAlignment(numLigne, numColonne, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self.SetReadOnly(numLigne, numColonne, True) # Remplissage des totaux for (IDgroupe, IDunite), valeur in dictTotaux["lignes"].iteritems(): label = FormateValeur(valeur, self.affichage_donnees) numLigne = dictLignes["total"] numColonne = dictColonnes[(IDgroupe, IDunite)] self.SetCellValue(numLigne, numColonne, label) self.SetCellAlignment(numLigne, numColonne, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self.SetReadOnly(numLigne, numColonne, True) total_general = defaut for regroupement, valeur in dictTotaux["colonnes"].iteritems(): total_general += valeur label = FormateValeur(valeur, self.affichage_donnees) numLigne = dictLignes[regroupement] numColonne = dictColonnes["total"] self.SetCellValue(numLigne, numColonne, label) self.SetCellAlignment(numLigne, numColonne, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self.SetReadOnly(numLigne, numColonne, True) # Total général label = FormateValeur(total_general, self.affichage_donnees) numLigne = dictLignes["total"] numColonne = dictColonnes["total"] self.SetCellValue(numLigne, numColonne, label) self.SetCellAlignment(numLigne, numColonne, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self.SetReadOnly(numLigne, numColonne, True) # Coloration des TOTAUX couleurFond = (240, 240, 240) for x in range(0, numLigne + 1): self.SetCellBackgroundColour(x, numColonne, couleurFond) for y in range(0, numColonne): self.SetCellBackgroundColour(numLigne, y, couleurFond)
def InitParametres(self): """ Récupération des paramètres d'impression """ # DLG des paramètres d'impression dictOptions = { "titre": self.titre, "introduction": self.intro, "conclusion": self.total, "orientation": self.orientation, } dlg = DLG_Options_impression_listes.Dialog(None, dictOptions=dictOptions) if dlg.ShowModal() == wx.ID_OK: dictOptions = dlg.GetOptions() dlg.Destroy() else: dlg.Destroy() return False # Remplacement des mots-clés listeChamps = [ "pied_page_texte_gauche", "pied_page_texte_milieu", "pied_page_texte_droite" ] for key, valeur in list(dictOptions.items()): if key in listeChamps: valeur = valeur.replace( "{DATE_JOUR}", UTILS_Dates.DateDDEnFr(datetime.date.today())) valeur = valeur.replace("{TITRE_DOCUMENT}", self.titre) valeur = valeur.replace("{NUM_PAGE}", "%(currentPage)d") valeur = valeur.replace("{NBRE_PAGES}", "%(totalPages)d") dictOptions[key] = valeur # Préparation du printout self.printer = ListCtrlPrinter.ListCtrlPrinter(self.listview, dictOptions["titre"]) self.printer.printout.margins = (wx.Point( int(dictOptions["marge_gauche"]), int(dictOptions["marge_haut"])), wx.Point( int(dictOptions["marge_droite"]), int(dictOptions["marge_bas"]))) self.printer.printout.printData.SetOrientation( dictOptions["orientation"]) self.printer.printout.printData.SetQuality( int(dictOptions["qualite_impression"])) self.printer.PageFooter = (dictOptions["pied_page_texte_gauche"], dictOptions["pied_page_texte_milieu"], dictOptions["pied_page_texte_droite"]) ListCtrlPrinter.LISTINTRO = dictOptions["introduction"] ListCtrlPrinter.LISTFOOTER = dictOptions["conclusion"] # Préparation du format fmt = ReportFormat() # Entête de page ## fmt.PageHeader.Font = wx.FFont(10, wx.FONTFAMILY_DECORATIVE, wx.FONTFLAG_BOLD, face=headerFontName) ## fmt.PageHeader.TextColor = wx.WHITE ## fmt.PageHeader.Background(wx.GREEN, wx.RED, space=(16, 4, 0, 4)) ## fmt.PageHeader.Padding = (0, 0, 0, 12) # Titre de liste fmt.ListHeader.Font = wx.Font(int(dictOptions["titre_taille_texte"]), wx.SWISS, wx.NORMAL, int(dictOptions["titre_style"]), faceName="Arial") fmt.ListHeader.TextColor = dictOptions["titre_couleur"] fmt.ListHeader.Padding = (0, 12, 0, 10) fmt.ListHeader.TextAlignment = dictOptions["titre_alignement"] fmt.ListHeader.Frame(wx.Pen(wx.BLACK, 0.25, wx.SOLID), space=10) # Intro fmt.ListIntro.Font = wx.Font(int(dictOptions["intro_taille_texte"]), wx.SWISS, wx.NORMAL, int(dictOptions["intro_style"]), faceName="Arial") fmt.ListIntro.TextColor = dictOptions["intro_couleur"] fmt.ListIntro.Padding = (12, 2, 12, 2) fmt.ListIntro.TextAlignment = dictOptions["intro_alignement"] fmt.ListIntro.CanWrap = True # Titre de colonne fmt.ColumnHeader.Font = wx.Font( int(dictOptions["titre_colonne_taille_texte"]), wx.SWISS, wx.NORMAL, int(dictOptions["titre_colonne_style"]), faceName="Arial") fmt.ColumnHeader.TextColor = dictOptions["titre_colonne_couleur"] fmt.ColumnHeader.Padding = (0, 15, 0, 0) fmt.ColumnHeader.Background(dictOptions["titre_colonne_couleur_fond"]) fmt.ColumnHeader.CellPadding = 5 fmt.ColumnHeader.TextAlignment = dictOptions[ "titre_colonne_alignement"] fmt.ColumnHeader.GridPen = wx.Pen( dictOptions["grille_trait_couleur"], dictOptions["grille_trait_epaisseur"], wx.SOLID) fmt.ColumnHeader.SetAlwaysCenter(True) # Titre d'un groupe fmt.GroupTitle.Font = wx.FFont(10, wx.FONTFAMILY_SWISS, wx.FONTFLAG_BOLD, faceName="Arial") fmt.GroupTitle.Padding = (2, 10, 2, 2) fmt.GroupTitle.CellPadding = 12 fmt.GroupTitle.GridPen = wx.Pen(dictOptions["grille_trait_couleur"], dictOptions["grille_trait_epaisseur"], wx.SOLID) ## fmt.GroupTitle.TextColor = wx.BLUE ## fmt.GroupTitle.Padding = (0, 12, 0, 12) ## fmt.GroupTitle.Line(wx.BOTTOM, wx.GREEN, 4, toColor=wx.WHITE, space=0) # Ligne fmt.Row.Font = wx.Font(int(dictOptions["ligne_taille_texte"]), wx.SWISS, wx.NORMAL, int(dictOptions["ligne_style"]), faceName="Arial") fmt.Row.TextColor = dictOptions["ligne_couleur"] fmt.Row.CellPadding = 5 fmt.Row.GridPen = wx.Pen(dictOptions["grille_trait_couleur"], dictOptions["grille_trait_epaisseur"], wx.SOLID) fmt.Row.CanWrap = dictOptions["ligne_multilignes"] # Pied de page fmt.PageFooter.Font = wx.Font(int( dictOptions["pied_page_taille_texte"]), wx.SWISS, wx.NORMAL, int(dictOptions["pied_page_style"]), faceName="Arial") fmt.PageFooter.TextColor = dictOptions["pied_page_couleur"] fmt.PageFooter.Line(wx.TOP, wx.BLACK, 1, space=3) fmt.PageFooter.Padding = (0, 16, 0, 0) # Pied de colonne fmt.ColumnFooter.Font = wx.Font(int( dictOptions["pied_colonne_taille_texte"]), wx.SWISS, wx.NORMAL, int(dictOptions["pied_colonne_style"]), faceName="Arial") fmt.ColumnFooter.TextColor = dictOptions["pied_colonne_couleur"] fmt.ColumnFooter.Padding = (0, 0, 0, 0) fmt.ColumnFooter.Background(dictOptions["pied_colonne_couleur_fond"]) fmt.ColumnFooter.CellPadding = 5 fmt.ColumnFooter.TextAlignment = dictOptions["pied_colonne_alignement"] fmt.ColumnFooter.GridPen = wx.Pen( dictOptions["grille_trait_couleur"], dictOptions["grille_trait_epaisseur"], wx.SOLID) ## fmt.ColumnFooter.SetAlwaysCenter(True) # Conclusion fmt.ListFooter.Font = wx.Font(int( dictOptions["conclusion_taille_texte"]), wx.SWISS, wx.NORMAL, int(dictOptions["conclusion_style"]), faceName="Arial") fmt.ListFooter.TextColor = dictOptions["conclusion_couleur"] fmt.ListFooter.Padding = (12, 12, 0, 0) fmt.ListFooter.CellPadding = 5 ## fmt.ListFooter.Line(wx.TOP, wx.BLACK, 1, space=3) fmt.ListFooter.TextAlignment = dictOptions["conclusion_alignement"] fmt.ListFooter.CanWrap = True # Divers paramètres fmt.IsShrinkToFit = True fmt.IncludeImages = dictOptions["inclure_images"] fmt.IsColumnHeadingsOnEachPage = dictOptions["entetes_toutes_pages"] fmt.UseListCtrlTextFormat = True self.printer.ReportFormat = fmt return True