def Remplissage(self):
""" Remplissage """
# Branches GROUPE
dictTemp = {}
for dictCombi in self.listeDonnees:
IDgroupe = dictCombi["IDgroupe"]
if IDgroupe == None:
nomGroupe = _(u"Tous les groupes")
else:
if self.dictGroupes.has_key(IDgroupe):
nomGroupe = self.dictGroupes[IDgroupe]["nom"]
else:
nomGroupe = _(u"Groupe inconnu")
groupe = (nomGroupe, IDgroupe)
if dictTemp.has_key(groupe) == False:
dictTemp[groupe] = []
dictTemp[groupe].append(dictCombi)
dictTemp[groupe] = sorted(dictTemp[groupe],
key=operator.itemgetter("date"),
reverse=False)
listeGroupes = dictTemp.keys()
listeGroupes.sort()
for groupe in listeGroupes:
nomGroupe, IDgroupe = groupe
niveauGroupe = self.AppendItem(self.root, nomGroupe)
self.SetItemBold(niveauGroupe, True)
## self.SetItemBackgroundColour(niveauGroupe, COULEUR_FOND_REGROUPEMENT)
# Branches DATE
listeCombi = dictTemp[groupe]
for dictCombi in listeCombi:
date = dictCombi["date"]
niveauDate = self.AppendItem(niveauGroupe,
UTILS_Dates.DateComplete(date))
# Combinaisons d'unités
texteTemp = []
for dictUniteCombi in dictCombi["unites"]:
IDunite = dictUniteCombi["IDunite"]
texteTemp.append((self.dictUnites[IDunite]["ordre"],
self.dictUnites[IDunite]["nom"]))
texteTemp.sort()
texteTemp2 = []
for ordre, nomUnite in texteTemp:
texteTemp2.append(nomUnite)
texteUnites = u" + ".join(texteTemp2)
self.SetItemText(niveauDate, texteUnites, 1)
self.ExpandAllChildren(self.root)
def MAJ(self, forcerActualisation=False):
# Conditions
conditions = self.GetSQLdates(self.listePeriodes)
if len(conditions) > 0:
conditionDates = " AND %s" % conditions
else:
conditionDates = ""
if len(self.listeActivites) == 0: conditionActivites = "()"
elif len(self.listeActivites) == 1:
conditionActivites = "(%d)" % self.listeActivites[0]
else:
conditionActivites = str(tuple(self.listeActivites))
# Recherche des évènements
DB = GestionDB.DB()
req = """SELECT IDevenement, evenements.IDactivite, evenements.nom, date, heure_debut, heure_fin, capacite_max,
activites.nom
FROM evenements
LEFT JOIN activites ON activites.IDactivite = evenements.IDactivite
WHERE evenements.IDactivite IN %s %s
ORDER BY date, heure_debut;""" % (conditionActivites, conditionDates)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictEvenements = {}
dictDonnees = {}
for IDevenement, IDactivite, nom, date, heure_debut, heure_fin, capacite_max, nomActivite in listeDonnees:
if nomActivite == None:
nomActivite = _(u"Activité inconnue")
date = UTILS_Dates.DateEngEnDateDD(date)
dictEvenement = {
"nom": nom,
"IDactivite": IDactivite,
"date": date,
"heure_debut": heure_debut,
"heure_fin": heure_fin,
"nomActivite": nomActivite,
"nbre_max": capacite_max,
"nbre_inscrits": 0,
"nbre_attente": 0
}
dictEvenements[IDevenement] = dictEvenement
# Filtre
infos = " ".join([nom, UTILS_Dates.DateEngFr(str(date))])
if self.filtre == None or (self.filtre.lower() in infos.lower()):
# Mémorisation de l'évènement
key = (nomActivite, IDactivite)
if (key in dictDonnees) == False:
dictDonnees[key] = {}
if (date in dictDonnees[key]) == False:
dictDonnees[key][date] = []
dictDonnees[key][date].append(IDevenement)
req = """SELECT IDconso, IDevenement, etat
FROM consommations
WHERE IDevenement IS NOT NULL AND consommations.etat in ('reservation', 'present', 'attente')
AND consommations.IDactivite IN %s %s
;""" % (conditionActivites, conditionDates)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
for IDconso, IDevenement, etat in listeDonnees:
if IDevenement in dictEvenements:
if etat in ("reservation", "present"):
dictEvenements[IDevenement]["nbre_inscrits"] += 1
if etat == "attente":
dictEvenements[IDevenement]["nbre_attente"] += 1
DB.Close()
# Vérifie si actualisation nécessaire
if self.dictEvenements != dictEvenements or forcerActualisation == True:
self.dictEvenements = dictEvenements
else:
return
# MAJ du contrôle
self.DeleteChildren(self.root)
# Préparation pour impression
self.dictImpression["contenu"] = []
self.dictImpression["coloration"] = []
# Tri par activités
listeActivites = list(dictDonnees.keys())
listeActivites.sort()
# Niveau Activité
for key in listeActivites:
nomActivite, IDactivite = key
label = nomActivite.upper()
niveau_activite = self.AppendItem(self.root, label)
self.SetItemBackgroundColour(niveau_activite,
wx.Colour(221, 221, 221))
self.dictImpression["contenu"].append([
label,
])
self.dictImpression["coloration"].append(
(len(self.dictImpression["contenu"]) - 1, "regroup"))
# Dates
listeDates = list(dictDonnees[key].keys())
listeDates.sort()
for date in listeDates:
label = UTILS_Dates.DateComplete(date)
niveau_date = self.AppendItem(niveau_activite, label)
font = self.GetFont()
font.SetWeight(wx.BOLD)
self.SetItemFont(niveau_date, font)
# Mémorisation ligne pour impression
self.dictImpression["contenu"].append([
label,
])
# Evènements
for IDevenement in dictDonnees[key][date]:
dictEvenement = dictEvenements[IDevenement]
label = dictEvenement["nom"]
niveau_evenement = self.AppendItem(niveau_date, label)
nbre_inscrits = dictEvenement["nbre_inscrits"]
if nbre_inscrits == None:
nbre_inscrits = 0
texte_inscrits = str(nbre_inscrits)
self.SetItemText(niveau_evenement, texte_inscrits, 1)
nbre_max = dictEvenement["nbre_max"]
if nbre_max == None:
texte_inscrits_max = ""
else:
texte_inscrits_max = str(nbre_max)
self.SetItemText(niveau_evenement, texte_inscrits_max, 2)
if nbre_max != None:
nbre_places_libres = nbre_max - nbre_inscrits
texte_places_libres = str(nbre_places_libres)
else:
nbre_places_libres = None
texte_places_libres = ""
self.SetItemText(niveau_evenement, texte_places_libres, 3)
nbre_attente = dictEvenement["nbre_attente"]
if nbre_attente in (0, None):
texte_attente = ""
else:
texte_attente = str(nbre_attente)
self.SetItemText(niveau_evenement, texte_attente, 4)
# Couleur de la ligne
couleur_fond = self.GetCouleurLigne(nbre_places_libres)
if couleur_fond != None:
self.SetItemBackgroundColour(niveau_evenement,
couleur_fond)
# Mémorisation ligne activité pour impression
self.dictImpression["contenu"].append([
u" %s" % label, texte_inscrits, texte_inscrits_max,
texte_places_libres
])
self.ExpandAllChildren(self.root)
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)
def Remplissage(self):
dictInscriptions, dictActivites, dictGroupes = self.Importation()
# Mémorisation pour impression
self.listeImpression = []
# Branches Activités
listeActivites = list(dictInscriptions.keys())
listeActivites.sort()
for IDactivite in listeActivites:
nom_activite = dictActivites[IDactivite]["nom"]
niveauActivite = self.AppendItem(self.root, nom_activite)
self.SetPyData(niveauActivite, IDactivite)
self.SetItemBold(niveauActivite, True)
# Branches Groupes
listeImpressionGroupes = []
listeGroupes = list(dictInscriptions[IDactivite].keys())
listeGroupes.sort()
for IDgroupe in listeGroupes:
nom_groupe = dictGroupes[IDgroupe]
niveauGroupe = self.AppendItem(niveauActivite, nom_groupe)
self.SetPyData(niveauGroupe, {
"type": "groupe",
"valeur": IDgroupe
})
self.SetItemBold(niveauGroupe, True)
# Branches Inscriptions
num = 1
listeImpressionIndividus = []
for dictInscription in dictInscriptions[IDactivite][IDgroupe]:
texteIndividu = u"%d. %s" % (
num, dictInscription["nom_individu"])
niveauIndividu = self.AppendItem(niveauGroupe,
texteIndividu)
self.SetPyData(
niveauIndividu, {
"type": "individu",
"nom_individu": dictInscription["nom_individu"],
"IDindividu": dictInscription["IDinscription"],
"IDfamille": dictInscription["IDfamille"]
})
texteDateSaisie = UTILS_Dates.DateComplete(
dictInscription["date_inscription"])
self.SetItemText(niveauIndividu, texteDateSaisie, 1)
nomCategorie = dictInscription["nomCategorie"]
self.SetItemText(niveauIndividu, nomCategorie, 2)
# Recherche si place dispo
nbre_places_dispo = self.RechercheSiPlaceDispo(
dictActivites[IDactivite], IDgroupe)
place_dispo = False
if nbre_places_dispo == None or nbre_places_dispo > 0:
place_dispo = True
# Modifie le nombre de places disponibles
if dictActivites[IDactivite][
"nbre_places_disponibles"] != None:
dictActivites[IDactivite][
"nbre_places_disponibles"] -= 1
if dictActivites[IDactivite]["groupes"][IDgroupe][
"nbre_places_disponibles"] != None:
dictActivites[IDactivite]["groupes"][IDgroupe][
"nbre_places_disponibles"] -= 1
else:
place_dispo = False
# Image
if place_dispo == True:
img = self.img_ok
else:
img = self.img_pasok
self.SetItemImage(niveauIndividu,
img,
which=wx.TreeItemIcon_Normal)
# Mémorisation pour impression
listeImpressionIndividus.append({
"placeDispo":
place_dispo,
"nomIndividu":
dictInscription["nom_individu"],
"num":
num,
"texteIndividu":
texteIndividu,
"texteDateSaisie":
texteDateSaisie,
"nomCategorie":
nomCategorie
})
num += 1
# Mémorisation pour impression
listeImpressionGroupes.append(
(nom_groupe, listeImpressionIndividus))
# Mémorisation pour impression
self.listeImpression.append((nom_activite, listeImpressionGroupes))
self.ExpandAllChildren(self.root)
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 GetDonneesImpression(self, listeLocations=[]):
""" Impression des locations """
dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None)
# Récupère les données de la facture
if len(listeLocations) == 0:
conditions = "()"
elif len(listeLocations) == 1:
conditions = "(%d)" % listeLocations[0]
else:
conditions = str(tuple(listeLocations))
DB = GestionDB.DB()
# Recherche les locations
req = """SELECT locations.IDlocation, locations.IDfamille, locations.IDproduit,
locations.observations, locations.date_debut, locations.date_fin,
produits.nom,
produits_categories.nom
FROM locations
LEFT JOIN produits ON produits.IDproduit = locations.IDproduit
LEFT JOIN produits_categories ON produits_categories.IDcategorie = produits.IDcategorie
WHERE IDlocation 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:
IDlocation = item[0]
IDfamille = item[1]
IDproduit = item[2]
observations = item[3]
date_debut = item[4]
date_fin = item[5]
if isinstance(date_debut, str) or isinstance(date_debut, unicode):
date_debut = datetime.datetime.strptime(
date_debut, "%Y-%m-%d %H:%M:%S")
date_debut_texte = datetime.datetime.strftime(
date_debut, "%d/%m/%Y")
heure_debut_texte = datetime.datetime.strftime(date_debut, "%Hh%M")
date_fin_texte = ""
heure_fin_texte = ""
if isinstance(date_fin, str) or isinstance(date_fin, unicode):
date_fin = datetime.datetime.strptime(date_fin,
"%Y-%m-%d %H:%M:%S")
date_fin_texte = datetime.datetime.strftime(
date_fin, "%d/%m/%Y")
heure_fin_texte = datetime.datetime.strftime(date_fin, "%Hh%M")
nomProduit = item[6]
nomCategorie = item[7]
# 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 = ""
# Facturation
# montant = 0.0
# ventilation = 0.0
# dateReglement = None
# modeReglement = None
#
# if dictFacturation.has_key(IDcotisation):
# 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,
"{IDLOCATION}":
str(IDlocation),
"{IDPRODUIT}":
str(IDproduit),
"{DATE_DEBUT}":
date_debut_texte,
"{DATE_FIN}":
date_fin_texte,
"{HEURE_DEBUT}":
heure_debut_texte,
"{HEURE_FIN}":
heure_fin_texte,
"{NOM_PRODUIT}":
nomProduit,
"{NOM_CATEGORIE}":
nomCategorie,
"{NOTES}":
observations,
"{IDFAMILLE}":
str(IDfamille),
"{FAMILLE_NOM}":
nomTitulaires,
"{FAMILLE_RUE}":
famille_rue,
"{FAMILLE_CP}":
famille_cp,
"{FAMILLE_VILLE}":
famille_ville,
# "{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),
"{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_locations.GetDonnees(
IDlocation):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee[
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
for dictReponse in self.Questionnaires_produits.GetDonnees(
IDproduit):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee[
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
dictDonnees[IDlocation] = dictDonnee
# Champs de fusion pour Email
dictChampsFusion[IDlocation] = {}
for key, valeur in dictDonnee.iteritems():
if key[0] == "{":
dictChampsFusion[IDlocation][key] = valeur
del dlgAttente
return dictDonnees, dictChampsFusion
def FormateDate(dateDD):
if dateDD == None :
return ""
else:
return UTILS_Dates.DateComplete(dateDD)
def GetDonneesImpression(self, listeRappels=[]):
""" Impression des factures """
dlgAttente = wx.BusyInfo(
_(u"Recherche des données de facturation..."), None)
try:
if 'phoenix' not in wx.PlatformInfo:
wx.Yield()
except:
pass
# Récupère les données de la facture
if len(listeRappels) == 0: conditions = "()"
elif len(listeRappels) == 1: conditions = "(%d)" % listeRappels[0]
else: conditions = str(tuple(listeRappels))
DB = GestionDB.DB()
req = """
SELECT
rappels.IDrappel, rappels.numero, rappels.IDcompte_payeur,
rappels.date_edition, rappels.activites, rappels.IDutilisateur,
rappels.IDtexte, rappels.date_reference, rappels.solde,
rappels.date_min, rappels.date_max, rappels.prestations,
comptes_payeurs.IDfamille, lots_rappels.nom
FROM rappels
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = rappels.IDcompte_payeur
LEFT JOIN lots_rappels ON lots_rappels.IDlot = rappels.IDlot
WHERE rappels.IDrappel IN %s
GROUP BY rappels.IDrappel
ORDER BY rappels.date_edition
;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
del dlgAttente
return False
# Création des dictRappels
dictRappels = {}
dictChampsFusion = {}
for IDrappel, numero, IDcompte_payeur, date_edition, activites, IDutilisateur, IDtexte, date_reference, solde, date_min, date_max, prestations, IDfamille, nomLot in listeDonnees:
if numero == None: numero = 0
date_edition = UTILS_Dates.DateEngEnDateDD(date_edition)
date_reference = UTILS_Dates.DateEngEnDateDD(date_reference)
if nomLot == None:
nomLot = ""
dictRappel = {
"{FAMILLE_NOM}":
self.dictTitulaires[IDfamille]["titulairesAvecCivilite"],
"nomSansCivilite":
self.dictTitulaires[IDfamille]["titulairesSansCivilite"],
"IDfamille":
IDfamille,
"{IDFAMILLE}":
IDfamille,
"{FAMILLE_RUE}":
self.dictTitulaires[IDfamille]["adresse"]["rue"],
"{FAMILLE_CP}":
self.dictTitulaires[IDfamille]["adresse"]["cp"],
"{FAMILLE_VILLE}":
self.dictTitulaires[IDfamille]["adresse"]["ville"],
"num_rappel":
numero,
"{NUM_RAPPEL}":
u"%06d" % numero,
"{NOM_LOT}":
nomLot,
"solde_num":
-solde,
"solde":
u"%.02f %s" % (solde, SYMBOLE),
"{SOLDE}":
u"%.02f %s" % (-solde, SYMBOLE),
"solde_lettres":
UTILS_Conversion.trad(solde, MONNAIE_SINGULIER,
MONNAIE_DIVISION),
"{SOLDE_LETTRES}":
UTILS_Conversion.trad(-solde, MONNAIE_SINGULIER,
MONNAIE_DIVISION),
"select":
True,
"num_codeBarre":
"%07d" % numero,
"numero":
_(u"Rappel n°%07d") % numero,
"{CODEBARRES_NUM_RAPPEL}":
"F%06d" % numero,
"date_min":
date_min,
"date_max":
date_max,
"{DATE_MIN}":
date_min,
"{DATE_MAX}":
date_max,
"{DATE_EDITION_LONG}":
UTILS_Dates.DateComplete(date_edition),
"{DATE_EDITION_COURT}":
UTILS_Dates.DateEngFr(str(date_edition)),
"{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"],
"titre":
self.dictTextesRappels[IDtexte]["titre"],
"IDtexte":
IDtexte,
}
dictRappel["texte"] = self.Fusion(IDtexte, dictRappel)
# Ajout les données de base familles
dictRappel.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
# Ajoute les réponses des questionnaires
for dictReponse in self.Questionnaires.GetDonnees(IDfamille):
dictRappel[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictRappel[
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
dictRappels[IDrappel] = dictRappel
# Champs de fusion pour Email
dictChampsFusion[IDrappel] = {}
dictChampsFusion[IDrappel]["{NUMERO_RAPPEL}"] = dictRappel[
"{NUM_RAPPEL}"]
dictChampsFusion[IDrappel]["{DATE_MIN}"] = UTILS_Dates.DateEngFr(
str(date_min))
dictChampsFusion[IDrappel]["{DATE_MAX}"] = UTILS_Dates.DateEngFr(
str(date_max))
dictChampsFusion[IDrappel][
"{DATE_EDITION_RAPPEL}"] = UTILS_Dates.DateEngFr(
str(date_edition))
dictChampsFusion[
IDrappel]["{DATE_REFERENCE}"] = UTILS_Dates.DateEngFr(
str(date_reference))
dictChampsFusion[IDrappel]["{SOLDE_CHIFFRES}"] = dictRappel[
"solde"]
dictChampsFusion[IDrappel]["{SOLDE_LETTRES}"] = dictRappel[
"{SOLDE_LETTRES}"]
del dlgAttente
return dictRappels, dictChampsFusion
def Remplissage(self):
dictConso, dictActivites, dictGroupes, dictIndividus = self.Importation(
)
# Mémorisation pour impression
self.listeImpression = []
# Branches DATE
listeDates = list(dictConso.keys())
listeDates.sort()
for date in listeDates:
niveauDate = self.AppendItem(self.root,
UTILS_Dates.DateComplete(date))
self.SetPyData(niveauDate, {"type": "date", "valeur": date})
self.SetItemBold(niveauDate, True)
self.SetItemBackgroundColour(niveauDate,
wx.Colour(*COULEUR_FOND_REGROUPEMENT))
# Branches Activités
listeActivites = list(dictConso[date].keys())
listeActivites.sort()
for IDactivite in listeActivites:
if len(listeActivites) > 1:
niveauActivite = self.AppendItem(niveauDate,
dictActivites[IDactivite])
self.SetPyData(niveauActivite, IDactivite)
self.SetItemBold(niveauActivite, True)
else:
niveauActivite = niveauDate
# Branches Groupe
listeImpressionGroupes = []
listeGroupes = list(dictConso[date][IDactivite].keys())
listeGroupes.sort()
for IDgroupe in listeGroupes:
nomGroupe = dictGroupes[IDgroupe]
niveauGroupe = self.AppendItem(niveauActivite, nomGroupe)
self.SetPyData(niveauGroupe, {
"type": "groupe",
"valeur": IDgroupe
})
self.SetItemBold(niveauGroupe, True)
# Branches Individus
listeImpressionIndividus = []
listeIndividus = []
for IDindividu, listeConso in dictConso[date][IDactivite][
IDgroupe].items():
listeIDconso = []
for dictConsoIndividu in listeConso:
listeIDconso.append(dictConsoIndividu["IDconso"])
IDconsoMin = min(listeIDconso)
listeIndividus.append((IDconsoMin, IDindividu))
listeIndividus.sort()
num = 1
for ordreIndividu, IDindividu in listeIndividus:
nomIndividu = dictIndividus[IDindividu]["nomIndividu"]
texteIndividu = u"%d. %s" % (num, nomIndividu)
IDfamille = dictIndividus[IDindividu]["IDfamille"]
niveauIndividu = self.AppendItem(
niveauGroupe, texteIndividu)
self.SetPyData(
niveauIndividu, {
"type": "individu",
"nomIndividu": nomIndividu,
"IDindividu": IDindividu,
"IDfamille": IDfamille
})
# Détail pour l'individu
texteUnites = u""
dateSaisie = None
placeDispo = True
for dictUnite in dictConso[date][IDactivite][IDgroupe][
IDindividu]:
IDunite = dictUnite["IDunite"]
date_saisie = dictUnite["date_saisie"]
texteUnites += dictUnite["abregeUnite"]
if dictUnite["quantite"] > 1:
texteUnites += u" (%d)" % dictUnite["quantite"]
texteUnites += u" + "
if dateSaisie == None or date_saisie < dateSaisie:
dateSaisie = date_saisie
texteUnites = texteUnites[:-3]
texteDateSaisie = UTILS_Dates.DateComplete(dateSaisie)
# Autres colonnes
self.SetItemText(niveauIndividu, texteUnites, 1)
self.SetItemText(niveauIndividu, texteDateSaisie, 2)
# Mémorisation pour impression
listeImpressionIndividus.append({
"placeDispo":
placeDispo,
"texteIndividu":
texteIndividu,
"texteUnites":
texteUnites,
"texteDateSaisie":
texteDateSaisie
})
num += 1
# Mémorisation pour impression
listeImpressionGroupes.append(
(nomGroupe, listeImpressionIndividus))
# Mémorisation pour impression
self.listeImpression.append(
(UTILS_Dates.DateComplete(date), listeImpressionGroupes))
self.ExpandAllChildren(self.root)
def MAJ(self, periode=None, IDrestaurateur=None):
self.periode = periode
self.IDrestaurateur = IDrestaurateur
# RAZ de la grid
if self.GetNumberRows() > 0:
self.DeleteRows(0, self.GetNumberRows())
if self.GetNumberCols() > 0:
self.DeleteCols(0, self.GetNumberCols())
self.ClearGrid()
if IDrestaurateur == None:
return False
# Importation
self.dictDonnees = self.Importation()
if len(self.dictDonnees) == 0:
return
# Création des colonnes
nbreColonnes = len(self.dictDonnees["categories"])
self.AppendCols(nbreColonnes)
numColonne = 0
for dictCategorie in self.dictDonnees["categories"]:
nomColonne = dictCategorie["nom"]
renderer = LabelColonneRenderer()
self.SetColLabelRenderer(numColonne, renderer)
self.SetColLabelValue(numColonne, nomColonne)
self.SetColSize(numColonne, 300)
numColonne += 1
# Création des lignes
nbreLignes = len(self.dictDonnees["dates"])
self.AppendRows(nbreLignes)
numLigne = 0
for date in self.dictDonnees["dates"]:
if type(date) == datetime.date:
label = UTILS_Dates.DateComplete(date)
else:
label = date
self.SetRowLabelValue(numLigne, label)
self.SetRowSize(numLigne, 40)
numLigne += 1
# Création des cases
self.dictCases = {}
numLigne = 0
for date in self.dictDonnees["dates"]:
numColonne = 0
for dictCategorie in self.dictDonnees["categories"]:
IDcategorie = dictCategorie["IDcategorie"]
# Recherche si une valeur existe
if self.dictDonnees["menus"].has_key(
date) and self.dictDonnees["menus"][date].has_key(
IDcategorie):
dictMenu = self.dictDonnees["menus"][date][IDcategorie]
else:
dictMenu = None
# Création de la case
case = Case(self,
numLigne=numLigne,
numColonne=numColonne,
IDcategorie=IDcategorie,
date=date,
dictMenu=dictMenu)
self.dictCases[(numLigne, numColonne)] = case
numColonne += 1
numLigne += 1
def GetDonneesImpression(self, tracks=[], dictOptions={}):
""" Impression des factures """
dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None)
try:
if 'phoenix' not in wx.PlatformInfo:
wx.Yield()
except:
pass
dictDonnees = {}
dictChampsFusion = {}
for track in tracks:
IDfamille = track.IDfamille
IDcompte_payeur = track.IDcompte_payeur
# Regroupement des enfants
dictEnfants = {}
for prestation in track.listePrestations:
IDindividu = prestation["IDindividu"]
if (IDindividu in dictEnfants) == False:
if prestation["prenom"] == None:
prenom = ""
else:
prenom = prestation["prenom"]
if prestation["date_naiss"] == None:
date_naiss = ""
else:
date_naiss = UTILS_Dates.DateEngFr(
prestation["date_naiss"])
genre = ""
if prestation["IDcivilite"] != None:
sexe = DICT_CIVILITES[prestation["IDcivilite"]]["sexe"]
if sexe == "F":
genre = "e"
nomComplet = u"%s %s" % (prestation["nom"], prenom)
dictEnfants[IDindividu] = {
"nomComplet": nomComplet,
"nom": prestation["nom"],
"prenom": prenom,
"date_naiss": date_naiss,
"genre": genre,
"regle": FloatToDecimal(0.0)
}
dictEnfants[IDindividu]["regle"] += prestation["regle"]
listeIndividus = []
for IDindividu, dictTemp in dictEnfants.items():
listeIndividus.append((dictTemp["nomComplet"], dictTemp))
listeIndividus.sort()
# Formatage du texte d'intro
textIntro = ""
if dictOptions["intro"] != None:
textIntro = dictOptions["intro"]
textIntro = textIntro.replace(
"{GENRE}", dictOptions["signataire"]["genre"])
textIntro = textIntro.replace("{NOM}",
dictOptions["signataire"]["nom"])
textIntro = textIntro.replace(
"{FONCTION}", dictOptions["signataire"]["fonction"])
textIntro = textIntro.replace(
"{DATE_DEBUT}",
UTILS_Dates.DateEngFr(str(dictOptions["date_debut"])))
textIntro = textIntro.replace(
"{DATE_FIN}",
UTILS_Dates.DateEngFr(str(dictOptions["date_fin"])))
# Mémorisation des données
dictDonnee = {
"{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"],
"{IDFAMILLE}":
str(track.IDfamille),
"{IDCOMPTE_PAYEUR}":
str(track.IDcompte_payeur),
"{FAMILLE_NOM}":
track.nomsTitulairesSansCivilite,
"{FAMILLE_RUE}":
track.rue_resid,
"{FAMILLE_CP}":
track.cp_resid,
"{FAMILLE_VILLE}":
track.ville_resid,
"{DATE_EDITION_COURT}":
UTILS_Dates.DateDDEnFr(datetime.date.today()),
"{DATE_EDITION_LONG}":
UTILS_Dates.DateComplete(datetime.date.today()),
"{DATE_DEBUT}":
UTILS_Dates.DateDDEnFr(dictOptions["date_debut"]),
"{DATE_FIN}":
UTILS_Dates.DateDDEnFr(dictOptions["date_fin"]),
"{MONTANT_FACTURE}":
u"%.2f %s" % (track.montant_total, SYMBOLE),
"{MONTANT_REGLE}":
u"%.2f %s" % (track.montant_regle, SYMBOLE),
"{MONTANT_IMPAYE}":
u"%.2f %s" % (track.montant_impaye, SYMBOLE),
"{MONTANT_FACTURE_LETTRES}":
UTILS_Conversion.trad(track.montant_total, MONNAIE_SINGULIER,
MONNAIE_DIVISION),
"{MONTANT_REGLE_LETTRES}":
UTILS_Conversion.trad(track.montant_regle, MONNAIE_SINGULIER,
MONNAIE_DIVISION),
"{MONTANT_IMPAYE_LETTRES}":
UTILS_Conversion.trad(track.montant_impaye, MONNAIE_SINGULIER,
MONNAIE_DIVISION),
"{INTRO}":
textIntro,
"TXT_ENFANT_1":
"",
"TXT_ENFANT_2":
"",
"TXT_ENFANT_3":
"",
"TXT_ENFANT_4":
"",
"TXT_ENFANT_5":
"",
"TXT_ENFANT_6":
"",
"individus":
listeIndividus,
}
# Ajoute les infos de base familles
dictDonnee.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
# Insertion des enfants
index = 1
for nomCompletIndividu, dictIndividu in listeIndividus:
dictDonnee["TXT_ENFANT_%d" %
index] = _(u"%.2f %s pour %s né%s le %s") % (
dictIndividu["regle"], SYMBOLE,
nomCompletIndividu, dictIndividu["genre"],
dictIndividu["date_naiss"])
index += 1
# 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[IDcompte_payeur] = dictDonnee
# Champs de fusion pour Email
dictChampsFusion[IDcompte_payeur] = {}
for key, valeur in dictDonnee.items():
if key[0] == "{":
dictChampsFusion[IDcompte_payeur][key] = valeur
del dlgAttente
return dictDonnees, dictChampsFusion
def MAJ(self, date_debut=None, date_fin=None):
self.date_debut = date_debut
self.date_fin = date_fin
# Mémorisation des données existantes
try:
for case in self.dictCases.values():
if case.ouvert == True:
self.dictValeursAnterieures[(
case.date, case.IDcolonne)] = case.GetValeur()
except:
pass
# Importation
self.dictDonnees = self.Importation()
# RAZ de la grid
if self.GetNumberRows() > 0:
self.DeleteRows(0, self.GetNumberRows())
if self.GetNumberCols() > 0:
self.DeleteCols(0, self.GetNumberCols())
self.ClearGrid()
if len(self.dictDonnees) == 0:
return
# Création des colonnes
nbreColonnes = len(self.dictDonnees["liste_colonnes"])
self.AppendCols(nbreColonnes)
numColonne = 0
for dictColonne in self.dictDonnees["liste_colonnes"]:
nomColonne = dictColonne["nom_colonne"]
renderer = LabelColonneRenderer()
self.SetColLabelRenderer(numColonne, renderer)
self.SetColLabelValue(numColonne, nomColonne)
self.SetColSize(numColonne, dictColonne["largeur"])
numColonne += 1
# Création des lignes
nbreLignes = len(self.dictDonnees["liste_dates"])
self.AppendRows(nbreLignes)
numLigne = 0
for date in self.dictDonnees["liste_dates"]:
if type(date) == datetime.date:
label = UTILS_Dates.DateComplete(date)
else:
label = date
self.SetRowLabelValue(numLigne, label)
self.SetRowSize(numLigne, 40)
numLigne += 1
# Création des cases
self.dictCases = {}
numLigne = 0
for date in self.dictDonnees["liste_dates"]:
numColonne = 0
for dictColonne in self.dictDonnees["liste_colonnes"]:
# Colonne de type NUMERIQUE
if type(
date
) == datetime.date: #and dictColonne["categorie"] in ("numerique_avec_suggestion", "numerique_sans_suggestion", "texte_libre") :
ouvert = True
suggestion = None
valeur = None
IDvaleur = None
# Recherche valeur dans DB
try:
valeur = self.dictDonnees["valeurs"][date][
dictColonne["IDcolonne"]]["valeur"]
IDvaleur = self.dictDonnees["valeurs"][date][
dictColonne["IDcolonne"]]["IDvaleur"]
except:
pass
# Récupération de la valeur avant MAJ
if self.dictValeursAnterieures.has_key(
(date, dictColonne["IDcolonne"])):
valeur = self.dictValeursAnterieures[(
date, dictColonne["IDcolonne"])]
# Recherche suggestion
if dictColonne["categorie"] == "numerique_avec_suggestion":
suggestion = 0
for (IDgroupe,
IDunite) in dictColonne["parametres"]["unites"]:
# Recherche si unités ouvertes
if self.RechercheOuverture(date, IDgroupe,
IDunite) == False:
ouvert = False
# Recherche le nombre de conso
try:
suggestion += self.dictDonnees["dict_conso"][
date][IDgroupe][IDunite]
except:
pass
# Recherche information
if dictColonne["categorie"] == "texte_infos":
ouvert = False
liste_infos = []
if self.dictDonnees["dict_dates"].has_key(date):
for IDindividu in self.dictDonnees["dict_dates"][
date]:
valide = True
if dictColonne["parametres"].has_key(
"groupes"):
valide = False
groupes = dictColonne["parametres"][
"groupes"]
for IDgroupe in groupes:
if IDgroupe in self.dictDonnees[
"dict_dates"][date][
IDindividu]:
valide = True
if valide == True:
# Recherche infos médicales
if dictColonne["parametres"].has_key(
"infos_medicales"):
if self.dictDonnees[
"infos_medicales"].has_key(
IDindividu):
for dictInfos in self.dictDonnees[
"infos_medicales"][
IDindividu]:
texte = u"<b>%s %s</b> : %s (%s)" % (
dictInfos[
"individu_prenom"],
dictInfos["individu_nom"],
dictInfos["intitule"],
dictInfos["description"])
liste_infos.append(texte)
# Recherche messages
if dictColonne["parametres"].has_key(
"messages_individuels"):
if self.dictDonnees[
"messages"].has_key(
IDindividu):
for dictMessages in self.dictDonnees[
"messages"][IDindividu]:
texte = u"<b>%s %s</b> : %s" % (
dictMessages[
"individu_prenom"],
dictMessages[
"individu_nom"],
dictMessages["texte"])
liste_infos.append(texte)
liste_infos.sort()
valeur = u"\n".join(liste_infos)
# Colonne de type TOTAL
if dictColonne["categorie"] == "numerique_total":
ouvert = False
# Création de la case
case = Case(self,
numLigne=numLigne,
numColonne=numColonne,
IDcolonne=dictColonne["IDcolonne"],
date=date,
categorieColonne=dictColonne["categorie"],
ouvert=ouvert,
suggestion=suggestion,
valeur=valeur,
IDvaleur=IDvaleur)
self.dictCases[(numLigne, numColonne)] = case
# Ligne de total
if type(date) in (str, unicode):
# Création de la case
case = Case(self,
numLigne=numLigne,
numColonne=numColonne,
IDcolonne=dictColonne["IDcolonne"],
date=date,
categorieColonne=dictColonne["categorie"],
ouvert=False,
valeur=None)
self.dictCases[(numLigne, numColonne)] = case
numColonne += 1
numLigne += 1
def GetDonneesImpression(self, listeInscriptions=[]):
""" Impression des inscriptions """
dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None)
# Récupère les données de la facture
if len(listeInscriptions) == 0:
conditions = "()"
elif len(listeInscriptions) == 1:
conditions = "(%d)" % listeInscriptions[0]
else:
conditions = str(tuple(listeInscriptions))
# Récupération des informations sur l'inscription
dictChamps = {
"inscriptions.IDinscription": "IDINSCRIPTION",
"inscriptions.date_inscription": "DATE_INSCRIPTION",
"inscriptions.date_desinscription": "EST_PARTI",
"activites.IDactivite": "IDACTIVITE",
"activites.nom": "ACTIVITE_NOM_LONG",
"activites.abrege": "ACTIVITE_NOM_COURT",
"groupes.IDgroupe": "IDGROUPE",
"groupes.nom": "GROUPE_NOM_LONG",
"groupes.abrege": "GROUPE_NOM_COURT",
"categories_tarifs.IDcategorie_tarif": "IDCATEGORIETARIF",
"categories_tarifs.nom": "NOM_CATEGORIE_TARIF",
"individus.IDindividu": "IDINDIVIDU",
"individus.IDcivilite": "IDCIVILITE",
"individus.nom": "INDIVIDU_NOM",
"individus.prenom": "INDIVIDU_PRENOM",
"individus.date_naiss": "INDIVIDU_DATE_NAISS",
"individus.cp_naiss": "INDIVIDU_CP_NAISS",
"individus.ville_naiss": "INDIVIDU_VILLE_NAISS",
"individus.adresse_auto": "INDIVIDU_ADRESSE_AUTO",
"individus.rue_resid": "INDIVIDU_RUE",
"individus.cp_resid": "INDIVIDU_CP",
"individus.ville_resid": "INDIVIDU_VILLE",
"individus.profession": "INDIVIDU_PROFESSION",
"individus.employeur": "INDIVIDU_EMPLOYEUR",
"individus.tel_domicile": "INDIVIDU_TEL_DOMICILE",
"individus.tel_mobile": "INDIVIDU_TEL_MOBILE",
"individus.tel_fax": "INDIVIDU_FAX",
"individus.mail": "INDIVIDU_EMAIL",
"individus.travail_tel": "INDIVIDU_TEL_PRO",
"individus.travail_fax": "INDIVIDU_FAX_PRO",
"individus.travail_mail": "INDIVIDU_EMAIL_PRO",
"familles.IDfamille": "IDFAMILLE",
"caisses.nom": "FAMILLE_CAISSE",
"regimes.nom": "FAMILLE_REGIME",
"familles.num_allocataire": "FAMILLE_NUMALLOC",
}
listeChamps = dictChamps.keys()
DB = GestionDB.DB()
req = """SELECT %s
FROM inscriptions
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
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
LEFT JOIN familles ON familles.IDfamille = inscriptions.IDfamille
LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse
LEFT JOIN regimes ON regimes.IDregime = caisses.IDregime
WHERE IDinscription IN %s
""" % (", ".join(listeChamps), conditions)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
if len(listeDonnees) == 0:
del dlgAttente
return False
dictDonnees = {}
dictChampsFusion = {}
for item in listeDonnees:
dictDonnee = {}
index = 0
for nomChamp in listeChamps:
code = dictChamps[nomChamp]
valeur = item[index]
dictDonnee["{%s}" % code] = valeur
index += 1
IDinscription = dictDonnee["{IDINSCRIPTION}"]
IDfamille = dictDonnee["{IDFAMILLE}"]
IDindividu = dictDonnee["{IDINDIVIDU}"]
# 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.update({
"select":
True,
"{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()),
})
# Formatage spécial
dictDonnee["{DATE_INSCRIPTION}"] = UTILS_Dates.DateEngFr(
dictDonnee["{DATE_INSCRIPTION}"])
dictDonnee["{INDIVIDU_DATE_NAISS}"] = UTILS_Dates.DateEngFr(
dictDonnee["{INDIVIDU_DATE_NAISS}"])
# Autres données
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_individus.GetDonnees(
IDindividu):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee[
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
for dictReponse in self.Questionnaires_inscriptions.GetDonnees(
IDinscription):
dictDonnee[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictDonnee[
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
dictDonnees[IDinscription] = dictDonnee
# Champs de fusion pour Email
dictChampsFusion[IDinscription] = {}
for key, valeur in dictDonnee.iteritems():
if key[0] == "{":
dictChampsFusion[IDinscription][key] = valeur
del dlgAttente
return dictDonnees, dictChampsFusion
def FormateDateLong(dateDD):
return UTILS_Dates.DateComplete(dateDD)
def __init__(self,
parent,
grid=None,
IDactivite=None,
date=None,
IDunite=None,
IDgroupe=None,
nomGroupe=None,
liste_evenements=[]):
wx.Dialog.__init__(self,
parent,
-1,
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
| wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX)
self.parent = parent
intro = _(
u"Vous pouvez ici saisir, modifier ou supprimer des évènements.")
titre = _(u"Evènements")
if date != None and nomGroupe != None:
titre = _(u"Evènements du %s (%s)") % (
UTILS_Dates.DateComplete(date), nomGroupe)
self.SetTitle(titre)
self.ctrl_bandeau = CTRL_Bandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteurHtml=30,
nomImage="Images/32x32/Evenement.png")
self.ctrl_listview = OL_Evenements.ListView(
self,
id=-1,
grid=grid,
IDactivite=IDactivite,
date=date,
IDunite=IDunite,
IDgroupe=IDgroupe,
liste_evenements=liste_evenements,
style=wx.LC_REPORT | wx.SUNKEN_BORDER | wx.LC_SINGLE_SEL
| wx.LC_HRULES | wx.LC_VRULES)
self.ctrl_listview.MAJ()
self.bouton_ajouter = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ajouter.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_modifier = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Modifier.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_supprimer = wx.BitmapButton(
self, -1,
wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Supprimer.png"),
wx.BITMAP_TYPE_ANY))
self.bouton_aide = CTRL_Bouton_image.CTRL(
self, texte=_(u"Aide"), cheminImage="Images/32x32/Aide.png")
self.bouton_ok = CTRL_Bouton_image.CTRL(
self, texte=_(u"Ok"), cheminImage="Images/32x32/Valider.png")
self.bouton_annuler = CTRL_Bouton_image.CTRL(
self, texte=_(u"Annuler"), cheminImage="Images/32x32/Annuler.png")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON, self.ctrl_listview.Ajouter,
self.bouton_ajouter)
self.Bind(wx.EVT_BUTTON, self.ctrl_listview.Modifier,
self.bouton_modifier)
self.Bind(wx.EVT_BUTTON, self.ctrl_listview.Supprimer,
self.bouton_supprimer)
self.Bind(wx.EVT_BUTTON, self.OnBoutonOk, self.bouton_ok)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAnnuler, self.bouton_annuler)
self.Bind(wx.EVT_BUTTON, self.OnBoutonAide, self.bouton_aide)
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 GetDonnees(
self,
listeRappels=[],
liste_activites=[],
listeExceptionsComptes=[],
date_reference=None,
date_edition=None,
prestations=["consommation", "cotisation", "location", "autre"]):
""" Recherche des rappels à créer """
# Création des conditions SQL
if len(liste_activites) == 0: conditionActivites = "()"
elif len(liste_activites) == 1:
conditionActivites = "(%d)" % liste_activites[0]
else:
conditionActivites = str(tuple(liste_activites))
if len(listeExceptionsComptes) == 0: conditionComptes = "()"
elif len(listeExceptionsComptes) == 1:
conditionComptes = "(%d)" % listeExceptionsComptes[0]
else:
conditionComptes = str(tuple(listeExceptionsComptes))
if len(prestations) == 1:
conditionPrestations = " prestations.categorie='%s'" % prestations[
0]
else:
conditionPrestations = " prestations.categorie IN %s" % str(
tuple(prestations)).replace("u'", "'")
DB = GestionDB.DB()
# Recherche des prestations de la période
req = """SELECT prestations.IDcompte_payeur, prestations.IDfamille,
MIN(prestations.date),
MAX(prestations.date),
SUM(prestations.montant)
FROM prestations
WHERE (prestations.IDactivite IN %s OR prestations.IDactivite IS NULL)
AND prestations.date <= '%s' AND prestations.IDcompte_payeur NOT IN %s AND %s
GROUP BY prestations.IDcompte_payeur
;""" % (conditionActivites, str(date_reference), conditionComptes,
conditionPrestations)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
# Récupération de la ventilation
req = """SELECT prestations.IDcompte_payeur, SUM(ventilation.montant)
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
WHERE (prestations.IDactivite IN %s OR prestations.IDactivite IS NULL)
AND prestations.date <= '%s' AND prestations.IDcompte_payeur NOT IN %s
GROUP BY prestations.IDcompte_payeur
;""" % (conditionActivites, str(date_reference), conditionComptes)
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDcompte_payeur, totalVentilation in listeVentilation:
dictVentilation[IDcompte_payeur] = totalVentilation
DB.Close()
# Analyse et regroupement des données
dictComptes = {}
for IDcompte_payeur, IDfamille, date_min, date_max, montant in listePrestations:
if IDcompte_payeur in dictVentilation:
montant_ventilation = dictVentilation[IDcompte_payeur]
else:
montant_ventilation = 0.0
# Regroupement par compte payeur
if montant_ventilation == None:
montant_ventilation = 0.0
# conversion en decimal
if montant == None:
montant = 0.0
montant = decimal.Decimal(str(montant))
montant_ventilation = decimal.Decimal(str(montant_ventilation))
numero = 0
solde = montant_ventilation - montant
if solde < decimal.Decimal("0.0"):
dictComptes[IDcompte_payeur] = {
"{FAMILLE_NOM}":
self.dictTitulaires[IDfamille]["titulairesAvecCivilite"],
"nomSansCivilite":
self.dictTitulaires[IDfamille]["titulairesSansCivilite"],
"IDfamille":
IDfamille,
"{IDFAMILLE}":
IDfamille,
"{FAMILLE_RUE}":
self.dictTitulaires[IDfamille]["adresse"]["rue"],
"{FAMILLE_CP}":
self.dictTitulaires[IDfamille]["adresse"]["cp"],
"{FAMILLE_VILLE}":
self.dictTitulaires[IDfamille]["adresse"]["ville"],
"num_rappel":
numero,
"{NUM_RAPPEL}":
u"%06d" % numero,
"{NOM_LOT}":
"",
"solde_num":
-solde,
"solde":
u"%.02f %s" % (-solde, SYMBOLE),
"{SOLDE}":
u"%.02f %s" % (-solde, SYMBOLE),
"solde_lettres":
UTILS_Conversion.trad(-solde, MONNAIE_SINGULIER,
MONNAIE_DIVISION),
"{SOLDE_LETTRES}":
UTILS_Conversion.trad(-solde, MONNAIE_SINGULIER,
MONNAIE_DIVISION),
"select":
True,
"num_codeBarre":
"%07d" % numero,
"numero":
_(u"Rappel n°%07d") % numero,
"{CODEBARRES_NUM_RAPPEL}":
"F%06d" % numero,
"date_min":
UTILS_Dates.DateEngEnDateDD(date_min),
"date_max":
UTILS_Dates.DateEngEnDateDD(date_max),
"{DATE_MIN}":
UTILS_Dates.DateEngEnDateDD(date_min),
"{DATE_MAX}":
UTILS_Dates.DateEngEnDateDD(date_max),
"{DATE_EDITION_LONG}":
UTILS_Dates.DateComplete(date_edition),
"{DATE_EDITION_COURT}":
UTILS_Dates.DateEngFr(str(date_edition)),
"{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"],
}
# Ajout les données de base familles
dictComptes[IDcompte_payeur].update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
# Ajoute les réponses des questionnaires
for dictReponse in self.Questionnaires.GetDonnees(IDfamille):
dictComptes[IDcompte_payeur][
dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictComptes[IDcompte_payeur][
"{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
return dictComptes
