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
