def SetDonnees(self, donnees=None, format="texte"):
""" Importe les données au format texte ou liste """
if format == "texte":
if donnees == None: donnees = ""
self.listeDonnees = UTILS_Divers.ConvertChaineEnListe(donnees)
else:
if donnees == None: donnees = []
self.listeDonnees = donnees
self.MAJ()
def __init__(self, parent, donnees):
self.IDcotisation = donnees[0]
self.IDfamille = donnees[1]
self.IDindividu = donnees[2]
self.IDtype_cotisation = donnees[3]
self.IDunite_cotisation = donnees[4]
self.date_saisie = DateEngEnDateDD(donnees[5])
self.IDutilisateur = donnees[6]
self.date_creation_carte = donnees[7]
self.numero = donnees[8]
self.IDdepot_cotisation = donnees[9]
self.date_debut = DateEngEnDateDD(donnees[10])
self.date_fin = DateEngEnDateDD(donnees[11])
self.IDprestation = donnees[12]
self.nomTypeCotisation = donnees[13]
self.typeTypeCotisation = donnees[14]
self.typeHasCarte = donnees[15]
self.nomUniteCotisation = donnees[16]
self.observations = donnees[17]
self.activites = donnees[18]
if self.activites == None:
self.activites = ""
self.individu_nom = donnees[19]
if self.individu_nom == None:
self.individu_nom = ""
self.individu_prenom = donnees[20]
if self.individu_prenom == None:
self.individu_prenom = ""
# Activites
texte = ""
if len(self.activites) > 0:
listeTemp = []
listeIDactivites = UTILS_Divers.ConvertChaineEnListe(
self.activites)
for IDactivite in listeIDactivites:
if IDactivite in parent.dictActivites:
nomActivite = parent.dictActivites[IDactivite]["nom"]
listeTemp.append(nomActivite)
if len(listeTemp) > 0:
texte = ", ".join(listeTemp)
self.activitesStr = texte
self.nomCotisation = u"%s - %s" % (self.nomTypeCotisation,
self.nomUniteCotisation)
if self.IDfamille in parent.titulaires:
self.nomTitulaires = parent.titulaires[
self.IDfamille]["titulairesSansCivilite"]
else:
self.nomTitulaires = u""
# Individu
self.individu = ""
if self.IDindividu != None:
self.individu = u"%s %s" % (self.individu_nom,
self.individu_prenom)
# Type
if self.typeTypeCotisation == "famille":
self.typeStr = _(u"Cotisation familiale")
else:
self.typeStr = _(u"Cotisation individuelle")
# Validité
dateDuJour = datetime.date.today()
if dateDuJour >= self.date_debut and dateDuJour <= self.date_fin:
self.valide = True
else:
self.valide = False
# Dépôt
if self.IDdepot_cotisation == None:
self.depotStr = _(u"Non déposée")
else:
self.depotStr = _(u"Dépôt n°%d") % self.IDdepot_cotisation
# Etat
if self.IDdepot_cotisation == None or self.IDdepot_cotisation == 0:
self.inclus = False
else:
self.inclus = True
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)
# Style du tableau
couleur_fond_entetes = UTILS_Divers.ConvertCouleurWXpourPDF(
dictOptions["couleur_fond_entetes"])
couleur_fond_total = UTILS_Divers.ConvertCouleurWXpourPDF(
dictOptions["couleur_fond_total"])
listeStyles = [
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
('FONT', (0, 0), (-1, -1), "Helvetica",
dictOptions["taille_texte"]),
('GRID', (0, 0), (-1, -1), 0.25, colors.black),
('ALIGN', (0, 1), (-2, -1), 'RIGHT'), # Centre les cases
('FONT', (0, 0), (0, -1), "Helvetica-Bold",
dictOptions["taille_texte"]),
('FONT', (0, 0), (-1, 0), "Helvetica-Bold",
dictOptions["taille_texte"]),
('BACKGROUND', (0, 0), (-1, 0), couleur_fond_entetes),
('BACKGROUND', (0, 0), (0, -1), couleur_fond_entetes),
def Importation(self):
# Conditions Activités
if self.liste_activites == None:
conditionActivites = "IDactivite > 0"
else:
if len(self.liste_activites) == 0:
conditionActivites = "IDactivite IN ()"
elif len(self.liste_activites) == 1:
conditionActivites = "IDactivite=%d" % self.liste_activites[0]
else:
conditionActivites = "IDactivite IN %s" % str(
tuple(self.liste_activites))
# Importation des inscriptions en attente
DB = GestionDB.DB()
req = """
SELECT IDinscription, date_inscription, categories_tarifs.nom,
inscriptions.IDindividu, individus.nom, individus.prenom,
inscriptions.IDactivite, activites.nom, inscriptions.IDgroupe, groupes.nom,
inscriptions.IDcompte_payeur, inscriptions.IDfamille
FROM inscriptions
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
LEFT JOIN activites ON activites.IDactivite = inscriptions.IDactivite
LEFT JOIN groupes ON groupes.IDgroupe = inscriptions.IDgroupe
LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = inscriptions.IDcategorie_tarif
WHERE inscriptions.statut='%s' AND inscriptions.%s
ORDER BY IDinscription
;""" % (self.mode, conditionActivites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictInscriptions = {}
dictGroupes = {}
for IDinscription, date_inscription, nomCategorie, IDindividu, nomIndividu, prenomIndividu, IDactivite, nomActivite, IDgroupe, nomGroupe, IDcompte_payeur, IDfamille in listeDonnees:
date_inscription = UTILS_Dates.DateEngEnDateDD(date_inscription)
if prenomIndividu == None: prenomIndividu = ""
nom_individu = u"%s %s" % (nomIndividu, prenomIndividu)
UTILS_Divers.DictionnaireImbrique(dictionnaire=dictInscriptions,
cles=[IDactivite, IDgroupe],
valeur=[])
dictTemp = {
"IDinscription": IDinscription,
"IDindividu": IDindividu,
"nom_individu": nom_individu,
"date_inscription": date_inscription,
"IDactivite": IDactivite,
"IDgroupe": IDgroupe,
"IDcompte_payeur": IDcompte_payeur,
"IDfamille": IDfamille,
"nomCategorie": nomCategorie,
}
dictInscriptions[IDactivite][IDgroupe].append(dictTemp)
# Mémorisation des groupes
if (IDgroupe in dictGroupes) == False:
dictGroupes[IDgroupe] = nomGroupe
# Recherche des places disponibles
# Recherche des inscriptions existantes
req = """SELECT IDgroupe, COUNT(IDinscription)
FROM inscriptions
WHERE inscriptions.%s AND inscriptions.statut='ok'
GROUP BY IDgroupe;""" % conditionActivites
DB.ExecuterReq(req)
listeInscriptions = DB.ResultatReq()
dictInscrits = {}
for IDgroupe, nbre_inscrits in listeInscriptions:
dictInscrits[IDgroupe] = nbre_inscrits
dictActivites = {}
req = """SELECT IDactivite, nom, abrege, date_debut, date_fin, nbre_inscrits_max
FROM activites
WHERE activites.%s;""" % conditionActivites
DB.ExecuterReq(req)
listeActivites = DB.ResultatReq()
for IDactivite, nom, abrege, date_debut, date_fin, nbre_inscrits_max in listeActivites:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
dictActivites[IDactivite] = {
"nom": nom,
"abrege": abrege,
"date_debut": date_debut,
"date_fin": date_fin,
"nbre_inscrits_max": nbre_inscrits_max,
"groupes": {}
}
# Recherche des groupes
req = """SELECT IDgroupe, IDactivite, nom, nbre_inscrits_max
FROM groupes
WHERE groupes.%s
ORDER BY ordre;""" % conditionActivites
DB.ExecuterReq(req)
listeGroupes = DB.ResultatReq()
for IDgroupe, IDactivite, nom, nbre_inscrits_max in listeGroupes:
# Recherche le nombre d'inscrits sur chaque groupe
if IDgroupe in dictInscrits:
nbre_inscrits = dictInscrits[IDgroupe]
else:
nbre_inscrits = 0
# Recherche du nombre de places disponibles sur le groupe
if nbre_inscrits_max not in (None, 0):
nbre_places_disponibles = nbre_inscrits_max - nbre_inscrits
else:
nbre_places_disponibles = None
# Mémorise le groupe
dictActivites[IDactivite]["groupes"][IDgroupe] = {
"nom": nom,
"nbre_places_disponibles": nbre_places_disponibles,
"nbre_inscrits": nbre_inscrits,
"nbre_inscrits_max": nbre_inscrits_max
}
for IDactivite in list(dictActivites.keys()):
# Recherche le nombre d'inscrits total de l'activité
dictActivites[IDactivite]["nbre_inscrits"] = 0
for IDgroupe in dictActivites[IDactivite]["groupes"]:
if IDgroupe in dictInscrits:
dictActivites[IDactivite]["nbre_inscrits"] += dictInscrits[
IDgroupe]
# Recherche du nombre de places disponibles sur l'activité
if dictActivites[IDactivite]["nbre_inscrits_max"] not in (None, 0):
dictActivites[IDactivite][
"nbre_places_disponibles"] = dictActivites[IDactivite][
"nbre_inscrits_max"] - dictActivites[IDactivite][
"nbre_inscrits"]
else:
dictActivites[IDactivite]["nbre_places_disponibles"] = None
DB.Close()
return dictInscriptions, dictActivites, dictGroupes
class CTRL(HTL.HyperTreeList):
def __init__(self, parent):
HTL.HyperTreeList.__init__(self, parent, -1)
self.parent = parent
self.dictImpression = {}
# Paramètres
self.mode_affichage = "mois" # "mois", "annee"
self.affichage_details = True
self.type = "depots"
self.date_debut = None
self.date_fin = None
self.listeActivites = []
self.listeDepots = []
## # Création de l'ImageList
## il = wx.ImageList(16, 16)
## self.img_ok = il.Add(wx.Bitmap(Chemins.GetStaticPath('Images/16x16/Ok.png'), wx.BITMAP_TYPE_PNG))
## self.img_pasok = il.Add(wx.Bitmap(Chemins.GetStaticPath('Images/16x16/Interdit.png'), wx.BITMAP_TYPE_PNG))
## self.AssignImageList(il)
# wx.TR_COLUMN_LINES | | wx.TR_HAS_BUTTONS
self.SetBackgroundColour(wx.WHITE)
if 'phoenix' in wx.PlatformInfo:
TR_COLUMN_LINES = HTL.TR_COLUMN_LINES
else :
TR_COLUMN_LINES = wx.TR_COLUMN_LINES
self.SetAGWWindowStyleFlag(wx.TR_HIDE_ROOT | wx.TR_ROW_LINES | TR_COLUMN_LINES | wx.TR_HAS_BUTTONS | wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.TR_FULL_ROW_HIGHLIGHT ) # HTL.TR_NO_HEADER
def SetModeAffichage(self, mode="depots"):
self.mode_affichage = mode
def SetAffichageDetails(self, etat=True):
self.affichage_details = etat
def SetTypeDepots(self, listeDepots=[]):
self.type = "depots"
self.listeDepots = listeDepots
def SetTypePrestations(self, date_debut=None, date_fin=None, listeActivites=[]):
self.type = "prestations"
self.date_debut = date_debut
self.date_fin = date_fin
self.listeActivites = listeActivites
def SetTypeVide(self):
self.type = "vide"
def Importation_depots(self):
""" Importation des données """
DB = GestionDB.DB()
if len(self.listeDepots) == 0 : conditionDepots = "()"
elif len(self.listeDepots) == 1 : conditionDepots = "(%d)" % self.listeDepots[0]
else : conditionDepots = str(tuple(self.listeDepots))
req = """SELECT depots.IDdepot, depots.date, nom, verrouillage, depots.IDcompte,
SUM(reglements.montant)
FROM depots
LEFT JOIN reglements ON reglements.IDdepot = depots.IDdepot
WHERE depots.IDdepot IN %s
GROUP BY depots.IDdepot
ORDER BY depots.date
;""" % conditionDepots
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDepots = {}
for IDdepot, date, nom, verrouillage, IDcompte, montantTotal in listeDonnees :
date = UTILS_Dates.DateEngEnDateDD(date)
if montantTotal == None : montantTotal = 0.0
dictDepots[IDdepot] = {"date":date, "nom":nom, "verrouillage":verrouillage, "IDcompte":IDcompte, "montantTotal":montantTotal}
DB.Close()
return dictDepots
def Importation_ventilation(self):
""" Importation des données """
DB = GestionDB.DB()
if self.type == "depots" :
# Type Dépôts
if len(self.listeDepots) == 0 : condition = "depots.IDdepot IN ()"
elif len(self.listeDepots) == 1 : condition = "depots.IDdepot IN (%d)" % self.listeDepots[0]
else : condition = "depots.IDdepot IN %s" % str(tuple(self.listeDepots))
else:
# Type Prestations
if len(self.listeActivites) == 0 : conditionActivites = ""
elif len(self.listeActivites) == 1 : conditionActivites = "AND prestations.IDactivite=%d" % self.listeActivites[0]
else : conditionActivites = "AND prestations.IDactivite IN %s" % str(tuple(self.listeActivites))
condition = "prestations.date>='%s' AND prestations.date<='%s' %s" % (self.date_debut, self.date_fin, conditionActivites)
# Récupèration de la ventilation des prestations des dépôts
req = """SELECT
ventilation.IDventilation, ventilation.IDreglement, ventilation.IDprestation, ventilation.montant,
reglements.date, reglements.date_saisie, depots.IDdepot, depots.date,
prestations.date, prestations.label, prestations.IDactivite, activites.nom, activites.abrege
FROM ventilation
LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN depots ON depots.IDdepot = reglements.IDdepot
LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
WHERE %s
ORDER BY prestations.date; """ % condition
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
listePeriodes = []
dictIDreglements = {}
for IDventilation, IDreglement, IDprestation, montantVentilation, dateReglement, dateSaisieReglement, IDdepot, dateDepotReglement, datePrestation, labelPrestation, IDactivite, nomActivite, abregeActivite in listeVentilation :
dateReglement = UTILS_Dates.DateEngEnDateDD(dateReglement)
dateSaisieReglement = UTILS_Dates.DateEngEnDateDD(dateSaisieReglement)
dateDepotReglement = UTILS_Dates.DateEngEnDateDD(dateDepotReglement)
datePrestation = UTILS_Dates.DateEngEnDateDD(datePrestation)
# Compte le nombre de règlements dans chaque dépôt
if dictIDreglements.has_key(IDdepot) == False :
dictIDreglements[IDdepot] = []
if IDreglement not in dictIDreglements[IDdepot] :
dictIDreglements[IDdepot].append(IDreglement)
# Rajoute le nom de l'activité dans le label de la prestation
if nomActivite != None :
labelPrestation = u"%s - %s" % (nomActivite, labelPrestation)
# Retient la période de ventilation
if datePrestation != None :
annee = datePrestation.year
mois = datePrestation.month
if self.mode_affichage == "mois" :
periode = (annee, mois)
else:
periode = annee
if periode not in listePeriodes :
listePeriodes.append(periode)
if dictVentilation.has_key(IDdepot) == False :
dictVentilation[IDdepot] = {}
if dictVentilation[IDdepot].has_key(periode) == False :
dictVentilation[IDdepot][periode] = {}
if dictVentilation[IDdepot][periode].has_key(labelPrestation) == False :
dictVentilation[IDdepot][periode][labelPrestation] = 0.0
dictVentilation[IDdepot][periode][labelPrestation] += montantVentilation
DB.Close()
listePeriodes.sort()
return dictVentilation, listePeriodes, dictIDreglements
def CreationColonnes(self, listePeriodes=[]):
""" Création des colonnes """
# Création de la première colonne
self.AddColumn(_(u"Dépôts"))
self.SetColumnWidth(0, 270)
self.SetColumnAlignment(0, wx.ALIGN_LEFT)
# Création des colonnes périodes
numColonne = 1
if self.mode_affichage == "mois" :
# Mode affichage MOIS
for annee, mois in listePeriodes :
self.AddColumn(PeriodeComplete(mois, annee))
self.SetColumnWidth(numColonne, 65)
self.SetColumnAlignment(numColonne, wx.ALIGN_CENTRE)
numColonne += 1
else:
# Mode affichage ANNEE
for annee in listePeriodes :
self.AddColumn(str(annee))
self.SetColumnWidth(numColonne, 65)
self.SetColumnAlignment(numColonne, wx.ALIGN_CENTRE)
numColonne += 1
# Création de la colonne Non Ventilé
if self.type == "depots" :
self.AddColumn(_(u"Non ventilé"))
self.SetColumnWidth(numColonne, 65)
self.SetColumnAlignment(numColonne, wx.ALIGN_CENTRE)
numColonne += 1
# Création de la colonne Total
self.AddColumn(_(u"Total"))
self.SetColumnWidth(numColonne, 75)
self.SetColumnAlignment(numColonne, wx.ALIGN_CENTRE)
def MAJ(self):
""" Remplissage du ctrl """
if self.type == "vide" :
self.RAZ()
return
# Importation des données
dictVentilation, listePeriodes, dictIDreglements = self.Importation_ventilation()
if self.type == "prestations" :
self.listeDepots = dictVentilation.keys()
if None in self.listeDepots : self.listeDepots.remove(None)
dictDepots = self.Importation_depots()
# Si on est en type PRESTATIONS, on crée un dépôt virtuel pour les règlements non déposées
if self.type == "prestations" and dictVentilation.has_key(None) :
dictDepots[None] = {"date":datetime.date(1977, 1, 1), "nom":_(u"----- %d règlements non déposés -----") % len(dictIDreglements[None]), "verrouillage":False, "IDcompte":None, "montantTotal":0.0}
self.dictImpression = { "entete" : [], "contenu" : [], "total" : [], "coloration" : [] }
# Mémorisation des colonnes
dictColonnes = {}
index = 1
self.dictImpression["entete"].append(_(u"Dépôts"))
for periode in listePeriodes :
dictColonnes[periode] = index
if self.mode_affichage == "mois" :
label = PeriodeComplete(periode[1], periode[0])
else:
label = str(periode)
self.dictImpression["entete"].append(label)
index += 1
if self.type == "depots" :
dictColonnes["sansVentilation"] = index
self.dictImpression["entete"].append(_(u"Non ventilé"))
index += 1
dictColonnes["total"] = index
self.dictImpression["entete"].append(_(u"Total"))
# Initialisation du CTRL
self.RAZ()
self.CreationColonnes(listePeriodes)
self.root = self.AddRoot(_(u"Racine"))
# Création des branches
# ------------------ Branches DEPOTS -----------------
# Tri des dépôts par date de dépôt
listeDepotsTemp = []
for IDdepot, dictDepot in dictDepots.iteritems() :
if dictDepot["date"] == None :
dateDepot = datetime.date(1977, 1, 1)
else:
dateDepot = dictDepot["date"]
listeDepotsTemp.append( (dateDepot, IDdepot, dictDepot) )
listeDepotsTemp.sort()
dictLigneTotal = {}
totalSansVentilation = 0.0
for dateDepot, IDdepot, dictDepot in listeDepotsTemp :
if dateDepot == datetime.date(1977, 1, 1) :
dateStr = _(u"Sans date de dépôt")
else:
dateStr = u"%02d/%02d/%04d" % (dateDepot.day, dateDepot.month, dateDepot.year)
label = u"%s (%s - %.2f %s)" % (dictDepot["nom"], dateStr, dictDepot["montantTotal"], SYMBOLE)
if IDdepot == None : label = dictDepot["nom"]
niveauDepot = self.AppendItem(self.root, label)
impressionLigne = [label,]
if self.affichage_details == True :
self.dictImpression["coloration"].append(len(self.dictImpression["contenu"]))
# Colonnes périodes
totalLigne = 0.0
for periode in listePeriodes :
if dictVentilation.has_key(IDdepot) and dictVentilation[IDdepot].has_key(periode) :
valeur = 0.0
for labelPrestation, montantVentilation in dictVentilation[IDdepot][periode].iteritems() :
valeur += montantVentilation
totalLigne += valeur
texte = u"%.2f %s" % (valeur, SYMBOLE)
self.SetItemText(niveauDepot, texte, dictColonnes[periode])
impressionLigne.append(texte)
else:
impressionLigne.append("")
# Colonne NON VENTILE
if self.type == "depots" :
totalDepot = dictDepots[IDdepot]["montantTotal"]
sansVentilation = totalDepot - totalLigne
if sansVentilation != 0.0 :
totalLigne += sansVentilation
totalSansVentilation += sansVentilation
texte = u"%.2f %s" % (sansVentilation, SYMBOLE)
self.SetItemText(niveauDepot, texte, dictColonnes["sansVentilation"])
impressionLigne.append(texte)
else:
impressionLigne.append(u"")
# Colonne Total
texte = u"%.2f %s" % (totalLigne, SYMBOLE)
self.SetItemText(niveauDepot, texte, dictColonnes["total"])
impressionLigne.append(texte)
self.dictImpression["contenu"].append(impressionLigne)
# ----------------- Branches LABELS DE PRESTATIONS -------------
listeLabelsPrestations = []
for periode in listePeriodes :
if dictVentilation.has_key(IDdepot) :
if dictVentilation[IDdepot].has_key(periode) :
for labelPrestation, montantVentilation in dictVentilation[IDdepot][periode].iteritems() :
if labelPrestation not in listeLabelsPrestations :
listeLabelsPrestations.append(labelPrestation)
listeLabelsPrestations.sort()
for labelPrestation in listeLabelsPrestations :
if self.affichage_details == True :
niveauPrestation = self.AppendItem(niveauDepot, labelPrestation)
self.SetItemFont(niveauPrestation, wx.Font(7, wx.SWISS, wx.NORMAL, wx.NORMAL))
self.SetItemTextColour(niveauPrestation, wx.Colour(160, 160, 160) )
impressionLigne = [labelPrestation,]
# Colonnes périodes
totalLigne = 0.0
for periode in listePeriodes :
texte = None
if dictVentilation.has_key(IDdepot) :
if dictVentilation[IDdepot].has_key(periode) :
if dictVentilation[IDdepot][periode].has_key(labelPrestation) :
valeur = dictVentilation[IDdepot][periode][labelPrestation]
totalLigne += valeur
if dictLigneTotal.has_key(labelPrestation) == False :
dictLigneTotal[labelPrestation] = {}
if dictLigneTotal[labelPrestation].has_key(periode) == False :
dictLigneTotal[labelPrestation][periode] = 0.0
dictLigneTotal[labelPrestation][periode] += valeur
if self.affichage_details == True :
texte = u"%.2f %s" % (valeur, SYMBOLE)
self.SetItemText(niveauPrestation, texte, dictColonnes[periode])
impressionLigne.append(texte)
if texte == None and self.affichage_details == True : impressionLigne.append("")
# Colonne Non ventilé
if self.type == "depots" and self.affichage_details == True :
impressionLigne.append(u"")
# Colonne Total
if self.affichage_details == True :
texte = u"%.2f %s" % (totalLigne, SYMBOLE)
self.SetItemText(niveauPrestation, texte, dictColonnes["total"])
impressionLigne.append(texte)
self.dictImpression["contenu"].append(impressionLigne)
# ------------ Ligne Total --------------
niveauTotal = self.AppendItem(self.root, _(u"Total"))
self.SetItemBackgroundColour(niveauTotal, wx.Colour(150, 150, 150) )
self.SetItemTextColour(niveauTotal, wx.Colour(255, 255, 255) )
impressionLigne = [_(u"Total"),]
listeLabels = dictLigneTotal.keys()
listeLabels.sort()
# Ligne de TOTAL pour chaque PERIODE
totalLigne = 0.0
for periode in listePeriodes :
totalColonne = 0.0
for dateDepot, IDdepot, dictDepot in listeDepotsTemp :
for label in listeLabels :
if dictVentilation.has_key(IDdepot) :
if dictVentilation[IDdepot].has_key(periode):
if dictVentilation[IDdepot][periode].has_key(label):
valeur = dictVentilation[IDdepot][periode][label]
totalColonne += valeur
texte = u"%.2f %s" % (totalColonne, SYMBOLE)
totalLigne += totalColonne
self.SetItemText(niveauTotal, texte, dictColonnes[periode])
impressionLigne.append(texte)
# Total SANS VENTILATION
if self.type == "depots" :
texte = u"%.2f %s" % (totalSansVentilation, SYMBOLE)
totalLigne += totalSansVentilation
self.SetItemText(niveauTotal, texte, dictColonnes["sansVentilation"])
impressionLigne.append(texte)
# Total de la ligne de Total
texte = u"%.2f %s" % (totalLigne, SYMBOLE)
self.SetItemText(niveauTotal, texte, dictColonnes["total"])
impressionLigne.append(texte)
self.dictImpression["total"].append(impressionLigne)
# Total des colonnes par label de prestation
if self.affichage_details == True :
for label in listeLabels :
niveauPrestation = self.AppendItem(niveauTotal, label)
self.SetItemFont(niveauPrestation, wx.Font(7, wx.SWISS, wx.NORMAL, wx.NORMAL))
self.SetItemTextColour(niveauPrestation, wx.Colour(120, 120, 120) )
self.SetItemBackgroundColour(niveauPrestation, wx.Colour(210, 210, 210) )
impressionLigne = [label,]
totalLigne = 0.0
for periode in listePeriodes :
texte = None
if dictLigneTotal.has_key(label):
if dictLigneTotal[label].has_key(periode) :
valeur = dictLigneTotal[label][periode]
totalLigne += valeur
texte = u"%.2f %s" % (valeur, SYMBOLE)
self.SetItemText(niveauPrestation, texte, dictColonnes[periode])
impressionLigne.append(texte)
if texte == None : impressionLigne.append(u"")
# Colonne None ventilé
if self.type == "depots" :
impressionLigne.append(u"")
# Colonne Total
texte = u"%.2f %s" % (totalLigne, SYMBOLE)
self.SetItemText(niveauPrestation, texte, dictColonnes["total"])
impressionLigne.append(texte)
self.dictImpression["total"].append(impressionLigne)
self.ExpandAllChildren(self.root)
def RAZ(self):
self.DeleteAllItems()
for indexColonne in range(self.GetColumnCount()-1, -1, -1) :
self.RemoveColumn(indexColonne)
self.DeleteRoot()
def DevelopperTout(self):
item = self.GetFirstChild(self.root)[0]
for index in range(0, self.GetChildrenCount(self.root)-1) :
self.Expand(item)
item = self.GetNext(item)
def ReduireTout(self):
item = self.GetFirstChild(self.root)[0]
for index in range(0, self.GetChildrenCount(self.root)-1) :
self.Collapse(item)
item = self.GetNext(item)
def Imprimer(self):
dlg = DLG_Options_impression_pdf.Dialog(self, categorie="synthese_ventilation", ctrl=CTRL_Parametres)
if dlg.ShowModal() == wx.ID_OK:
dictOptions = dlg.GetOptions()
dlg.Destroy()
else :
dlg.Destroy()
return
# Création du PDF
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
from reportlab.lib.pagesizes import A4
from reportlab.lib import colors
from reportlab.lib.styles import ParagraphStyle
hauteur_page = A4[0]
largeur_page = A4[1]
# Initialisation du PDF
nomDoc = FonctionsPerso.GenerationNomDoc("STATS_VENTILATION", "pdf")
if sys.platform.startswith("win") : nomDoc = nomDoc.replace("/", "\\")
doc = SimpleDocTemplate(nomDoc, pagesize=(largeur_page, hauteur_page), topMargin=30, bottomMargin=30)
story = []
# Création du titre du document
def Header():
dataTableau = []
largeursColonnes = ( (largeur_page-175, 100) )
dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today()))
dataTableau.append( (_(u"Analyse croisée ventilation/dépôts"), _(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,20))
# Insère un header
Header()
# Tableau
dataTableau = []
largeursColonnes = [dictOptions["largeur_colonne_labels"],]
for x in range(0, len(self.dictImpression["entete"])-1):
largeursColonnes.append(dictOptions["largeur_colonne_valeurs"])
# Entetes labels
dataTableau.append(self.dictImpression["entete"])
paraNormal = ParagraphStyle(name="normal", fontName="Helvetica", fontSize=dictOptions["taille_texte"], spaceAfter=0, leading=dictOptions["taille_texte"]+1, spaceBefore=0)
paraTitre = ParagraphStyle(name="titre", fontName="Helvetica-Bold", fontSize=dictOptions["taille_texte"], spaceAfter=0, leading=dictOptions["taille_texte"]+1, spaceBefore=0)
# Contenu du tableau
listeRubriques = ("contenu", "total")
for rubrique in listeRubriques :
listeLignes = self.dictImpression[rubrique]
indexLigne = 0
for ligne in listeLignes :
ligneTemp = []
indexColonne = 0
for texte in ligne :
# Aligne à droite les montants
if indexColonne > 0 :
texte = _(u"<para align='right'>%s</para>") % texte
case = Paragraph(texte, paraNormal)
# Ligne de titre
if rubrique == "contenu" and indexLigne in self.dictImpression["coloration"] :
case = Paragraph(texte, paraTitre)
ligneTemp.append(case)
indexColonne += 1
dataTableau.append(ligneTemp)
indexLigne += 1
positionLigneTotal = len(self.dictImpression["contenu"]) + 1
listeStyles = [
('VALIGN', (0,0), (-1,-1), 'MIDDLE'), # Centre verticalement toutes les cases
('FONT',(0,0),(-1,-1), "Helvetica", dictOptions["taille_texte"]), # Donne la police de caract. + taille de police
('GRID', (0,0), (-1,-1), 0.25, colors.black), # Crée la bordure noire pour tout le tableau
('ALIGN', (0,0), (-1,-1), 'CENTRE'), # Centre les cases
('BACKGROUND', (0,0), (-1,0), UTILS_Divers.ConvertCouleurWXpourPDF(dictOptions["couleur_fond_entetes"]) ), # Donne la couleur de fond du label
('BACKGROUND', (0, positionLigneTotal), (-1, positionLigneTotal), UTILS_Divers.ConvertCouleurWXpourPDF(dictOptions["couleur_fond_total"]) ), # Donne la couleur de fond du label
]
# Formatage des lignes "Activités"
for indexColoration in self.dictImpression["coloration"] :
listeStyles.append( ('BACKGROUND', (0, indexColoration+1), (-1, indexColoration+1), UTILS_Divers.ConvertCouleurWXpourPDF(dictOptions["couleur_fond_depot"])))
# Création du tableau
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
story.append(Spacer(0,20))
# Enregistrement du PDF
doc.build(story)
# Affichage du PDF
FonctionsPerso.LanceFichierExterne(nomDoc)
def GetDonneesImpression(self, listeCotisations=[]):
""" Impression des factures """
dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None)
if 'phoenix' not in wx.PlatformInfo:
wx.Yield()
# Récupère les données de la facture
if len(listeCotisations) == 0: conditions = "()"
elif len(listeCotisations) == 1:
conditions = "(%d)" % listeCotisations[0]
else:
conditions = str(tuple(listeCotisations))
DB = GestionDB.DB()
# Récupération des activités
req = """SELECT IDactivite, nom, abrege
FROM activites
ORDER BY date_fin DESC;"""
DB.ExecuterReq(req)
listeTemp = DB.ResultatReq()
dictActivites = {}
for IDactivite, nom, abrege in listeTemp:
dictTemp = {"IDactivite": IDactivite, "nom": nom, "abrege": abrege}
dictActivites[IDactivite] = dictTemp
# Récupère les prestations
dictFacturation = {}
req = """SELECT IDcotisation, SUM(montant)
FROM prestations
LEFT JOIN cotisations ON cotisations.IDprestation = prestations.IDprestation
WHERE cotisations.IDcotisation IN %s
GROUP BY cotisations.IDcotisation;""" % conditions
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
for IDcotisation, montant in listePrestations:
dictFacturation[IDcotisation] = {
"montant": montant,
"ventilation": 0.0,
"dateReglement": None,
"modeReglement": None
}
# Récupère la ventilation
req = """SELECT IDcotisation, SUM(ventilation.montant), MIN(reglements.date), MIN(modes_reglements.label)
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN cotisations ON cotisations.IDprestation = ventilation.IDprestation
LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement
LEFT JOIN modes_reglements ON modes_reglements.IDmode = reglements.IDmode
WHERE cotisations.IDcotisation IN %s
GROUP BY cotisations.IDcotisation;""" % conditions
DB.ExecuterReq(req)
listeVentilations = DB.ResultatReq()
for IDcotisation, ventilation, dateReglement, modeReglement in listeVentilations:
if IDcotisation in dictFacturation:
dictFacturation[IDcotisation]["ventilation"] = ventilation
dictFacturation[IDcotisation]["dateReglement"] = dateReglement
dictFacturation[IDcotisation]["modeReglement"] = modeReglement
# Recherche les cotisations
req = """
SELECT
cotisations.IDcotisation,
cotisations.IDfamille, cotisations.IDindividu, cotisations.IDtype_cotisation, cotisations.IDunite_cotisation,
cotisations.date_saisie, cotisations.IDutilisateur, cotisations.date_creation_carte, cotisations.numero,
cotisations.IDdepot_cotisation, cotisations.date_debut, cotisations.date_fin, cotisations.IDprestation,
types_cotisations.nom, types_cotisations.type, types_cotisations.carte,
unites_cotisations.nom, comptes_payeurs.IDcompte_payeur, cotisations.observations, cotisations.activites
FROM cotisations
LEFT JOIN types_cotisations ON types_cotisations.IDtype_cotisation = cotisations.IDtype_cotisation
LEFT JOIN unites_cotisations ON unites_cotisations.IDunite_cotisation = cotisations.IDunite_cotisation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = cotisations.IDfamille
WHERE cotisations.IDcotisation IN %s
ORDER BY cotisations.date_saisie
;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
del dlgAttente
return False
# Création des dictRappels
dictDonnees = {}
dictChampsFusion = {}
for item in listeDonnees:
IDcotisation = item[0]
IDfamille = item[1]
IDindividu = item[2]
IDtype_cotisation = item[3]
IDunite_cotisation = item[4]
date_saisie = UTILS_Dates.DateEngEnDateDD(item[5])
IDutilisateur = item[6]
date_creation_carte = item[7]
numero = item[8]
IDdepot_cotisation = item[9]
date_debut = UTILS_Dates.DateEngEnDateDD(item[10])
date_fin = UTILS_Dates.DateEngEnDateDD(item[11])
IDprestation = item[12]
nomTypeCotisation = item[13]
typeTypeCotisation = item[14]
typeHasCarte = item[15]
nomUniteCotisation = item[16]
IDcompte_payeur = item[17]
observations = item[18]
activites = item[19]
if activites == None:
activites = ""
# Activités
texte = ""
if len(activites) > 0:
listeTemp = []
listeIDactivites = UTILS_Divers.ConvertChaineEnListe(activites)
for IDactivite in listeIDactivites:
if IDactivite in dictActivites:
nomActivite = dictActivites[IDactivite]["nom"]
listeTemp.append(nomActivite)
if len(listeTemp) > 0:
texte = ", ".join(listeTemp)
activites = texte
nomCotisation = u"%s - %s" % (nomTypeCotisation,
nomUniteCotisation)
# Type
if typeTypeCotisation == "famille":
typeStr = _(u"Cotisation familiale")
else:
typeStr = _(u"Cotisation individuelle")
# Dépôt
if IDdepot_cotisation == None:
depotStr = _(u"Non déposée")
else:
depotStr = _(u"Dépôt n°%d") % IDdepot_cotisation
# Nom des titulaires de famille
beneficiaires = ""
rue = ""
cp = ""
ville = ""
if IDfamille != None:
beneficiaires = self.dictTitulaires[IDfamille][
"titulairesAvecCivilite"]
rue = self.dictTitulaires[IDfamille]["adresse"]["rue"]
cp = self.dictTitulaires[IDfamille]["adresse"]["cp"]
ville = self.dictTitulaires[IDfamille]["adresse"]["ville"]
if IDindividu != None and IDindividu in self.dictIndividus:
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 = ""
# Facturation
montant = 0.0
ventilation = 0.0
dateReglement = None
modeReglement = None
if IDcotisation in dictFacturation:
montant = dictFacturation[IDcotisation]["montant"]
ventilation = dictFacturation[IDcotisation]["ventilation"]
dateReglement = dictFacturation[IDcotisation]["dateReglement"]
modeReglement = dictFacturation[IDcotisation]["modeReglement"]
solde = float(
FloatToDecimal(montant) - FloatToDecimal(ventilation))
montantStr = u"%.02f %s" % (montant, SYMBOLE)
regleStr = u"%.02f %s" % (ventilation, SYMBOLE)
soldeStr = u"%.02f %s" % (solde, SYMBOLE)
montantStrLettres = UTILS_Conversion.trad(montant,
MONNAIE_SINGULIER,
MONNAIE_DIVISION)
regleStrLettres = UTILS_Conversion.trad(ventilation,
MONNAIE_SINGULIER,
MONNAIE_DIVISION)
soldeStrLettres = UTILS_Conversion.trad(solde, MONNAIE_SINGULIER,
MONNAIE_DIVISION)
# Mémorisation des données
dictDonnee = {
"select":
True,
"{IDCOTISATION}":
str(IDcotisation),
"{IDTYPE_COTISATION}":
str(IDtype_cotisation),
"{IDUNITE_COTISATION}":
str(IDunite_cotisation),
"{DATE_SAISIE}":
UTILS_Dates.DateDDEnFr(date_saisie),
"{IDUTILISATEUR}":
str(IDutilisateur),
"{DATE_CREATION_CARTE}":
UTILS_Dates.DateDDEnFr(date_creation_carte),
"{NUMERO_CARTE}":
numero,
"{IDDEPOT_COTISATION}":
str(IDdepot_cotisation),
"{DATE_DEBUT}":
UTILS_Dates.DateDDEnFr(date_debut),
"{DATE_FIN}":
UTILS_Dates.DateDDEnFr(date_fin),
"{IDPRESTATION}":
str(IDprestation),
"{NOM_TYPE_COTISATION}":
nomTypeCotisation,
"{NOM_UNITE_COTISATION}":
nomUniteCotisation,
"{COTISATION_FAM_IND}":
typeStr,
"{IDCOMPTE_PAYEUR}":
str(IDcompte_payeur),
"{NOM_COTISATION}":
nomCotisation,
"{NOM_DEPOT}":
depotStr,
"{MONTANT_FACTURE}":
montantStr,
"{MONTANT_REGLE}":
regleStr,
"{SOLDE_ACTUEL}":
soldeStr,
"{MONTANT_FACTURE_LETTRES}":
montantStrLettres.capitalize(),
"{MONTANT_REGLE_LETTRES}":
regleStrLettres.capitalize(),
"{SOLDE_ACTUEL_LETTRES}":
soldeStrLettres.capitalize(),
"{DATE_REGLEMENT}":
UTILS_Dates.DateDDEnFr(dateReglement),
"{MODE_REGLEMENT}":
modeReglement,
"{ACTIVITES}":
activites,
"{NOTES}":
observations,
"{IDINDIVIDU}":
IDindividu,
"{BENEFICIAIRE_NOM}":
beneficiaires,
"{BENEFICIAIRE_RUE}":
rue,
"{BENEFICIAIRE_CP}":
cp,
"{BENEFICIAIRE_VILLE}":
ville,
"{IDFAMILLE}":
str(IDfamille),
"{FAMILLE_NOM}":
nomTitulaires,
"{FAMILLE_RUE}":
famille_rue,
"{FAMILLE_CP}":
famille_cp,
"{FAMILLE_VILLE}":
famille_ville,
"{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.GetDonnees(IDfamille):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee[
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
dictDonnees[IDcotisation] = dictDonnee
# Champs de fusion pour Email
dictChampsFusion[IDcotisation] = {}
for key, valeur in dictDonnee.items():
if key[0] == "{":
dictChampsFusion[IDcotisation][key] = valeur
del dlgAttente
return dictDonnees, dictChampsFusion
def GetDonnees(self, format="texte"):
""" Retourne les données au format texte ou liste """
if format == "texte":
return UTILS_Divers.ConvertListeEnChaine(self.listeDonnees)
else:
return self.listeDonnees
def Importation(self):
""" Importation des données """
dictDonnees = {}
if self.IDmodele == None or self.date_debut == None or self.date_fin == None:
return dictDonnees
DB = GestionDB.DB()
# Modèle
req = """SELECT modeles_commandes.nom, modeles_commandes.IDrestaurateur, parametres,
restaurateurs.nom, restaurateurs.tel, restaurateurs.mail
FROM modeles_commandes
LEFT JOIN restaurateurs ON restaurateurs.IDrestaurateur = modeles_commandes.IDrestaurateur
WHERE IDmodele=%d;""" % self.IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0:
nom_modele, IDrestaurateur, parametres, restaurateur_nom, restaurateur_tel, restaurateur_mail = listeDonnees[
0]
if type(parametres) in (str, unicode):
exec(u"parametres = %s" % parametres)
dictDonnees["modele_nom"] = nom_modele
dictDonnees["modele_parametres"] = parametres
dictDonnees["IDrestaurateur"] = IDrestaurateur
dictDonnees["restaurateur_nom"] = restaurateur_nom
dictDonnees["restaurateur_tel"] = restaurateur_tel
dictDonnees["restaurateur_mail"] = restaurateur_mail
# Colonnes
req = """SELECT IDcolonne, ordre, nom, largeur, categorie, parametres
FROM modeles_commandes_colonnes
WHERE IDmodele=%d
ORDER BY ordre;""" % self.IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["liste_colonnes"] = []
dictDonnees["dict_colonnes"] = {}
if len(listeDonnees) > 0:
index = 0
for IDcolonne, ordre, nom_colonne, largeur, categorie, parametres in listeDonnees:
if type(parametres) in (str, unicode):
exec(u"parametres = %s" % parametres)
dictColonne = {
"IDcolonne": IDcolonne,
"ordre": ordre,
"nom_colonne": nom_colonne,
"largeur": largeur,
"categorie": categorie,
"parametres": parametres
}
dictDonnees["liste_colonnes"].append(dictColonne)
dictDonnees["dict_colonnes"][index] = dictColonne
index += 1
# Recherche les activités concernées
listeUnites = []
for dictColonne in dictDonnees["liste_colonnes"]:
if dictColonne["parametres"].has_key("unites"):
for (IDgroupe, IDunite) in dictColonne["parametres"]["unites"]:
if IDunite not in listeUnites:
listeUnites.append(IDunite)
if len(listeUnites) == 0: conditionUnites = "()"
elif len(listeUnites) == 1: conditionUnites = "(%d)" % listeUnites[0]
else: conditionUnites = str(tuple(listeUnites))
# Ouvertures
req = """SELECT IDouverture, IDactivite, IDunite, IDgroupe, date
FROM ouvertures
WHERE date>='%s' AND date<='%s' AND IDunite IN %s;""" % (
self.date_debut, self.date_fin, conditionUnites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["liste_ouvertures"] = []
dictDonnees["dict_ouvertures"] = {}
dictDonnees["liste_dates"] = []
for IDouverture, IDactivite, IDunite, IDgroupe, date in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
dictOuverture = {
"IDouverture": IDouverture,
"IDactivite": IDactivite,
"IDunite": IDunite,
"IDgroupe": IDgroupe,
"date": date
}
dictDonnees["liste_ouvertures"].append(dictOuverture)
# Mémorisation dans un dict
dictDonnees["dict_ouvertures"] = UTILS_Divers.DictionnaireImbrique(
dictionnaire=dictDonnees["dict_ouvertures"],
cles=[date, IDgroupe, IDunite],
valeur=True)
# Mémorisation des dates
if date not in dictDonnees["liste_dates"]:
dictDonnees["liste_dates"].append(date)
dictDonnees["liste_dates"].sort()
dictDonnees["liste_dates"].append(_(u"Total"))
# Consommations
req = """SELECT IDconso, date, IDgroupe, IDunite, IDindividu
FROM consommations
WHERE date>='%s' AND date<='%s' AND IDunite IN %s AND consommations.etat IN ('reservation', 'present')
;""" % (self.date_debut, self.date_fin, conditionUnites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDonnees["dict_conso"] = {}
dictDonnees["liste_individus"] = []
dictDonnees["dict_dates"] = {}
for IDconso, date, IDgroupe, IDunite, IDindividu in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dictDonnees["dict_conso"].has_key(date) == False:
dictDonnees["dict_conso"][date] = {}
if dictDonnees["dict_conso"][date].has_key(IDgroupe) == False:
dictDonnees["dict_conso"][date][IDgroupe] = {}
if dictDonnees["dict_conso"][date][IDgroupe].has_key(
IDunite) == False:
dictDonnees["dict_conso"][date][IDgroupe][IDunite] = 0
dictDonnees["dict_conso"][date][IDgroupe][IDunite] += 1
if IDindividu not in dictDonnees["liste_individus"]:
dictDonnees["liste_individus"].append(IDindividu)
if dictDonnees["dict_dates"].has_key(date) == False:
dictDonnees["dict_dates"][date] = {}
if dictDonnees["dict_dates"][date].has_key(IDindividu) == False:
dictDonnees["dict_dates"][date][IDindividu] = []
if IDgroupe not in dictDonnees["dict_dates"][date][IDindividu]:
dictDonnees["dict_dates"][date][IDindividu].append(IDgroupe)
if len(dictDonnees["liste_individus"]) == 0: conditionIndividus = "()"
elif len(dictDonnees["liste_individus"]) == 1:
conditionIndividus = "(%d)" % dictDonnees["liste_individus"][0]
else:
conditionIndividus = str(tuple(dictDonnees["liste_individus"]))
# Informations médicales
req = """SELECT IDprobleme, problemes_sante.IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical,
description_traitement, date_debut_traitement, date_fin_traitement,
individus.nom, individus.prenom
FROM problemes_sante
LEFT JOIN individus ON individus.IDindividu = problemes_sante.IDindividu
WHERE diffusion_listing_repas=1 AND problemes_sante.IDindividu IN %s
;""" % conditionIndividus
DB.ExecuterReq(req)
listeInformations = DB.ResultatReq()
dictInfosMedicales = {}
for IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical, description_traitement, date_debut_traitement, date_fin_traitement, individu_nom, individu_prenom in listeInformations:
date_debut = UTILS_Dates.DateEngEnDateDD(date_debut)
date_fin = UTILS_Dates.DateEngEnDateDD(date_fin)
if dictInfosMedicales.has_key(IDindividu) == False:
dictInfosMedicales[IDindividu] = []
dictTemp = {
"IDprobleme": IDprobleme,
"IDcategorie": IDtype,
"intitule": intitule,
"date_debut": date_debut,
"date_fin": date_fin,
"description": description,
"traitement_medical": traitement_medical,
"description_traitement": description_traitement,
"date_debut_traitement": date_debut_traitement,
"date_fin_traitement": date_fin_traitement,
"individu_nom": individu_nom,
"individu_prenom": individu_prenom,
}
dictInfosMedicales[IDindividu].append(dictTemp)
dictDonnees["infos_medicales"] = dictInfosMedicales
# Messages
req = """SELECT IDmessage, IDcategorie, priorite,
messages.IDindividu, texte, individus.nom, individus.prenom
FROM messages
LEFT JOIN individus ON individus.IDindividu = messages.IDindividu
WHERE afficher_commande=1 AND messages.IDindividu IN %s
;""" % conditionIndividus
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictMessages = {}
for IDmessage, IDcategorie, priorite, IDindividu, texte, individu_nom, individu_prenom in listeDonnees:
dictTemp = {
"IDmessage": IDmessage,
"IDindividu": IDindividu,
"priorite": priorite,
"texte": texte,
"individu_nom": individu_nom,
"individu_prenom": individu_prenom
}
if dictMessages.has_key(IDindividu) == False:
dictMessages[IDindividu] = []
dictMessages[IDindividu].append(dictTemp)
dictDonnees["messages"] = dictMessages
# Repas
dictDonnees["valeurs"] = {}
if self.IDcommande != None:
req = """SELECT IDvaleur, date, IDcolonne, valeur
FROM commandes_valeurs
WHERE IDcommande=%d
;""" % self.IDcommande
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
for IDvaleur, date, IDcolonne, valeur in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dictDonnees["valeurs"].has_key(date) == False:
dictDonnees["valeurs"][date] = {}
dictDonnees["valeurs"][date][IDcolonne] = {
"IDvaleur": IDvaleur,
"valeur": valeur
}
# Menus
if dictDonnees.has_key("IDrestaurateur"):
IDrestaurateur = dictDonnees["IDrestaurateur"]
if IDrestaurateur == None:
IDrestaurateur = 0
else:
IDrestaurateur = 0
req = """SELECT IDmenu, menus.IDcategorie, menus_categories.nom, date, texte
FROM menus
LEFT JOIN menus_categories ON menus_categories.IDcategorie = menus.IDcategorie
WHERE date>='%s' AND date<='%s' AND IDrestaurateur=%d
ORDER BY menus_categories.ordre;""" % (self.date_debut, self.date_fin,
IDrestaurateur)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dict_menus = {}
for IDmenu, IDcategorie, nom_categorie, date, texte in listeDonnees:
date = UTILS_Dates.DateEngEnDateDD(date)
if dict_menus.has_key(date) == False:
dict_menus[date] = []
dict_menus[date].append({
"IDmenu": IDmenu,
"IDcategorie": IDcategorie,
"nom_categorie": nom_categorie,
"texte": texte
})
dictDonnees["dict_menus"] = dict_menus
DB.Close()
return dictDonnees
def OnBoutonOk(self, event):
dictParametres = self.ctrl_notebook.GetParametres()
# Récupération et vérification des données
listeActivites = dictParametres["liste_activites"]
if len(listeActivites) == 0 :
self.ctrl_notebook.AffichePage("generalites")
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement cocher au moins une activité !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Récupération et vérification des données
listeGroupes = dictParametres["liste_groupes"]
if len(dictParametres["liste_groupes"]) == 0 :
self.ctrl_notebook.AffichePage("generalites")
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement cocher au moins un groupe !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Vérification qu'il y a des colonnes
if not dictParametres["colonnes"]:
dlg = wx.MessageDialog(self, _(u"Vous devez obligatoirement créer au moins une colonne !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
# Recherche les catégories utilisées
liste_categories_utilisees = []
for nom_categorie, categories in dictParametres["colonnes"]:
for IDcategorie in UTILS_Texte.ConvertStrToListe(categories):
if IDcategorie not in liste_categories_utilisees :
liste_categories_utilisees.append(IDcategorie)
# Création du PDF
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
from reportlab.platypus.flowables import ParagraphAndImage, Image
from reportlab.lib.pagesizes import A4
from reportlab.lib import colors
from reportlab.lib.styles import ParagraphStyle
self.taille_page = A4
if dictParametres["orientation"] == "portrait" :
self.hauteur_page = self.taille_page[1]
self.largeur_page = self.taille_page[0]
else:
self.hauteur_page = self.taille_page[0]
self.largeur_page = self.taille_page[1]
# Création des conditions pour les requêtes SQL
conditionsPeriodes = GetSQLdates(dictParametres["liste_periodes"])
if len(listeActivites) == 0 : conditionActivites = "()"
elif len(listeActivites) == 1 : conditionActivites = "(%d)" % listeActivites[0]
else : conditionActivites = str(tuple(listeActivites))
if len(listeGroupes) == 0 : conditionGroupes = "()"
elif len(listeGroupes) == 1 : conditionGroupes = "(%d)" % listeGroupes[0]
else : conditionGroupes = str(tuple(listeGroupes))
# Récupération des noms des groupes
dictGroupes = dictParametres["dict_groupes"]
dictActivites = dictParametres["dict_activites"]
DB = GestionDB.DB()
# ------------ MODE PRESENTS ---------------------------------
if dictParametres["mode"] == "presents" :
# Récupération de la liste des groupes ouverts sur cette période
req = """SELECT IDouverture, IDactivite, IDunite, IDgroupe
FROM ouvertures
WHERE ouvertures.IDactivite IN %s AND %s
AND IDgroupe IN %s
; """ % (conditionActivites, conditionsPeriodes, conditionGroupes)
DB.ExecuterReq(req)
listeOuvertures = DB.ResultatReq()
dictOuvertures = {}
for IDouverture, IDactivite, IDunite, IDgroupe in listeOuvertures :
if (IDactivite in dictOuvertures) == False :
dictOuvertures[IDactivite] = []
if IDgroupe not in dictOuvertures[IDactivite] :
dictOuvertures[IDactivite].append(IDgroupe)
# Récupération des individus grâce à leurs consommations
req = """SELECT individus.IDindividu, IDactivite, IDgroupe,
IDcivilite, nom, prenom, date_naiss
FROM consommations
LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu
WHERE consommations.etat IN ("reservation", "present")
AND IDactivite IN %s AND %s
GROUP BY individus.IDindividu, IDactivite, IDgroupe
ORDER BY nom, prenom
;""" % (conditionActivites, conditionsPeriodes)
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
# ------------ MODE INSCRITS ---------------------------------
if dictParametres["mode"] == "inscrits" :
dictOuvertures = {}
for IDgroupe, dictGroupe in dictGroupes.items() :
IDactivite = dictGroupe["IDactivite"]
if (IDactivite in dictOuvertures) == False :
dictOuvertures[IDactivite] = []
if IDgroupe not in dictOuvertures[IDactivite] :
dictOuvertures[IDactivite].append(IDgroupe)
# Récupération des individus grâce à leurs consommations
req = """SELECT individus.IDindividu, IDactivite, IDgroupe,
IDcivilite, nom, prenom, date_naiss
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
WHERE inscriptions.statut='ok' AND IDactivite IN %s
GROUP BY individus.IDindividu, IDactivite, IDgroupe
ORDER BY nom, prenom
;""" % conditionActivites
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
# Analyse des individus
dictIndividus = {}
listeIDindividus = []
for IDindividu, IDactivite, IDgroupe, IDcivilite, nom, prenom, date_naiss in listeIndividus:
if date_naiss != None: date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss)
age = self.GetAge(date_naiss)
# Mémorisation de l'individu
dictIndividus[IDindividu] = {
"IDcivilite": IDcivilite, "nom": nom, "prenom": prenom,
"age": age, "date_naiss": date_naiss, "IDgroupe": IDgroupe, "IDactivite": IDactivite,
}
# Mémorisation du IDindividu
if IDindividu not in listeIDindividus:
listeIDindividus.append(IDindividu)
# Dict Informations médicales
req = """SELECT IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical,
description_traitement, date_debut_traitement, date_fin_traitement, eviction, date_debut_eviction, date_fin_eviction
FROM problemes_sante
WHERE diffusion_listing_enfants=1
;"""
DB.ExecuterReq(req)
listeInformations = DB.ResultatReq()
DB.Close()
dictInfosMedicales = {}
for IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical, description_traitement, date_debut_traitement, date_fin_traitement, eviction, date_debut_eviction, date_fin_eviction in listeInformations :
if (IDindividu in dictInfosMedicales) == False :
dictInfosMedicales[IDindividu] = []
dictTemp = {
"IDprobleme" : IDprobleme, "IDcategorie" : IDtype, "intitule" : intitule, "date_debut" : date_debut,
"date_fin" : date_fin, "description" : description, "traitement_medical" : traitement_medical, "description_traitement" : description_traitement,
"date_debut_traitement" : date_debut_traitement, "date_fin_traitement" : date_fin_traitement, "eviction" : eviction,
"date_debut_eviction" : date_debut_eviction, "date_fin_eviction" : date_fin_eviction,
}
dictInfosMedicales[IDindividu].append(dictTemp)
# Récupération des photos individuelles
dictPhotos = {}
taillePhoto = 128
if dictParametres["afficher_photos"] == "petite" : tailleImageFinal = 16
if dictParametres["afficher_photos"] == "moyenne" : tailleImageFinal = 32
if dictParametres["afficher_photos"] == "grande" : tailleImageFinal = 64
if dictParametres["afficher_photos"] != "non" :
for IDindividu in listeIDindividus :
IDcivilite = dictIndividus[IDindividu]["IDcivilite"]
nomFichier = Chemins.GetStaticPath("Images/128x128/%s" % DICT_CIVILITES[IDcivilite]["nomImage"])
IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDindividu, nomFichier=nomFichier, taillePhoto=(taillePhoto, taillePhoto), qualite=100)
# Création de la photo dans le répertoire Temp
nomFichier = UTILS_Fichiers.GetRepTemp(fichier="photoTmp%d.jpg" % IDindividu)
bmp.SaveFile(nomFichier, type=wx.BITMAP_TYPE_JPEG)
img = Image(nomFichier, width=tailleImageFinal, height=tailleImageFinal)
dictPhotos[IDindividu] = img
# ---------------- Création du PDF -------------------
# Initialisation du PDF
nomDoc = FonctionsPerso.GenerationNomDoc("LISTE_INFORMATIONS_MEDICALES", "pdf")
if sys.platform.startswith("win") : nomDoc = nomDoc.replace("/", "\\")
doc = SimpleDocTemplate(nomDoc, pagesize=(self.largeur_page, self.hauteur_page), topMargin=30, bottomMargin=30)
story = []
largeurContenu = self.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"Informations médicales"), _(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,20))
# Insère un header
Header()
# Activités
for IDactivite in listeActivites :
# Groupes
if IDactivite in dictOuvertures :
nbreGroupes = len(dictOuvertures[IDactivite])
indexGroupe = 1
for IDgroupe in dictOuvertures[IDactivite] :
nomGroupe = dictGroupes[IDgroupe]["nom"]
if isinstance(dictActivites[IDactivite], dict):
nomActivite = dictActivites[IDactivite]["nom"]
else:
nomActivite = dictActivites[IDactivite]
# Initialisation du tableau
dataTableau = []
largeursColonnes = []
labelsColonnes = []
# Recherche des entêtes de colonnes :
if dictParametres["afficher_photos"] != "non" :
labelsColonnes.append(_(u"Photo"))
largeursColonnes.append(tailleImageFinal+6)
labelsColonnes.append(_(u"Nom - prénom"))
if dictParametres["largeur_colonne_nom"] == "automatique" :
largeursColonnes.append(120)
else :
largeursColonnes.append(int(dictParametres["largeur_colonne_nom"]))
if dictParametres["afficher_age"] == True :
labelsColonnes.append(_(u"Âge"))
if dictParametres["largeur_colonne_age"] == "automatique":
largeursColonnes.append(20)
else:
largeursColonnes.append(int(dictParametres["largeur_colonne_age"]))
# Calcule la largeur restante
largeurRestante = largeurContenu - sum(largeursColonnes)
# Calcul des largeurs de colonnes
largeurColonnes = largeurRestante * 1.0 / len(dictParametres["colonnes"])
for nom_categorie, categories in dictParametres["colonnes"]:
labelsColonnes.append(nom_categorie)
largeursColonnes.append(largeurColonnes)
# Création de l'entete de groupe
ligne = [u"%s - %s" % (nomActivite, nomGroupe),]
for x in range(0, len(labelsColonnes)-1):
ligne.append("")
dataTableau.append(ligne)
# Création des entêtes
ligne = []
for label in labelsColonnes :
ligne.append(label)
dataTableau.append(ligne)
# --------- Création des lignes -----------
# Création d'une liste temporaire pour le tri
listeIndividus = []
if IDactivite in dictOuvertures :
if IDgroupe in dictOuvertures[IDactivite] :
for IDindividu in listeIDindividus :
dictIndividu = dictIndividus[IDindividu]
if dictIndividu["IDgroupe"] == IDgroupe :
valeursTri = (IDindividu, dictIndividu["nom"], dictIndividu["prenom"], dictIndividu["age"])
# + Sélection uniquement des individus avec infos
if dictParametres["individus_avec_infos"] == False or (dictParametres["individus_avec_infos"] == True and IDindividu in dictInfosMedicales ) :
listeIndividus.append(valeursTri)
if dictParametres["tri"] == "nom" : paramTri = 1 # Nom
if dictParametres["tri"] == "prenom" : paramTri = 2 # Prénom
if dictParametres["tri"] == "age" : paramTri = 3 # Age
if dictParametres["ordre"] == "croissant" :
ordreDecroissant = False
else:
ordreDecroissant = True
listeIndividus = sorted(listeIndividus, key=operator.itemgetter(paramTri), reverse=ordreDecroissant)
# Récupération des lignes individus
for IDindividu, nom, prenom, age in listeIndividus :
dictIndividu = dictIndividus[IDindividu]
ligne = []
# Photo
if dictParametres["afficher_photos"] != "non" and IDindividu in dictPhotos :
img = dictPhotos[IDindividu]
ligne.append(img)
# Nom
ligne.append(u"%s %s" % (nom, prenom))
# Age
if dictParametres["afficher_age"] == True :
if age != None :
ligne.append(age)
else:
ligne.append("")
# Informations médicales
paraStyle = ParagraphStyle(name="infos",
fontName="Helvetica",
fontSize=7,
leading=8,
spaceAfter=2,
)
# Création des colonnes
has_infos = False
for nom_categorie, categories in dictParametres["colonnes"]:
liste_categories = UTILS_Texte.ConvertStrToListe(categories)
case = []
# Recherche s'il y a une info médicale dans cette case
if IDindividu in dictInfosMedicales:
for infoMedicale in dictInfosMedicales[IDindividu] :
IDcategorie = infoMedicale["IDcategorie"]
if IDcategorie in liste_categories or (0 in liste_categories and IDcategorie not in liste_categories_utilisees) :
intitule = infoMedicale["intitule"]
description = infoMedicale["description"]
traitement = infoMedicale["traitement_medical"]
description_traitement = infoMedicale["description_traitement"]
date_debut_traitement = infoMedicale["date_debut_traitement"]
date_fin_traitement = infoMedicale["date_fin_traitement"]
# Intitulé et description
if description != None and description != "":
texteInfos = u"<b>%s</b> : %s" % (intitule, description)
else:
texteInfos = u"%s" % intitule
if len(texteInfos) > 0 and texteInfos[-1] != ".": texteInfos += u"."
# Traitement médical
if traitement == 1 and description_traitement != None and description_traitement != "":
texteDatesTraitement = u""
if date_debut_traitement != None and date_fin_traitement != None:
texteDatesTraitement = _(u" du %s au %s") % (UTILS_Dates.DateEngFr(date_debut_traitement), UTILS_Dates.DateEngFr(date_fin_traitement))
if date_debut_traitement != None and date_fin_traitement == None:
texteDatesTraitement = _(u" à partir du %s") % UTILS_Dates.DateEngFr(date_debut_traitement)
if date_debut_traitement == None and date_fin_traitement != None:
texteDatesTraitement = _(u" jusqu'au %s") % UTILS_Dates.DateEngFr(date_fin_traitement)
texteInfos += _(u"Traitement%s : %s.") % (texteDatesTraitement, description_traitement)
# Création du paragraphe
case.append(Paragraph(texteInfos, paraStyle))
has_infos = True
# Ajoute la case à la ligne
ligne.append(case)
# Ajout de la ligne individuelle dans le tableau
if dictParametres["individus_avec_infos"] == False or (dictParametres["individus_avec_infos"] == True and has_infos == True):
dataTableau.append(ligne)
# Création des lignes vierges
for x in range(0, dictParametres["nbre_lignes_vierges"]):
ligne = []
for col in labelsColonnes :
ligne.append("")
dataTableau.append(ligne)
# Style du tableau
couleur_fond_entetes = UTILS_Divers.ConvertCouleurWXpourPDF(dictParametres["couleur_fond_entetes"])
style = TableStyle([
('VALIGN', (0,0), (-1,-1), 'MIDDLE'), # Centre verticalement toutes les cases
('FONT',(0,0),(-1,-1), "Helvetica", 7), # Donne la police de caract. + taille de police
('GRID', (0,0), (-1,-1), 0.25, colors.black), # Crée la bordure noire pour tout le tableau
('ALIGN', (0,1), (-2,-1), 'CENTRE'), # Centre les cases
('ALIGN', (0,1), (-1,1), 'CENTRE'), # Ligne de labels colonne alignée au centre
('FONT',(0,1),(-1,1), "Helvetica", 6), # Donne la police de caract. + taille de police des labels
('SPAN',(0,0),(-1,0)), # Fusionne les lignes du haut pour faire le titre du groupe
('FONT',(0,0),(0,0), "Helvetica-Bold", 10), # Donne la police de caract. + taille de police du titre de groupe
('BACKGROUND', (0,0), (-1,0), couleur_fond_entetes), # Donne la couleur de fond du titre de groupe
])
# Création du tableau
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0,20))
# Saut de page après un groupe
if dictParametres["saut_page_groupe"] == True :
story.append(PageBreak())
# Insère un header
if indexGroupe < nbreGroupes :
Header()
indexGroupe += 1
# Enregistrement du PDF
doc.build(story)
# Affichage du PDF
FonctionsPerso.LanceFichierExterne(nomDoc)
def __init__(self, parent, donnees, dictFacturation):
self.IDcotisation = donnees[0]
self.IDfamille = donnees[1]
self.IDindividu = donnees[2]
self.IDtype_cotisation = donnees[3]
self.IDunite_cotisation = donnees[4]
self.date_saisie = UTILS_Dates.DateEngEnDateDD(donnees[5])
self.IDutilisateur = donnees[6]
self.date_creation_carte = donnees[7]
self.numero = donnees[8]
self.IDdepot_cotisation = donnees[9]
self.date_debut = UTILS_Dates.DateEngEnDateDD(donnees[10])
self.date_fin = UTILS_Dates.DateEngEnDateDD(donnees[11])
self.IDprestation = donnees[12]
self.nomTypeCotisation = donnees[13]
self.typeTypeCotisation = donnees[14]
self.typeHasCarte = donnees[15]
self.nomUniteCotisation = donnees[16]
self.IDcompte_payeur = donnees[17]
self.observations = donnees[18]
self.activites = donnees[19]
if self.activites == None :
self.activites = ""
# Activites
texte = ""
if len(self.activites) > 0 :
listeTemp = []
listeIDactivites = UTILS_Divers.ConvertChaineEnListe(self.activites)
for IDactivite in listeIDactivites :
if parent.dictActivites.has_key(IDactivite) :
nomActivite = parent.dictActivites[IDactivite]["nom"]
listeTemp.append(nomActivite)
if len(listeTemp) > 0 :
texte = ", ".join(listeTemp)
self.activitesStr = texte
# Nom cotisation
self.nomCotisation = u"%s - %s" % (self.nomTypeCotisation, self.nomUniteCotisation)
# Numéro de cotisation
try :
self.numero_int = int(self.numero)
except :
self.numero_int = None
# Titulaires famille
if parent.titulaires.has_key(self.IDfamille) :
self.nomsTitulaires = parent.titulaires[self.IDfamille]["titulairesSansCivilite"]
else :
self.nomsTitulaires = "nom inconnu"
# Type
if self.typeTypeCotisation == "famille" :
self.typeStr = _(u"Cotisation familiale")
else:
self.typeStr = _(u"Cotisation individuelle")
# Validité
dateDuJour = datetime.date.today()
if dateDuJour >= self.date_debut and dateDuJour <= self.date_fin :
self.valide = True
else:
self.valide = False
# Dépôt
if self.IDdepot_cotisation == None :
self.depotStr = _(u"Non déposée")
else:
self.depotStr = _(u"Dépôt n°%d") % self.IDdepot_cotisation
# Nom des titulaires de famille
self.beneficiaires = ""
self.rue = ""
self.cp = ""
self.ville = ""
if self.IDfamille != None :
self.beneficiaires = _(u"IDfamille n°%d") % self.IDfamille
if parent.dictFamillesRattachees != None :
if parent.dictFamillesRattachees.has_key(self.IDfamille) :
self.beneficiaires = parent.dictFamillesRattachees[self.IDfamille]["nomsTitulaires"]
else:
self.beneficiaires = parent.titulaires[self.IDfamille]["titulairesSansCivilite"]
self.rue = parent.titulaires[self.IDfamille]["adresse"]["rue"]
self.cp = parent.titulaires[self.IDfamille]["adresse"]["cp"]
self.ville = parent.titulaires[self.IDfamille]["adresse"]["ville"]
if self.IDindividu != None and parent.individus.has_key(self.IDindividu) :
self.beneficiaires = parent.individus[self.IDindividu]["nom_complet"]
self.rue = parent.individus[self.IDindividu]["rue"]
self.cp = parent.individus[self.IDindividu]["cp"]
self.ville = parent.individus[self.IDindividu]["ville"]
# Facturation
self.montant = 0.0
self.ventilation = 0.0
self.dateReglement = None
self.modeReglement = None
if dictFacturation.has_key(self.IDprestation):
self.montant = dictFacturation[self.IDprestation]["montant"]
self.ventilation = dictFacturation[self.IDprestation]["ventilation"]
self.dateReglement = dictFacturation[self.IDprestation]["dateReglement"]
self.modeReglement = dictFacturation[self.IDprestation]["modeReglement"]
self.solde = float(FloatToDecimal(self.montant) - FloatToDecimal(self.ventilation))
if self.solde > 0.0 :
self.solde = -self.solde
if self.montant == None :
self.solde = 0.0
