def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur("couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
liste_Colonnes = [
ColumnDefn(_(u"ID"), "left", 0, "IDfamille", typeDonnee="entier"),
ColumnDefn(_(u"Famille"), 'left', 250, "nomTitulaires", typeDonnee="texte"),
ColumnDefn(_(u"Rue"), "left", 160, "rue", typeDonnee="texte"),
ColumnDefn(_(u"C.P."), "left", 45, "cp", typeDonnee="texte"),
ColumnDefn(_(u"Ville"), "left", 120, "ville", typeDonnee="texte"),
ColumnDefn(_(u"Secteur"), "left", 100, "secteur", typeDonnee="texte"),
ColumnDefn(_(u"Régime"), "left", 130, "regime", typeDonnee="texte"),
ColumnDefn(_(u"Caisse"), "left", 130, "caisse", typeDonnee="texte"),
ColumnDefn(_(u"Numéro Alloc."), "left", 120, "numAlloc", typeDonnee="texte"),
]
# Insertion des champs infos de base individus
listeChamps = self.infosIndividus.GetNomsChampsPresents(mode="famille")
for nomChamp in listeChamps :
typeDonnee = UTILS_Infos_individus.GetTypeChamp(nomChamp)
liste_Colonnes.append(ColumnDefn(nomChamp, "left", 100, nomChamp, typeDonnee=typeDonnee, visible=False))
self.SetColumns2(colonnes=liste_Colonnes, nomListe="OL_Liste_familles")
self.SetEmptyListMsg(_(u"Aucune famille"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, face="Tekton"))
if len(self.columns) > 1 :
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
def MAJ(self,
date_debut=None,
date_fin=None,
IDactivite=None,
listeGroupes=[],
detail_groupes=False,
affichage_donnees="quantite",
affichage_regroupement="jour",
affichage_mode="reservation",
affichage_etat=["reservation", "present"],
labelParametres=u""):
# Chargement des informations individuelles
if self.date_debut != date_debut:
self.infosIndividus = UTILS_Infos_individus.Informations(
date_reference=date_debut,
qf=True,
inscriptions=True,
messages=False,
infosMedicales=False,
cotisationsManquantes=False,
piecesManquantes=False,
questionnaires=True,
scolarite=True)
self.dictInfosIndividus = self.infosIndividus.GetDictValeurs(
mode="individu", ID=None, formatChamp=False)
self.dictInfosFamilles = self.infosIndividus.GetDictValeurs(
mode="famille", ID=None, formatChamp=False)
# Mémorisation des paramètres
self.date_debut = date_debut
self.date_fin = date_fin
self.IDactivite = IDactivite
self.listeGroupes = listeGroupes
self.detail_groupes = detail_groupes
self.affichage_donnees = affichage_donnees
self.affichage_regroupement = affichage_regroupement
self.affichage_mode = affichage_mode
self.affichage_etat = affichage_etat
self.labelParametres = labelParametres
# init grid
try:
dlgAttente = wx.BusyInfo(
_(u"Veuillez patienter durant la recherche des données..."),
None)
if 'phoenix' not in wx.PlatformInfo:
wx.Yield()
self.InitGrid()
del dlgAttente
except Exception as err:
del dlgAttente
traceback.print_exc(file=sys.stdout)
dlg = wx.MessageDialog(
self,
_(u"Désolé, le problème suivant a été rencontré dans la recherche des données de la synthèse des consommations : \n\n%s"
) % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
def InitModel(self):
self.donnees = self.GetTracks()
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
for track in self.donnees:
self.infosIndividus.SetAsAttributs(parent=track,
mode="individu",
ID=track.IDindividu)
def InitObjectListView(self):
# Création du imageList
for categorie, civilites in Civilites.LISTE_CIVILITES :
for IDcivilite, CiviliteLong, CiviliteAbrege, nomImage, genre in civilites :
indexImg = self.AddNamedImages(nomImage, wx.Bitmap(Chemins.GetStaticPath("Images/16x16/%s" % nomImage), wx.BITMAP_TYPE_PNG))
def GetImageCivilite(track):
return track.nomImage
def FormateDate(dateStr):
if dateStr == "" or dateStr == None : return ""
date = str(datetime.date(year=int(dateStr[:4]), month=int(dateStr[5:7]), day=int(dateStr[8:10])))
text = str(date[8:10]) + "/" + str(date[5:7]) + "/" + str(date[:4])
return text
def FormateAge(age):
if age == None : return ""
return _(u"%d ans") % age
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur("couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
liste_Colonnes = [
ColumnDefn(u"", "left", 22, "IDindividu", typeDonnee="entier", imageGetter=GetImageCivilite),
ColumnDefn(_(u"Nom"), 'left', 100, "nom", typeDonnee="texte"),
ColumnDefn(_(u"Prénom"), "left", 100, "prenom", typeDonnee="texte"),
ColumnDefn(_(u"Date naiss."), "left", 72, "date_naiss", typeDonnee="date", stringConverter=FormateDate),
ColumnDefn(_(u"Genre"), "left", 50, "genre", typeDonnee="texte"),
ColumnDefn(_(u"Age"), "left", 50, "age", typeDonnee="entier", stringConverter=FormateAge),
ColumnDefn(_(u"Rue"), "left", 150, "rue_resid", typeDonnee="texte"),
ColumnDefn(_(u"C.P."), "left", 50, "cp_resid", typeDonnee="texte"),
ColumnDefn(_(u"Ville"), "left", 120, "ville_resid", typeDonnee="texte"),
ColumnDefn(_(u"Tél. domicile"), "left", 100, "tel_domicile", typeDonnee="texte"),
ColumnDefn(_(u"Tél. mobile"), "left", 100, "tel_mobile", typeDonnee="texte"),
ColumnDefn(_(u"Email"), "left", 150, "mail", typeDonnee="texte"),
]
# Insertion des champs infos de base individus
listeChamps = self.infosIndividus.GetNomsChampsPresents(mode="individu")
for nomChamp in listeChamps :
typeDonnee = UTILS_Infos_individus.GetTypeChamp(nomChamp)
liste_Colonnes.append(ColumnDefn(nomChamp, "left", 100, nomChamp, typeDonnee=typeDonnee, visible=False))
self.SetColumns2(colonnes=liste_Colonnes, nomListe="OL_Liste_individus")
self.SetEmptyListMsg(_(u"Aucun individu"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
if len(self.columns) > 1 :
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
def __init__(self):
""" Récupération de toutes les données de base """
DB = GestionDB.DB()
# Récupération des infos sur l'organisme
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
self.dictOrganisme["nom"] = nom
self.dictOrganisme["rue"] = rue
self.dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
self.dictOrganisme["ville"] = ville
self.dictOrganisme["tel"] = tel
self.dictOrganisme["fax"] = fax
self.dictOrganisme["mail"] = mail
self.dictOrganisme["site"] = site
self.dictOrganisme["num_agrement"] = num_agrement
self.dictOrganisme["num_siret"] = num_siret
self.dictOrganisme["code_ape"] = code_ape
# Récupération des textes de rappels
req = """SELECT IDtexte, titre, texte_pdf
FROM textes_rappels;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictTextesRappels = {}
for IDtexte, titre, texte_pdf in listeDonnees:
self.dictTextesRappels[IDtexte] = {
"titre": titre,
"texte_pdf": texte_pdf
}
DB.Close()
# Get noms Titulaires
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# Récupération des questionnaires
self.Questionnaires = UTILS_Questionnaires.ChampsEtReponses(
type="famille")
# Récupération des infos de base familles
self.infosIndividus = UTILS_Infos_individus.Informations()
def InitModel(self):
# Récupération des questions
self.LISTE_QUESTIONS = self.UtilsQuestionnaires.GetQuestions(type=self.categorie[:-1])
# Récupération des questionnaires
self.DICT_QUESTIONNAIRES = self.UtilsQuestionnaires.GetReponses(type=self.categorie[:-1])
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
# Récupération des tracks
if self.categorie == "individus" :
self.donnees = GetListeIndividus(self, self.listeActivites, self.presents, self.IDindividu, self.infosIndividus)
else:
self.donnees = GetListeFamilles(self, self.listeActivites, self.presents, self.IDfamille, self.infosIndividus)
def InitModel(self):
# Initialisation des questionnaires
categorie = "inscription"
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(
type=categorie)
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(
type=categorie)
# Importation des données
self.donnees = self.GetTracks()
# Infos individus
self.infosIndividus = UTILS_Infos_individus.Informations()
for track in self.donnees:
self.infosIndividus.SetAsAttributs(parent=track,
mode="individu",
ID=track.IDindividu)
for track in self.donnees:
self.infosIndividus.SetAsAttributs(parent=track,
mode="famille",
ID=track.IDfamille)
def CreationPDF(self,
nomDoc=FonctionsPerso.GenerationNomDoc(
"RECU_REGLEMENT", "pdf"),
afficherDoc=True):
dictChampsFusion = {}
# Récupération des valeurs de base
dictDonnees = DICT_DONNEES
# Récupération des infos sur l'organisme
DB = GestionDB.DB()
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
dictOrganisme["nom"] = nom
dictOrganisme["rue"] = rue
dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
dictOrganisme["ville"] = ville
dictOrganisme["tel"] = tel
dictOrganisme["fax"] = fax
dictOrganisme["mail"] = mail
dictOrganisme["site"] = site
dictOrganisme["num_agrement"] = num_agrement
dictOrganisme["num_siret"] = num_siret
dictOrganisme["code_ape"] = code_ape
DB.Close()
date_edition = dictDonnees["date"]
try:
date_editionDD = DateEngEnDateDD(DateFrEng(date_edition))
except:
date_editionDD = ""
# Insertion des données de base dans le dictValeurs
IDfamille = self.IDfamille
dictValeurs = {
"IDfamille": self.IDfamille,
"{IDFAMILLE}": str(self.IDfamille),
"num_recu": dictDonnees["numero"],
"{DATE_EDITION}": dictDonnees["date"],
"{LIEU_EDITION}": dictDonnees["lieu"],
"{DESTINATAIRE_NOM}": dictDonnees["nom"],
"{DESTINATAIRE_RUE}": dictDonnees["rue"],
"{DESTINATAIRE_VILLE}": dictDonnees["ville"],
"{NUM_RECU}": dictDonnees["numero"],
"{DATE_EDITION}": date_edition,
"{DATE_EDITION_LONG}": DateComplete(date_editionDD),
"{DATE_EDITION_COURT}": date_edition,
"{ORGANISATEUR_NOM}": dictOrganisme["nom"],
"{ORGANISATEUR_RUE}": dictOrganisme["rue"],
"{ORGANISATEUR_CP}": dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}": dictOrganisme["ville"],
"{ORGANISATEUR_TEL}": dictOrganisme["tel"],
"{ORGANISATEUR_FAX}": dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}": dictOrganisme["mail"],
"{ORGANISATEUR_SITE}": dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}": dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}": dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}": dictOrganisme["code_ape"],
}
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
dictValeurs.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
# Récupération des questionnaires
Questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="famille")
for dictReponse in Questionnaires.GetDonnees(IDfamille):
dictValeurs[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictValeurs["{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
# Récupération du signataire
infosSignataire = self.ctrl_signataire.GetInfos()
if infosSignataire == None:
dlg = wx.MessageDialog(
self, _(u"Vous n'avez sélectionné aucun signataire !"),
_(u"Annulation"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
nomSignataire = infosSignataire["nom"]
fonctionSignataire = infosSignataire["fonction"]
sexeSignataire = infosSignataire["sexe"]
if sexeSignataire == "H":
genreSignataire = u""
else:
genreSignataire = u"e"
# Récupération et transformation du texte d'intro
if self.ctrl_intro.GetValue() == True:
textIntro = self.ctrl_texte_intro.GetValue()
textIntro = textIntro.replace("{GENRE}", genreSignataire)
textIntro = textIntro.replace("{NOM}", nomSignataire)
textIntro = textIntro.replace("{FONCTION}", fonctionSignataire)
textIntro = textIntro.replace("{FAMILLE}", dictDonnees["nom"])
textIntro = textIntro.replace(
"{MONTANT}",
u"<b>%.2f %s</b>" % (self.dictReglement["montant"], SYMBOLE))
dictValeurs["intro"] = textIntro
else:
dictValeurs["intro"] = None
# Envoi des informations sur le règlement
for key, valeur in self.dictReglement.iteritems():
dictValeurs[key] = valeur
dictValeurs["{IDREGLEMENT}"] = str(dictValeurs["IDreglement"])
dictValeurs["{DATE_REGLEMENT}"] = DateEngFr(
dictValeurs["dateReglement"])
dictValeurs["{MODE_REGLEMENT}"] = dictValeurs["nomMode"]
if dictValeurs["nomEmetteur"] != None:
dictValeurs["{NOM_EMETTEUR}"] = dictValeurs["nomEmetteur"]
else:
dictValeurs["{NOM_EMETTEUR}"] = ""
dictValeurs["{NUM_PIECE}"] = dictValeurs["numPiece"]
dictValeurs["{MONTANT_REGLEMENT}"] = u"%.2f %s" % (
dictValeurs["montant"], SYMBOLE)
dictValeurs["{NOM_PAYEUR}"] = dictValeurs["nomPayeur"]
dictValeurs["{NUM_QUITTANCIER}"] = str(dictValeurs["numQuittancier"])
dictValeurs["{DATE_SAISIE}"] = DateEngFr(dictValeurs["date_saisie"])
dictValeurs["{OBSERVATIONS}"] = u"%s" % dictValeurs["observations"]
# Récupération liste des prestations
if self.ctrl_prestations.GetValue() == True:
dictValeurs["prestations"] = self.GetPrestations()
else:
dictValeurs["prestations"] = []
# Préparation des données pour une sauvegarde de l'attestation
self.dictSave = {}
self.dictSave["numero"] = dictDonnees["numero"]
self.dictSave["IDfamille"] = self.IDfamille
self.dictSave["date_edition"] = DateFrEng(dictDonnees["date"])
self.dictSave["IDutilisateur"] = UTILS_Identification.GetIDutilisateur(
)
self.dictSave["IDreglement"] = self.IDreglement
# Récupération du modèle
IDmodele = self.ctrl_modele.GetID()
if IDmodele == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un modèle !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
dictChampsFusion["{DATE_EDITION_RECU}"] = DateFrEng(
dictDonnees["date"])
dictChampsFusion["{NUMERO_RECU}"] = dictDonnees["numero"]
dictChampsFusion["{ID_REGLEMENT}"] = str(dictValeurs["{IDREGLEMENT}"])
dictChampsFusion["{DATE_REGLEMENT}"] = dictValeurs["{DATE_REGLEMENT}"]
dictChampsFusion["{MODE_REGLEMENT}"] = dictValeurs["{MODE_REGLEMENT}"]
dictChampsFusion["{NOM_EMETTEUR}"] = dictValeurs["{NOM_EMETTEUR}"]
dictChampsFusion["{NUM_PIECE}"] = dictValeurs["{NUM_PIECE}"]
dictChampsFusion["{MONTANT_REGLEMENT}"] = dictValeurs[
"{MONTANT_REGLEMENT}"]
dictChampsFusion["{NOM_PAYEUR}"] = dictValeurs["{NOM_PAYEUR}"]
dictChampsFusion["{NUM_QUITTANCIER}"] = dictValeurs[
"{NUM_QUITTANCIER}"]
dictChampsFusion["{DATE_SAISIE}"] = dictValeurs["{DATE_SAISIE}"]
# Fabrication du PDF
from Utils import UTILS_Impression_recu
UTILS_Impression_recu.Impression(dictValeurs,
IDmodele=IDmodele,
nomDoc=nomDoc,
afficherDoc=afficherDoc)
return dictChampsFusion
def Importation_prestations(self):
""" Importation des données """
# Chargement des informations individuelles
self.infosIndividus = UTILS_Infos_individus.Informations(
date_reference=self.date_debut,
qf=True,
inscriptions=True,
messages=False,
infosMedicales=False,
cotisationsManquantes=False,
piecesManquantes=False,
questionnaires=True,
scolarite=True)
self.dictInfosIndividus = self.infosIndividus.GetDictValeurs(
mode="individu", ID=None, formatChamp=False)
self.dictInfosFamilles = self.infosIndividus.GetDictValeurs(
mode="famille", ID=None, formatChamp=False)
DB = GestionDB.DB()
# Récupèration de la ventilation des prestations de la période
conditionDepots = ""
if self.filtreDepots == True and self.filtreDepots_dateDebut != None and self.filtreDepots_dateFin != None:
conditionDepots = " AND (depots.date>='%s' and depots.date<='%s') " % (
self.filtreDepots_dateDebut, self.filtreDepots_dateFin)
conditionReglements = ""
if self.filtreReglements == True and self.filtreReglements_dateDebut != None and self.filtreReglements_dateFin != None:
conditionReglements = " AND (reglements.date_saisie>='%s' and reglements.date_saisie<='%s') " % (
self.filtreReglements_dateDebut, self.filtreReglements_dateFin)
req = """SELECT
ventilation.IDventilation, ventilation.IDreglement, ventilation.IDprestation, ventilation.montant,
reglements.date, reglements.date_saisie, depots.date,
prestations.date
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
WHERE prestations.date>='%s' AND prestations.date <='%s' %s %s
ORDER BY prestations.date; """ % (self.date_debut, self.date_fin,
conditionDepots, conditionReglements)
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDventilation, IDreglement, IDprestation, montantVentilation, dateReglement, dateSaisieReglement, dateDepotReglement, datePrestation in listeVentilation:
if (IDprestation in dictVentilation) == False:
dictVentilation[IDprestation] = 0.0
dictVentilation[IDprestation] += montantVentilation
# Condition Afficher Cotisations et/ou Consommations ?
listeAffichage = []
if self.afficher_cotisations == True:
listeAffichage.append("cotisation")
if self.afficher_locations == True: listeAffichage.append("location")
if self.afficher_consommations == True:
listeAffichage.append("consommation")
if self.afficher_autres == True: listeAffichage.append("autre")
if len(listeAffichage) == 0: conditionAfficher = "categorie='xxxxxxx' "
elif len(listeAffichage) == 1:
conditionAfficher = "categorie='%s'" % listeAffichage[0]
else:
conditionAfficher = "categorie IN %s" % str(tuple(listeAffichage))
# Condition Activités affichées
if len(self.listeActivites) == 0:
conditionActivites = "prestations.IDactivite=9999999"
elif len(self.listeActivites) == 1:
conditionActivites = "prestations.IDactivite=%d" % self.listeActivites[
0]
else:
conditionActivites = "prestations.IDactivite IN %s" % str(
tuple(self.listeActivites))
# Filtre Prestation facturée / non facturée
conditionFacturee = ""
if "facturee" in self.mode_affichage:
conditionFacturee = " AND prestations.IDfacture IS NOT NULL"
if "nonfacturee" in self.mode_affichage:
conditionFacturee = " AND prestations.IDfacture IS NULL"
# Récupération de toutes les prestations de la période
req = """SELECT IDprestation, date, categorie, label, montant, prestations.IDactivite, prestations.IDcategorie_tarif, IDfamille, IDindividu
FROM prestations
WHERE date>='%s' AND date <='%s'
AND %s AND (%s OR prestations.IDactivite IS NULL)
%s
ORDER BY date; """ % (self.date_debut, self.date_fin,
conditionAfficher, conditionActivites,
conditionFacturee)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
# Récupération des tranches de tarifs paramétrées
if len(self.listeActivites) == 0:
condition = ""
else:
condition = "AND %s" % conditionActivites.replace(
"prestations.", "")
req = """SELECT IDligne, qf_min, qf_max
FROM tarifs_lignes
WHERE qf_min IS NOT NULL AND qf_max IS NOT NULL
%s
;""" % condition
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
liste_tranches = []
for IDligne, qf_min, qf_max in listeDonnees:
tranche = float(qf_min), float(qf_max)
if tranche not in liste_tranches:
liste_tranches.append(tranche)
liste_tranches.sort()
DB.Close()
dictPrestations = {}
listeRegroupements = []
dictLabelsRegroupements = {}
for IDprestation, date, categorie, label, montant, IDactivite, IDcategorie_tarif, IDfamille, IDindividu in listePrestations:
date = UTILS_Dates.DateEngEnDateDD(date)
annee = date.year
mois = date.month
if montant == None:
montant = 0.0
def GetKey(key_code=""):
key = None
key_label = ""
key_tri = None
if key_code == "jour":
key = date
key_tri = key
key_label = UTILS_Dates.DateEngFr(date)
if key_code == "mois":
key = (annee, mois)
key_tri = key
key_label = PeriodeComplete(mois, annee)
if key_code == "annee":
key = annee
key_tri = key
key_label = str(annee)
if key_code == "label_prestation":
key = label
key_tri = label
key_label = label
if key_code == "activite":
key = IDactivite
if IDactivite == None or (IDactivite
in self.dictActivites) == False:
key_label = _(u"Activité inconnue")
else:
key_label = self.dictActivites[IDactivite]["nom"]
key_tri = key_label
if key_code == "categorie_tarif":
key = IDcategorie_tarif
if IDcategorie_tarif == None or (
IDcategorie_tarif
in self.dictCategoriesTarifs) == False:
key_label = _(u"Sans catégorie")
else:
key_label = self.dictCategoriesTarifs[
IDcategorie_tarif]["nomCategorie"]
key_tri = key_label
if key_code == "famille":
key = IDfamille
if IDfamille == None or (IDfamille
in self.dict_titulaires) == False:
key_label = _(u"Famille inconnue")
else:
key_label = self.dict_titulaires[IDfamille][
"titulairesSansCivilite"]
key_tri = key_label
if key_code == "individu":
key = IDindividu
if IDindividu == None or (IDindividu
in self.dictIndividus) == False:
key_label = _(u"Individu inconnu")
else:
key_label = self.dictIndividus[IDindividu][
"nom_complet"]
key_tri = key_label
if key_code == "ville_residence" and IDindividu not in (0,
None):
key = self.dictInfosIndividus[IDindividu]["INDIVIDU_VILLE"]
key_label = key
key_tri = key
if key_code == "secteur" and IDindividu not in (0, None):
key = self.dictInfosIndividus[IDindividu][
"INDIVIDU_SECTEUR"]
key_label = key
key_tri = key
if key_code == "age" and IDindividu not in (0, None):
key = self.dictInfosIndividus[IDindividu][
"INDIVIDU_AGE_INT"]
key_label = str(key)
key_tri = key
if key_code == "nom_ecole" and IDindividu not in (0, None):
key = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_ECOLE"]
key_label = key
key_tri = key
if key_code == "nom_classe" and IDindividu not in (0, None):
key = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_CLASSE"]
key_label = key
key_tri = key
if key_code == "nom_niveau_scolaire" and IDindividu not in (
0, None):
key = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_NIVEAU"]
key_label = key
key_tri = key
if key_code == "regime":
key = self.dictInfosFamilles[IDfamille][
"FAMILLE_NOM_REGIME"]
key_label = key
key_tri = key
if key_code == "caisse":
key = self.dictInfosFamilles[IDfamille][
"FAMILLE_NOM_CAISSE"]
key_label = key
key_tri = key
# QF
if key_code.startswith("qf"):
key = None
if "FAMILLE_QF_ACTUEL_INT" in self.dictInfosFamilles[
IDfamille]:
qf = self.dictInfosFamilles[IDfamille][
"FAMILLE_QF_ACTUEL_INT"]
# Tranches de 100
if key_code == "qf_100":
for x in range(0, 10000, 100):
min, max = x, x + 99
if qf >= min and qf <= max:
key = (min, max)
key_tri = key
key_label = "%s - %s" % (min, max)
# Tranches paramétrées
if key_code == "qf_tarifs":
for min, max in liste_tranches:
if qf >= min and qf <= max:
key = (min, max)
key_tri = key
key_label = "%s - %s" % (min, max)
# Questionnaires
if key_code.startswith("question_") and "famille" in key_code:
key = self.dictInfosFamilles[IDfamille]["QUESTION_%s" %
key_code[17:]]
key_label = six.text_type(key)
key_tri = key_label
if key_code.startswith(
"question_"
) and "individu" in key_code and IDindividu not in (0, None):
key = self.dictInfosIndividus[IDindividu]["QUESTION_%s" %
key_code[18:]]
key_label = six.text_type(key)
key_tri = key_label
if key in ("", None):
key = _(u"- Autre -")
key_label = key
key_tri = key_label
return key, key_label, key_tri
# Création des keys de regroupements
regroupement, labelRegroupement, triRegroupement = GetKey(
self.key_colonne)
key1, key1_label, key1_tri = GetKey(self.key_ligne1)
key2, key2_label, key2_tri = GetKey(self.key_ligne2)
# Mémorisation du regroupement
if regroupement not in listeRegroupements:
listeRegroupements.append(regroupement)
dictLabelsRegroupements[regroupement] = labelRegroupement
# Total
if (key1 in dictPrestations) == False:
dictPrestations[key1] = {
"label": key1_label,
"tri": key1_tri,
"nbre": 0,
"facture": 0.0,
"regle": 0.0,
"impaye": 0.0,
"regroupements": {}
}
dictPrestations[key1]["nbre"] += 1
dictPrestations[key1]["facture"] += montant
# Détail par période
if (regroupement
in dictPrestations[key1]["regroupements"]) == False:
dictPrestations[key1]["regroupements"][regroupement] = {
"nbre": 0,
"facture": 0.0,
"regle": 0.0,
"impaye": 0.0,
"key2": {}
}
dictPrestations[key1]["regroupements"][regroupement]["nbre"] += 1
dictPrestations[key1]["regroupements"][regroupement][
"facture"] += montant
# Détail par catégorie de tarifs
if (key2 in dictPrestations[key1]["regroupements"][regroupement]
["key2"]) == False:
dictPrestations[key1]["regroupements"][regroupement]["key2"][
key2] = {
"label": key2_label,
"tri": key2_tri,
"nbre": 0,
"facture": 0.0,
"regle": 0.0,
"impaye": 0.0
}
dictPrestations[key1]["regroupements"][regroupement]["key2"][key2][
"nbre"] += 1
dictPrestations[key1]["regroupements"][regroupement]["key2"][key2][
"facture"] += montant
# Ajoute la ventilation
if IDprestation in dictVentilation:
dictPrestations[key1]["regle"] += dictVentilation[IDprestation]
dictPrestations[key1]["regroupements"][regroupement][
"regle"] += dictVentilation[IDprestation]
dictPrestations[key1]["regroupements"][regroupement]["key2"][
key2]["regle"] += dictVentilation[IDprestation]
# Calcule les impayés
dictPrestations[key1]["impaye"] = dictPrestations[key1][
"regle"] - dictPrestations[key1]["facture"]
dictPrestations[key1]["regroupements"][regroupement][
"impaye"] = dictPrestations[key1]["regroupements"][
regroupement]["regle"] - dictPrestations[key1][
"regroupements"][regroupement]["facture"]
dictPrestations[key1]["regroupements"][regroupement]["key2"][key2][
"impaye"] = dictPrestations[key1]["regroupements"][
regroupement]["key2"][key2]["regle"] - dictPrestations[
key1]["regroupements"][regroupement]["key2"][key2][
"facture"]
listeRegroupements.sort()
return dictPrestations, listeRegroupements, dictLabelsRegroupements
def Importation(liste_activites=[],
date_debut=None,
date_fin=None,
date_edition=None,
dateNaiss=None,
listePrestations=[],
typeLabel="original"):
""" Recherche des attestations à créer """
# Conditions
if len(liste_activites) == 0: conditionActivites = "()"
elif len(liste_activites) == 1:
conditionActivites = "(%d)" % liste_activites[0]
else:
conditionActivites = str(tuple(liste_activites))
conditionDates = " prestations.date>='%s' AND prestations.date<='%s' " % (
date_debut, date_fin)
# Condition date Naissance
if dateNaiss != None:
conditionDateNaiss = "AND individus.date_naiss >= '%s' " % dateNaiss
else:
conditionDateNaiss = ""
DB = GestionDB.DB()
# Récupération de tous les individus de la base
req = """
SELECT IDindividu, IDcivilite, nom, prenom, date_naiss, adresse_auto, rue_resid, cp_resid, ville_resid
FROM individus
;"""
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
dictIndividus = {}
for IDindividu, IDcivilite, nom, prenom, date_naiss, adresse_auto, rue_resid, cp_resid, ville_resid in listeIndividus:
dictIndividus[IDindividu] = {
"IDcivilite": IDcivilite,
"nom": nom,
"prenom": prenom,
"date_naiss": date_naiss,
"adresse_auto": adresse_auto,
"rue_resid": rue_resid,
"cp_resid": cp_resid,
"ville_resid": ville_resid
}
# Recherche des prestations de la période
req = """
SELECT prestations.IDprestation, prestations.IDcompte_payeur, prestations.date, categorie,
label, prestations.montant_initial, prestations.montant, prestations.tva,
prestations.IDactivite, activites.nom, activites.abrege,
prestations.IDtarif, noms_tarifs.nom, categories_tarifs.nom, IDfacture,
prestations.IDindividu, prestations.IDfamille
FROM prestations
LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite
LEFT JOIN tarifs ON prestations.IDtarif = tarifs.IDtarif
LEFT JOIN noms_tarifs ON tarifs.IDnom_tarif = noms_tarifs.IDnom_tarif
LEFT JOIN categories_tarifs ON tarifs.IDcategorie_tarif = categories_tarifs.IDcategorie_tarif
LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
WHERE (prestations.IDactivite IN %s OR prestations.IDactivite IS NULL)
AND %s
%s
GROUP BY prestations.IDprestation
ORDER BY prestations.date
;""" % (conditionActivites, conditionDates, conditionDateNaiss)
DB.ExecuterReq(req)
listePrestationsTemp = DB.ResultatReq()
# Récupération de la ventilation
req = """
SELECT prestations.IDprestation, SUM(ventilation.montant)
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite
LEFT JOIN individus ON individus.IDindividu = prestations.IDindividu
WHERE (prestations.IDactivite IN %s OR prestations.IDactivite IS NULL)
AND %s
%s
GROUP BY prestations.IDprestation
;""" % (conditionActivites, conditionDates, conditionDateNaiss)
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDprestation, totalVentilation in listeVentilation:
dictVentilation[IDprestation] = totalVentilation
# Recherche des déductions
req = u"""
SELECT IDdeduction, IDprestation, date, montant, label, IDaide
FROM deductions
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = deductions.IDcompte_payeur
;"""
DB.ExecuterReq(req)
listeDeductionsTemp = DB.ResultatReq()
dictDeductions = {}
for IDdeduction, IDprestation, date, montant, label, IDaide in listeDeductionsTemp:
if dictDeductions.has_key(IDprestation) == False:
dictDeductions[IDprestation] = []
dictDeductions[IDprestation].append({
"IDdeduction": IDdeduction,
"date": date,
"montant": montant,
"label": label,
"IDaide": IDaide
})
# Recherche des consommations (sert pour les forfaits)
req = """
SELECT IDconso, consommations.date, consommations.IDprestation
FROM consommations
LEFT JOIN prestations ON prestations.IDprestation = consommations.IDprestation
WHERE prestations.IDactivite IN %s
AND %s
;""" % (conditionActivites, conditionDates)
DB.ExecuterReq(req)
listeConsommations = DB.ResultatReq()
dictConsommations = {}
for IDconso, date, IDprestation in listeConsommations:
date = DateEngEnDateDD(date)
if dictConsommations.has_key(IDprestation) == False:
dictConsommations[IDprestation] = []
if date not in dictConsommations[IDprestation]:
dictConsommations[IDprestation].append(date)
# Recherche des numéros d'agréments
req = """
SELECT IDactivite, agrement, date_debut, date_fin
FROM agrements
WHERE IDactivite IN %s
ORDER BY date_debut
""" % conditionActivites
DB.ExecuterReq(req)
listeAgrements = DB.ResultatReq()
# Récupération des infos sur l'organisme
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
dictOrganisme["nom"] = nom
dictOrganisme["rue"] = rue
dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
dictOrganisme["ville"] = ville
dictOrganisme["tel"] = tel
dictOrganisme["fax"] = fax
dictOrganisme["mail"] = mail
dictOrganisme["site"] = site
dictOrganisme["num_agrement"] = num_agrement
dictOrganisme["num_siret"] = num_siret
dictOrganisme["code_ape"] = code_ape
# Get noms Titulaires
dictNomsTitulaires = UTILS_Titulaires.GetTitulaires()
DB.Close()
# Analyse et regroupement des données
def isPrestationSelection(label, IDactivite):
for track in listePrestations:
if label == track["label"] and IDactivite == track["IDactivite"]:
return True
return False
# Récupération des infos de base individus et familles
infosIndividus = UTILS_Infos_individus.Informations()
dictComptes = {}
for IDprestation, IDcompte_payeur, date, categorie, label, montant_initial, montant, tva, IDactivite, nomActivite, abregeActivite, IDtarif, nomTarif, nomCategorieTarif, IDfacture, IDindividu, IDfamille in listePrestationsTemp:
montant_initial = FloatToDecimal(montant_initial)
montant = FloatToDecimal(montant)
if isPrestationSelection(label, IDactivite) == True:
# Regroupement par compte payeur
if dictComptes.has_key(IDcompte_payeur) == False:
# Recherche des titulaires
dictInfosTitulaires = dictNomsTitulaires[IDfamille]
nomsTitulairesAvecCivilite = dictInfosTitulaires[
"titulairesAvecCivilite"]
nomsTitulairesSansCivilite = dictInfosTitulaires[
"titulairesSansCivilite"]
rue_resid = dictInfosTitulaires["adresse"]["rue"]
cp_resid = dictInfosTitulaires["adresse"]["cp"]
ville_resid = dictInfosTitulaires["adresse"]["ville"]
if cp_resid == None: cp_resid = u""
if ville_resid == None: ville_resid = u""
destinataire_ville = u"%s %s" % (cp_resid, ville_resid)
# Mémorisation des infos
dictComptes[IDcompte_payeur] = {
"{FAMILLE_NOM}": nomsTitulairesAvecCivilite,
"{DESTINATAIRE_NOM}": nomsTitulairesAvecCivilite,
"nomSansCivilite": nomsTitulairesSansCivilite,
"IDfamille": IDfamille,
"{IDFAMILLE}": str(IDfamille),
"{FAMILLE_RUE}": rue_resid,
"{FAMILLE_CP}": cp_resid,
"{FAMILLE_VILLE}": ville_resid,
"{DESTINATAIRE_RUE}": rue_resid,
"{DESTINATAIRE_CP}": cp_resid,
"{DESTINATAIRE_VILLE}": destinataire_ville,
"individus": {},
"listeNomsIndividus": [],
"listePrestations": [],
"prestations_familiales": [],
"total": FloatToDecimal(0.0),
"ventilation": FloatToDecimal(0.0),
"solde": FloatToDecimal(0.0),
"num_attestation": None,
"select": True,
"intro": "",
"date_debut": date_debut,
"date_fin": date_fin,
"{DATE_DEBUT}": DateEngFr(str(date_debut)),
"{DATE_FIN}": DateEngFr(str(date_fin)),
"{DATE_EDITION_LONG}": DateComplete(date_edition),
"{DATE_EDITION_COURT}": DateEngFr(str(date_edition)),
"{DATE_EDITION}": DateEngFr(str(date_edition)),
"{ORGANISATEUR_NOM}": dictOrganisme["nom"],
"{ORGANISATEUR_RUE}": dictOrganisme["rue"],
"{ORGANISATEUR_CP}": dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}": dictOrganisme["ville"],
"{ORGANISATEUR_TEL}": dictOrganisme["tel"],
"{ORGANISATEUR_FAX}": dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}": dictOrganisme["mail"],
"{ORGANISATEUR_SITE}": dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}": dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}": dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}": dictOrganisme["code_ape"],
}
dictComptes[IDcompte_payeur].update(
infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
# Insert les montants pour le compte payeur
if dictVentilation.has_key(IDprestation):
montant_ventilation = FloatToDecimal(
dictVentilation[IDprestation])
else:
montant_ventilation = FloatToDecimal(0.0)
dictComptes[IDcompte_payeur]["total"] += montant
dictComptes[IDcompte_payeur]["ventilation"] += montant_ventilation
dictComptes[IDcompte_payeur][
"solde"] = dictComptes[IDcompte_payeur]["total"] - dictComptes[
IDcompte_payeur]["ventilation"]
dictComptes[IDcompte_payeur]["{TOTAL_PERIODE}"] = u"%.02f %s" % (
dictComptes[IDcompte_payeur]["total"], SYMBOLE)
dictComptes[IDcompte_payeur]["{TOTAL_REGLE}"] = u"%.02f %s" % (
dictComptes[IDcompte_payeur]["ventilation"], SYMBOLE)
dictComptes[IDcompte_payeur]["{SOLDE_DU}"] = u"%.02f %s" % (
dictComptes[IDcompte_payeur]["solde"], SYMBOLE)
# Ajout d'une prestation familiale
if IDindividu == None:
IDindividu = 0
if IDactivite == None:
IDactivite = 0
# Ajout d'un individu
if dictComptes[IDcompte_payeur]["individus"].has_key(
IDindividu) == False:
if dictIndividus.has_key(IDindividu):
# Si c'est bien un individu
IDcivilite = dictIndividus[IDindividu]["IDcivilite"]
nomIndividu = dictIndividus[IDindividu]["nom"]
prenomIndividu = dictIndividus[IDindividu]["prenom"]
dateNaiss = dictIndividus[IDindividu]["date_naiss"]
if dateNaiss != None:
if DICT_CIVILITES[IDcivilite]["sexe"] == "M":
texteDateNaiss = _(u", né le %s") % DateEngFr(
str(dateNaiss))
else:
texteDateNaiss = _(u", née le %s") % DateEngFr(
str(dateNaiss))
else:
texteDateNaiss = u""
texteIndividu = _(u"<b>%s %s</b><font size=7>%s</font>"
) % (nomIndividu, prenomIndividu,
texteDateNaiss)
nom = u"%s %s" % (nomIndividu, prenomIndividu)
# créé le texte complet des noms des individus pour l'intro de l'attestation
dictComptes[IDcompte_payeur]["listeNomsIndividus"].append(
u"%s %s" % (prenomIndividu, nomIndividu))
else:
# Si c'est pour une prestation familiale on créé un individu ID 0 :
nom = _(u"Prestations familiales")
texteIndividu = u"<b>%s</b>" % nom
dictComptes[IDcompte_payeur]["individus"][IDindividu] = {
"texte": texteIndividu,
"activites": {},
"total": FloatToDecimal(0.0),
"ventilation": FloatToDecimal(0.0),
"total_reports": FloatToDecimal(0.0),
"nom": nom,
"select": True
}
# Ajout de l'activité
if dictComptes[IDcompte_payeur]["individus"][IDindividu][
"activites"].has_key(IDactivite) == False:
texteActivite = nomActivite
agrement = RechercheAgrement(listeAgrements, IDactivite, date)
if agrement != None:
texteActivite += _(u" - n° agrément : %s") % agrement
dictComptes[IDcompte_payeur]["individus"][IDindividu][
"activites"][IDactivite] = {
"texte": texteActivite,
"presences": {}
}
# Ajout de la présence
if dictComptes[IDcompte_payeur]["individus"][IDindividu][
"activites"][IDactivite]["presences"].has_key(
date) == False:
dictComptes[IDcompte_payeur]["individus"][IDindividu][
"activites"][IDactivite]["presences"][date] = {
"texte": DateEngFr(str(date)),
"unites": [],
"total": FloatToDecimal(0.0)
}
# Recherche du nbre de dates pour cette prestation
if dictConsommations.has_key(IDprestation):
listeDates = dictConsommations[IDprestation]
else:
listeDates = []
# Recherche des déductions
if dictDeductions.has_key(IDprestation):
deductions = dictDeductions[IDprestation]
else:
deductions = []
# Adaptation du label
if typeLabel == 2:
label = nomTarif
if typeLabel == 3:
label = nomActivite
# Mémorisation de la prestation
dictPrestation = {
"IDprestation": IDprestation,
"date": date,
"categorie": categorie,
"label": label,
"montant_initial": montant_initial,
"montant": montant,
"tva": tva,
"IDtarif": IDtarif,
"nomTarif": nomTarif,
"nomCategorieTarif": nomCategorieTarif,
"montant_ventilation": montant_ventilation,
"listeDatesConso": listeDates,
"deductions": deductions,
}
dictComptes[IDcompte_payeur]["individus"][IDindividu]["activites"][
IDactivite]["presences"][date]["unites"].append(dictPrestation)
# Ajout des totaux
if montant != None:
dictComptes[IDcompte_payeur]["individus"][IDindividu][
"total"] += montant
dictComptes[IDcompte_payeur]["individus"][IDindividu][
"activites"][IDactivite]["presences"][date][
"total"] += montant
if montant_ventilation != None:
dictComptes[IDcompte_payeur]["individus"][IDindividu][
"ventilation"] += montant_ventilation
# Stockage des IDprestation pour saisir le IDfacture après création de la facture
dictComptes[IDcompte_payeur]["listePrestations"].append(
(IDindividu, IDprestation))
return dictComptes
def Run(self, afficherDlgAttente=False):
dictParametres = self.GetParametres()
# Ouverture dlg d'attente
if afficherDlgAttente == True:
dlgAttente = wx.BusyInfo(
_(u"Génération du fichier de données..."), None)
try:
# Génération du nom de fichier
self.nomFichier = UTILS_Fichiers.GetRepTemp(
fichier=u"data_%s" % dictParametres["IDfichier"])
# Vérifie si le fichier existe déj�
nomFichierTemp = self.nomFichier + ".dat"
if os.path.isfile(nomFichierTemp):
os.remove(nomFichierTemp)
# Création des tables
dbdest = GestionDB.DB(suffixe=None,
nomFichier=nomFichierTemp,
modeCreation=True)
dbdest.CreationTables(dicoDB=self.dictTables)
# Enregistrement des paramètres
listeParametres = [
("IDfichier", dictParametres["IDfichier"]),
("horodatage", dictParametres["horodatage"]),
("type", "donnees"),
]
self.Enregistrer(dbdest,
nomTable="parametres",
listeChamps=["nom", "valeur"],
listeDonnees=listeParametres)
# Données du dictIndividus
from Utils import UTILS_Infos_individus
infos = UTILS_Infos_individus.Informations()
dictValeurs = infos.GetDictValeurs(mode="individu",
formatChamp=False)
listeDonnees = []
for ID, dictTemp in dictValeurs.items():
for champ, valeur in dictTemp.items():
if type(valeur) in (str, six.text_type) and valeur not in (
"", None):
listeDonnees.append((ID, champ, valeur))
self.Enregistrer(dbdest,
nomTable="informations",
listeChamps=["IDindividu", "champ", "valeur"],
listeDonnees=listeDonnees)
# Données individus
db = GestionDB.DB(suffixe="PHOTOS")
req = """SELECT IDindividu, photo FROM photos;"""
db.ExecuterReq(req)
listePhotos = db.ResultatReq()
db.Close()
dictPhotos = {}
for IDindividu, photo in listePhotos:
dictPhotos[IDindividu] = photo
db = GestionDB.DB()
req = """SELECT IDindividu, IDcivilite, nom, prenom FROM individus;"""
db.ExecuterReq(req)
listeIndividus = db.ResultatReq()
db.Close()
listeDonnees = []
for IDindividu, IDcivilite, nom, prenom in listeIndividus:
if IDindividu in dictPhotos:
photo = sqlite3.Binary(dictPhotos[IDindividu])
else:
photo = None
listeDonnees.append(
(IDindividu, IDcivilite, nom, prenom, photo))
self.Enregistrer(dbdest,
nomTable="individus",
listeChamps=[
"IDindividu", "IDcivilite", "nom", "prenom",
"photo"
],
listeDonnees=listeDonnees)
# Données Titulaires de dossier
dictTitulaires = UTILS_Titulaires.GetTitulaires()
listeDonnees = []
for IDfamille, dictTemp in dictTitulaires.items():
nom = dictTitulaires[IDfamille]["titulairesSansCivilite"]
listeDonnees.append((IDfamille, nom))
self.Enregistrer(dbdest,
nomTable="titulaires",
listeChamps=["IDfamille", "nom"],
listeDonnees=listeDonnees)
# Données organisateur
db = GestionDB.DB()
req = """SELECT IDorganisateur, nom, logo FROM organisateur;"""
db.ExecuterReq(req)
listeTemp = db.ResultatReq()
db.Close()
listeDonnees = []
for IDorganisateur, nom, logo in listeTemp:
if logo != None:
logo = sqlite3.Binary(logo)
listeDonnees.append((IDorganisateur, nom, logo))
self.Enregistrer(dbdest,
nomTable="organisateur",
listeChamps=["IDorganisateur", "nom", "logo"],
listeDonnees=listeDonnees)
# Tables à copier en intégralité
listeTables = [
"vacances",
"jours_feries",
"activites",
"groupes",
"unites",
"unites_groupes",
"unites_incompat",
"unites_remplissage",
"unites_remplissage_unites",
"ouvertures",
"remplissage",
"inscriptions",
"consommations",
"memo_journee",
"comptes_payeurs",
"familles",
"utilisateurs",
"nomade_archivage",
"niveaux_scolaires",
"ecoles",
"classes",
"scolarite",
]
self.CopieTables(dbdest, listeTables)
# Cloture de la base
dbdest.connexion.commit()
dbdest.Close()
# Compression
fichierZip = zipfile.ZipFile(self.nomFichier + EXTENSION_DECRYPTE,
"w",
compression=zipfile.ZIP_DEFLATED)
fichierZip.write(self.nomFichier + ".dat", "database.dat")
fichierZip.close()
os.remove(self.nomFichier + ".dat")
# Cryptage
cryptage_actif = UTILS_Config.GetParametre(
"synchro_cryptage_activer", defaut=False)
cryptage_mdp = base64.b64decode(
UTILS_Config.GetParametre("synchro_cryptage_mdp", defaut=""))
if cryptage_actif == True and cryptage_mdp != "":
UTILS_Cryptage_fichier.CrypterFichier(
self.nomFichier + EXTENSION_DECRYPTE,
self.nomFichier + EXTENSION_CRYPTE, cryptage_mdp)
os.remove(self.nomFichier + EXTENSION_DECRYPTE)
nomFichierFinal = self.nomFichier + EXTENSION_CRYPTE
else:
nomFichierFinal = self.nomFichier + EXTENSION_DECRYPTE
except Exception as err:
print("Erreur dans UTILS_Export_nomade.Run :", err)
traceback.print_exc(file=sys.stdout)
if afficherDlgAttente == True:
del dlgAttente
dlg = wx.MessageDialog(
None,
_(u"Désolé, l'erreur suivante a été rencontrée : ") +
str(err), "Erreur ", wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return None
if afficherDlgAttente == True:
del dlgAttente
return nomFichierFinal
def GetDoc(self):
# Importation des données de la DB
DB = GestionDB.DB()
if self.IDfamille == None:
conditions = ""
req = """SELECT IDfamille, date_creation FROM familles;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
liste_IDfamille = []
for IDfamille, date_creation in listeDonnees:
liste_IDfamille.append(IDfamille)
else:
conditions = "WHERE IDfamille=%d" % self.IDfamille
liste_IDfamille = [
self.IDfamille,
]
# Importation des pièces fournies
req = """SELECT pieces.IDpiece, pieces.date_debut, pieces.date_fin,
types_pieces.public, types_pieces.nom,
individus.IDindividu, pieces.IDfamille, individus.prenom
FROM pieces
LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece
LEFT JOIN individus ON individus.IDindividu = pieces.IDindividu
ORDER BY date_debut;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPieces = {"familles": {}, "individus": {}}
for IDpiece, date_debut, date_fin, public, nom_piece, IDindividu, IDfamille, prenom in listeDonnees:
dictPiece = {
"IDpiece": IDpiece,
"nom_piece": nom_piece,
"date_debut": UTILS_Dates.DateEngEnDateDD(date_debut),
"date_fin": UTILS_Dates.DateEngEnDateDD(date_fin)
}
if public == "famille":
if (IDfamille in dictPieces["familles"]) == False:
dictPieces["familles"][IDfamille] = []
dictPieces["familles"][IDfamille].append(dictPiece)
if public == "individu":
if (IDindividu in dictPieces["individus"]) == False:
dictPieces["individus"][IDindividu] = []
dictPieces["individus"][IDindividu].append(dictPiece)
# Importation des cotisations
champs_cotisations = [
("IDcotisation", "cotisations.IDcotisation"),
("IDfamille", "cotisations.IDfamille"),
("IDindividu", "cotisations.IDindividu"),
("date_saisie", "cotisations.date_saisie"),
("date_creation_carte", "cotisations.date_creation_carte"),
("numero", "cotisations.numero"),
("date_debut", "cotisations.date_debut"),
("date_fin", "cotisations.date_fin"),
("observations", "cotisations.observations"),
("activites", "cotisations.activites"),
("type_cotisation", "types_cotisations.nom"),
("type", "types_cotisations.type"),
("nom_unite_cotisation", "unites_cotisations.nom"),
]
req = """
SELECT %s
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
ORDER BY cotisations.date_debut
;""" % ", ".join([champ for nom, champ in champs_cotisations])
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictCotisations = {"familles": {}, "individus": {}}
for donnees in listeDonnees:
dictCotisation = {}
for index in range(0, len(champs_cotisations)):
dictCotisation[champs_cotisations[index][0]] = donnees[index]
if dictCotisation["type"] == "famille":
IDfamille = dictCotisation["IDfamille"]
if (IDfamille in dictCotisations["familles"]) == False:
dictCotisations["familles"][IDfamille] = []
dictCotisations["familles"][IDfamille].append(dictCotisation)
if dictCotisation["type"] == "individu":
IDindividu = dictCotisation["IDindividu"]
if (IDindividu in dictCotisations["individus"]) == False:
dictCotisations["individus"][IDindividu] = []
dictCotisations["individus"][IDindividu].append(dictCotisation)
# Importation des prestations
champs_prestations = [
("IDprestation", "prestations.IDprestation"),
("date", "prestations.date"),
("label", "prestations.label"),
("montant", "prestations.montant"),
("numero_facture", "factures.numero"),
("activite", "activites.nom"),
("prenom", "individus.prenom"),
("IDfamille", "prestations.IDfamille"),
("IDindividu", "prestations.IDindividu"),
]
req = """
SELECT %s
FROM prestations
LEFT JOIN activites ON prestations.IDactivite = activites.IDactivite
LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu
LEFT JOIN factures ON prestations.IDfacture = factures.IDfacture
%s
GROUP BY prestations.IDprestation
ORDER BY prestations.date
;""" % (", ".join([champ
for nom, champ in champs_prestations]), conditions)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPrestations = {}
for donnees in listeDonnees:
dictPrestation = {}
for index in range(0, len(champs_prestations)):
dictPrestation[champs_prestations[index][0]] = donnees[index]
if dictPrestation["numero_facture"] == None:
dictPrestation["numero_facture"] = ""
if dictPrestation["prenom"] == None: dictPrestation["prenom"] = ""
IDfamille = dictPrestation["IDfamille"]
if (IDfamille in dictPrestations) == False:
dictPrestations[IDfamille] = []
dictPrestations[IDfamille].append(dictPrestation)
# Importation des consommations
req = """
SELECT IDconso, date, activites.nom, consommations.etat,
unites.nom, consommations.IDindividu, comptes_payeurs.IDfamille
FROM consommations
LEFT JOIN activites ON activites.IDactivite = consommations.IDactivite
LEFT JOIN unites ON unites.IDunite = consommations.IDunite
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = consommations.IDcompte_payeur
%s
GROUP BY consommations.IDconso
ORDER BY date
;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictConsommations = {}
for IDconso, date, nomActivite, etat, nomUnite, IDindividu, IDfamille in listeDonnees:
dictConso = {
"IDconso": IDconso,
"date": date,
"nomActivite": nomActivite,
"etat": etat,
"nomUnite": nomUnite,
}
if (IDfamille in dictConsommations) == False:
dictConsommations[IDfamille] = {}
if (IDindividu in dictConsommations[IDfamille]) == False:
dictConsommations[IDfamille][IDindividu] = []
dictConsommations[IDfamille][IDindividu].append(dictConso)
# Importation des factures
# Récupération des totaux des prestations pour chaque facture
req = """
SELECT prestations.IDfacture, SUM(prestations.montant)
FROM prestations
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
GROUP BY prestations.IDfacture
;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictPrestationsFactures = {}
for IDfacture, totalPrestations in listeDonnees:
if IDfacture != None:
dictPrestationsFactures[IDfacture] = totalPrestations
# Récupération des factures
req = """
SELECT factures.IDfacture, factures.numero, factures.date_edition, factures.date_debut,
factures.date_fin, factures.total, factures.regle, factures.solde, comptes_payeurs.IDfamille
FROM factures
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = factures.IDcompte_payeur
%s
ORDER BY factures.date_edition
;""" % conditions
DB.ExecuterReq(req)
listeFactures = DB.ResultatReq()
# Récupération de la ventilation
req = """
SELECT prestations.IDfacture, SUM(ventilation.montant)
FROM ventilation
LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = prestations.IDcompte_payeur
LEFT JOIN factures ON factures.IDfacture = prestations.IDfacture
%s
GROUP BY prestations.IDfacture
;""" % conditions.replace("IDfamille", "comptes_payeurs.IDfamille")
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilationFactures = {}
for IDfacture, montantVentilation in listeVentilation:
if IDfacture != None:
dictVentilationFactures[IDfacture] = montantVentilation
dictFactures = {}
for IDfacture, numero, date_edition, date_debut, date_fin, total, regle, solde, IDfamille in listeFactures:
if numero == None: numero = 0
total = FloatToDecimal(total)
if IDfacture in dictVentilationFactures:
totalVentilation = FloatToDecimal(
dictVentilationFactures[IDfacture])
else:
totalVentilation = FloatToDecimal(0.0)
if IDfacture in dictPrestationsFactures:
totalPrestations = FloatToDecimal(
dictPrestationsFactures[IDfacture])
else:
totalPrestations = FloatToDecimal(0.0)
solde_actuel = totalPrestations - totalVentilation
dictFacture = {
"IDfacture": IDfacture,
"numero": numero,
"date_edition": date_edition,
"date_debut": date_debut,
"date_fin": date_fin,
"montant": float(totalPrestations),
"montant_regle": float(totalVentilation),
"montant_solde": float(solde_actuel),
}
if (IDfamille in dictFactures) == False:
dictFactures[IDfamille] = []
dictFactures[IDfamille].append(dictFacture)
# Importation des règlements
req = """SELECT
reglements.IDreglement, comptes_payeurs.IDfamille,
reglements.date, modes_reglements.label, emetteurs.nom,
reglements.numero_piece, reglements.montant, payeurs.nom,
reglements.observations, numero_quittancier, date_differe,
date_saisie, depots.date
FROM reglements
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDcompte_payeur = reglements.IDcompte_payeur
LEFT JOIN modes_reglements ON reglements.IDmode=modes_reglements.IDmode
LEFT JOIN emetteurs ON reglements.IDemetteur=emetteurs.IDemetteur
LEFT JOIN payeurs ON reglements.IDpayeur=payeurs.IDpayeur
LEFT JOIN depots ON reglements.IDdepot=depots.IDdepot
%s
GROUP BY reglements.IDreglement
ORDER BY date_saisie
;""" % conditions.replace("IDfamille", "comptes_payeurs.IDfamille")
DB.ExecuterReq(req)
listeReglements = DB.ResultatReq()
dictReglements = {}
for IDreglement, IDfamille, date, mode, emetteur, numero, montant, payeur, observations, numero_quittancier, date_differe, date_saisie, date_encaissement in listeReglements:
if numero == None: numero = ""
if emetteur == None: emetteur = ""
if observations == None: observations = ""
if numero_quittancier == None: numero_quittancier = ""
dictReglement = {
"date": date,
"mode": mode,
"emetteur": emetteur,
"numero": numero,
"montant": montant,
"payeur": payeur,
"observations": observations,
"numero_quittancier": numero_quittancier,
"date_differe": date_differe,
"date_saisie": date_saisie,
"date_encaissement": date_encaissement,
}
if (IDfamille in dictReglements) == False:
dictReglements[IDfamille] = []
dictReglements[IDfamille].append(dictReglement)
DB.Close()
# Récupération des infos individus
infos = UTILS_Infos_individus.Informations()
# Génération du XML
doc = Document()
# Racine Familles
node_racine = doc.createElement("familles")
doc.appendChild(node_racine)
for IDfamille in liste_IDfamille:
# Famille : Infos générales
node_famille = doc.createElement("famille")
node_famille.setAttribute("id", str(IDfamille))
node_racine.appendChild(node_famille)
for key, valeur in infos.dictFamilles[IDfamille].items():
if key.startswith("FAMILLE_"):
node = doc.createElement(
key.replace("FAMILLE_", "").lower())
node.setAttribute("valeur", six.text_type(valeur))
node_famille.appendChild(node)
# Famille : Quotients
if "qf" in infos.dictFamilles[IDfamille]:
node_qf = doc.createElement(u"quotients_familiaux")
node_famille.appendChild(node_qf)
for dictQF in infos.dictFamilles[IDfamille]["qf"]:
node = doc.createElement(u"quotient")
node.setAttribute("date_debut", dictQF["date_debut"])
node.setAttribute("date_fin", dictQF["date_fin"])
node.setAttribute("quotient", str(dictQF["quotient"]))
node.setAttribute("observations", dictQF["observations"])
node_qf.appendChild(node)
# Famille : Messages
if "messages" in infos.dictFamilles[IDfamille]:
node_messages = doc.createElement(u"messages")
node_famille.appendChild(node_messages)
for dictMessage in infos.dictFamilles[IDfamille]["messages"][
"liste"]:
node = doc.createElement(u"message")
node.setAttribute("categorie_nom",
dictMessage["categorie_nom"])
node.setAttribute("date_saisie",
dictMessage["date_saisie"])
node.setAttribute("date_parution",
dictMessage["date_parution"])
node.setAttribute("nom", dictMessage["nom"])
node.setAttribute("texte", dictMessage["texte"])
node_messages.appendChild(node)
# Famille : Questionnaires
if "questionnaires" in infos.dictFamilles[IDfamille]:
node_questionnaires = doc.createElement(u"questionnaires")
node_famille.appendChild(node_questionnaires)
for dictQuestionnaire in infos.dictFamilles[IDfamille][
"questionnaires"]:
node = doc.createElement(u"questionnaire")
node.setAttribute("question", dictQuestionnaire["label"])
node.setAttribute(
"reponse", six.text_type(dictQuestionnaire["reponse"]))
node_questionnaires.appendChild(node)
# Famille : Pièces
if IDfamille in dictPieces["familles"]:
node_pieces = doc.createElement(u"pieces")
node_famille.appendChild(node_pieces)
for dictPiece in dictPieces["familles"][IDfamille]:
node = doc.createElement(u"piece")
node.setAttribute("nom_piece", dictPiece["nom_piece"])
node.setAttribute(
"date_debut",
UTILS_Dates.DateDDEnFr(dictPiece["date_debut"]))
node.setAttribute(
"date_fin",
UTILS_Dates.DateDDEnFr(dictPiece["date_fin"]))
node_pieces.appendChild(node)
# Famille : Cotisations
if IDfamille in dictCotisations["familles"]:
node_cotisations = doc.createElement(u"cotisations")
node_famille.appendChild(node_cotisations)
for dictCotisation in dictCotisations["familles"][IDfamille]:
node = doc.createElement(u"cotisation")
node.setAttribute(
"date_saisie",
UTILS_Dates.DateDDEnFr(dictCotisation["date_saisie"]))
node.setAttribute(
"date_creation_carte",
UTILS_Dates.DateDDEnFr(
dictCotisation["date_creation_carte"]))
node.setAttribute(
"date_debut",
UTILS_Dates.DateDDEnFr(dictCotisation["date_debut"]))
node.setAttribute(
"date_fin",
UTILS_Dates.DateDDEnFr(dictCotisation["date_fin"]))
node.setAttribute("numero", dictCotisation["numero"])
node.setAttribute("type_cotisation",
dictCotisation["type_cotisation"])
node.setAttribute("nom_unite_cotisation",
dictCotisation["nom_unite_cotisation"])
node.setAttribute("observations",
dictCotisation["observations"])
node.setAttribute("activites", dictCotisation["activites"])
node_cotisations.appendChild(node)
# Famille : Prestations
if IDfamille in dictPrestations:
node_prestations = doc.createElement(u"prestations")
node_famille.appendChild(node_prestations)
for dictPrestation in dictPrestations[IDfamille]:
node = doc.createElement(u"prestation")
node.setAttribute(
"date", UTILS_Dates.DateEngFr(dictPrestation["date"]))
node.setAttribute("label", dictPrestation["label"])
node.setAttribute("devise", SYMBOLE)
node.setAttribute("montant",
u"%.2f" % dictPrestation["montant"])
node.setAttribute("numero_facture",
str(dictPrestation["numero_facture"]))
node.setAttribute("activite", dictPrestation["activite"])
node.setAttribute("prenom", dictPrestation["prenom"])
node_prestations.appendChild(node)
# Famille : Factures
if IDfamille in dictFactures:
node_factures = doc.createElement(u"factures")
node_famille.appendChild(node_factures)
for dictFacture in dictFactures[IDfamille]:
node = doc.createElement(u"facture")
node.setAttribute(
"date_edition",
UTILS_Dates.DateEngFr(dictFacture["date_edition"]))
node.setAttribute(
"date_debut",
UTILS_Dates.DateEngFr(dictFacture["date_debut"]))
node.setAttribute(
"date_fin",
UTILS_Dates.DateEngFr(dictFacture["date_fin"]))
node.setAttribute("numero_facture",
str(dictFacture["numero"]))
node.setAttribute("devise", SYMBOLE)
node.setAttribute("montant",
u"%.2f" % dictFacture["montant"])
node.setAttribute(
"montant_regle",
u"%.2f" % dictFacture["montant_regle"])
node.setAttribute(
"montant_solde",
u"%.2f" % dictFacture["montant_solde"])
node_factures.appendChild(node)
# Famille : Règlements
if IDfamille in dictReglements:
node_reglements = doc.createElement(u"reglements")
node_famille.appendChild(node_reglements)
for dictReglement in dictReglements[IDfamille]:
node = doc.createElement(u"reglement")
node.setAttribute(
"date",
UTILS_Dates.DateEngFr(dictReglement["date"]))
node.setAttribute(
"date_differe",
UTILS_Dates.DateEngFr(
dictReglement["date_differe"]))
node.setAttribute(
"date_saisie",
UTILS_Dates.DateEngFr(
dictReglement["date_saisie"]))
node.setAttribute(
"date_encaissement",
UTILS_Dates.DateEngFr(
dictReglement["date_encaissement"]))
node.setAttribute("mode", dictReglement["mode"])
node.setAttribute("emetteur",
dictReglement["emetteur"])
node.setAttribute("numero_piece",
dictReglement["numero"])
node.setAttribute("devise", SYMBOLE)
node.setAttribute("montant",
u"%.2f" % dictReglement["montant"])
node.setAttribute("payeur", dictReglement["payeur"])
node.setAttribute("observations",
dictReglement["observations"])
node.setAttribute("numero_quittancier",
dictReglement["numero_quittancier"])
node_reglements.appendChild(node)
# Individus
node_individus = doc.createElement(u"individus")
node_famille.appendChild(node_individus)
if IDfamille in infos.dictRattachements["familles"]:
for dictRattachement in infos.dictRattachements["familles"][
IDfamille]:
IDindividu = dictRattachement["IDindividu"]
node_individu = doc.createElement(u"individu")
node_individu.setAttribute("id", str(IDindividu))
node_individus.appendChild(node_individu)
# Individu : données générales
for key, champ in infos.GetListeChampsIndividus():
valeur = infos.dictIndividus[IDindividu][key]
if isinstance(valeur, (six.text_type, str)):
node = doc.createElement(
key.replace("INDIVIDU_", "").lower())
node.setAttribute("valeur", six.text_type(valeur))
node_individu.appendChild(node)
# Individu : Messages
if "messages" in infos.dictIndividus[IDindividu]:
node_messages = doc.createElement(u"messages")
node_individu.appendChild(node_messages)
for dictMessage in infos.dictIndividus[IDindividu][
"messages"]["liste"]:
node = doc.createElement(u"message")
node.setAttribute("categorie_nom",
dictMessage["categorie_nom"])
node.setAttribute("date_saisie",
dictMessage["date_saisie"])
node.setAttribute("date_parution",
dictMessage["date_parution"])
node.setAttribute("nom", dictMessage["nom"])
node.setAttribute("texte", dictMessage["texte"])
node_messages.appendChild(node)
# Individu : Infos médicales
if "medical" in infos.dictIndividus[IDindividu]:
node_medicales = doc.createElement(u"infos_medicales")
node_individu.appendChild(node_medicales)
for dictMedicale in infos.dictIndividus[IDindividu][
"medical"]["liste"]:
node = doc.createElement(u"info_medicale")
node.setAttribute("intitule",
dictMedicale["intitule"])
node.setAttribute("description",
dictMedicale["description"])
node.setAttribute(
"description_traitement",
dictMedicale["description_traitement"])
node.setAttribute(
"date_debut_traitement",
dictMedicale["date_debut_traitement"])
node.setAttribute(
"date_fin_traitement",
dictMedicale["date_fin_traitement"])
node_medicales.appendChild(node)
# Individu : Inscriptions
if "inscriptions" in infos.dictIndividus[IDindividu]:
node_inscriptions = doc.createElement(u"inscriptions")
node_individu.appendChild(node_inscriptions)
for dictInscription in infos.dictIndividus[IDindividu][
"inscriptions"]["liste"]:
node = doc.createElement(u"inscription")
node.setAttribute("activite",
dictInscription["activite"])
node.setAttribute("groupe",
dictInscription["groupe"])
node.setAttribute(
"categorie_tarif",
dictInscription["categorie_tarif"])
node.setAttribute("parti",
dictInscription["parti"])
node.setAttribute(
"date_inscription",
dictInscription["date_inscription"])
node_inscriptions.appendChild(node)
# Individu : Questionnaires
if "questionnaires" in infos.dictIndividus[IDindividu]:
node_questionnaires = doc.createElement(
u"questionnaires")
node_individu.appendChild(node_questionnaires)
for dictQuestionnaire in infos.dictIndividus[
IDindividu]["questionnaires"]:
node = doc.createElement(u"questionnaire")
node.setAttribute("question",
dictQuestionnaire["label"])
node.setAttribute(
"reponse",
six.text_type(dictQuestionnaire["reponse"]))
node_questionnaires.appendChild(node)
# Individu : Scolarité
if "scolarite" in infos.dictIndividus[IDindividu]:
node_scolarite = doc.createElement(u"scolarite")
node_individu.appendChild(node_scolarite)
for dictScolarite in infos.dictIndividus[IDindividu][
"scolarite"]["liste"]:
node = doc.createElement(u"etape")
node.setAttribute("date_debut",
dictScolarite["date_debut"])
node.setAttribute("date_fin",
dictScolarite["date_fin"])
node.setAttribute("ecole_nom",
dictScolarite["ecole_nom"])
node.setAttribute("classe_nom",
dictScolarite["classe_nom"])
node.setAttribute("niveau_nom",
dictScolarite["niveau_nom"])
node.setAttribute("niveau_abrege",
dictScolarite["niveau_abrege"])
node_scolarite.appendChild(node)
# Individu : Pièces
if IDindividu in dictPieces["individus"]:
node_pieces = doc.createElement(u"pieces")
node_individu.appendChild(node_pieces)
for dictPiece in dictPieces["individus"][IDindividu]:
node = doc.createElement(u"piece")
node.setAttribute("nom_piece",
dictPiece["nom_piece"])
node.setAttribute(
"date_debut",
UTILS_Dates.DateDDEnFr(
dictPiece["date_debut"]))
node.setAttribute(
"date_fin",
UTILS_Dates.DateDDEnFr(dictPiece["date_fin"]))
node_pieces.appendChild(node)
# Individu : Cotisations
if IDindividu in dictCotisations["individus"]:
node_cotisations = doc.createElement(u"cotisations")
node_individu.appendChild(node_cotisations)
for dictCotisation in dictCotisations["individus"][
IDindividu]:
node = doc.createElement(u"cotisation")
node.setAttribute(
"date_saisie",
UTILS_Dates.DateDDEnFr(
dictCotisation["date_saisie"]))
node.setAttribute(
"date_creation_carte",
UTILS_Dates.DateDDEnFr(
dictCotisation["date_creation_carte"]))
node.setAttribute(
"date_debut",
UTILS_Dates.DateDDEnFr(
dictCotisation["date_debut"]))
node.setAttribute(
"date_fin",
UTILS_Dates.DateDDEnFr(
dictCotisation["date_fin"]))
node.setAttribute("numero",
dictCotisation["numero"])
node.setAttribute(
"type_cotisation",
dictCotisation["type_cotisation"])
node.setAttribute(
"nom_unite_cotisation",
dictCotisation["nom_unite_cotisation"])
node.setAttribute("observations",
dictCotisation["observations"])
node.setAttribute("activites",
dictCotisation["activites"])
node_cotisations.appendChild(node)
# Individu : Consommations
if IDfamille in dictConsommations:
if IDindividu in dictConsommations[IDfamille]:
node_consommations = doc.createElement(
u"consommations")
node_individu.appendChild(node_consommations)
for dictConso in dictConsommations[IDfamille][
IDindividu]:
node = doc.createElement(u"consommation")
node.setAttribute(
"date",
UTILS_Dates.DateEngFr(dictConso["date"]))
node.setAttribute("activite",
dictConso["nomActivite"])
node.setAttribute("etat", dictConso["etat"])
node.setAttribute("unite",
dictConso["nomUnite"])
node_consommations.appendChild(node)
# Renvoie le doc
return doc
def InitObjectListView(self):
# Création du imageList
for categorie, civilites in Civilites.LISTE_CIVILITES:
for IDcivilite, CiviliteLong, CiviliteAbrege, nomImage, genre in civilites:
indexImg = self.AddNamedImages(
nomImage,
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/%s" % nomImage),
wx.BITMAP_TYPE_PNG))
self.imgVert = self.AddNamedImages(
"vert",
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Ventilation_vert.png"),
wx.BITMAP_TYPE_PNG))
self.imgRouge = self.AddNamedImages(
"rouge",
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Ventilation_rouge.png"),
wx.BITMAP_TYPE_PNG))
self.imgOrange = self.AddNamedImages(
"orange",
wx.Bitmap(
Chemins.GetStaticPath("Images/16x16/Ventilation_orange.png"),
wx.BITMAP_TYPE_PNG))
def GetImageCivilite(track):
return track.nomImage
def GetImageVentilation(track):
if track.totalFacture == track.totalRegle:
return self.imgVert
if track.totalRegle == FloatToDecimal(
0.0) or track.totalRegle == None:
return self.imgRouge
if track.totalRegle < track.totalFacture:
return self.imgOrange
return self.imgRouge
def FormateDate(dateDD):
if dateDD == None: return ""
return UTILS_Dates.DateEngFr(str(dateDD))
def FormateMontant(montant):
if montant == None or montant == "": return ""
return u"%.2f %s" % (montant, SYMBOLE)
def FormateSolde(montant):
if montant == None: FloatToDecimal(0.0)
if montant == FloatToDecimal(0.0):
return u"%.2f %s" % (montant, SYMBOLE)
elif montant > FloatToDecimal(0.0):
return u"- %.2f %s" % (montant, SYMBOLE)
else:
return u"+ %.2f %s" % (montant, SYMBOLE)
def FormateAge(age):
if age == None: return ""
return _(u"%d ans") % age
def rowFormatter(listItem, track):
if track.valide == False:
listItem.SetTextColour(wx.Colour(150, 150, 150))
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = "#FFFFFF" # Vert
# Création des colonnes
listeColonnes = []
for dictChamp in LISTE_CHAMPS:
if dictChamp["afficher"] == True:
# stringConverter
if "stringConverter" in dictChamp:
stringConverter = dictChamp["stringConverter"]
if stringConverter == "date": stringConverter = FormateDate
elif stringConverter == "age": stringConverter = FormateAge
elif stringConverter == "montant":
stringConverter = FormateMontant
elif stringConverter == "solde":
stringConverter = FormateSolde
else:
stringConverter = None
else:
stringConverter = None
# Image Getter
if "imageGetter" in dictChamp:
imageGetter = dictChamp["imageGetter"]
if imageGetter == "civilite":
imageGetter = GetImageCivilite
elif imageGetter == "ventilation":
imageGetter = GetImageVentilation
else:
imageGetter = None
else:
imageGetter = None
# Création de la colonne
colonne = ColumnDefn(dictChamp["label"],
dictChamp["align"],
dictChamp["largeur"],
dictChamp["code"],
typeDonnee=dictChamp["typeDonnee"],
stringConverter=stringConverter,
imageGetter=imageGetter)
listeColonnes.append(colonne)
# Ajout des questions des questionnaires
listeColonnes.extend(
UTILS_Questionnaires.GetColonnesForOL(self.liste_questions))
# Ajout des infos individus
listeChamps = UTILS_Infos_individus.GetNomsChampsPossibles(
mode="individu+famille")
for titre, exemple, code in listeChamps:
if u"n°" not in titre and "_x_" not in code:
typeDonnee = UTILS_Infos_individus.GetTypeChamp(code)
code = code.replace("{", "").replace("}", "")
listeColonnes.append(
ColumnDefn(titre,
"left",
100,
code,
typeDonnee=typeDonnee,
visible=False))
#self.SetColumns(listeColonnes)
self.SetColumns2(colonnes=listeColonnes,
nomListe="OL_Liste_inscriptions")
# Regroupement
if self.regroupement != None:
#self.SetColonneTri(self.regroupement)
self.SetAlwaysGroupByColumn(self.regroupement)
self.SetShowGroups(True)
self.useExpansionColumn = False
else:
self.SetShowGroups(False)
self.useExpansionColumn = False
# Case à cocher
if self.checkColonne == True:
self.CreateCheckStateColumn(0)
if len(self.columns) > 0:
self.SetSortColumn(self.columns[1])
else:
if len(self.columns) > 0:
self.SetSortColumn(self.columns[0])
self.SetShowItemCounts(True)
self.SetEmptyListMsg(_(u"Aucune inscription"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetObjects(self.donnees)
def Importation_prestations(self):
""" Importation des données """
# Chargement des informations individuelles
self.infosIndividus = UTILS_Infos_individus.Informations(
date_reference=self.date_debut,
qf=True,
inscriptions=True,
messages=False,
infosMedicales=False,
cotisationsManquantes=False,
piecesManquantes=False,
questionnaires=True,
scolarite=True)
self.dictInfosIndividus = self.infosIndividus.GetDictValeurs(
mode="individu", ID=None, formatChamp=False)
self.dictInfosFamilles = self.infosIndividus.GetDictValeurs(
mode="famille", ID=None, formatChamp=False)
DB = GestionDB.DB()
# Récupèration de la ventilation des prestations de la période
conditionDepots = ""
if self.filtreDepots == True and self.filtreDepots_dateDebut != None and self.filtreDepots_dateFin != None:
conditionDepots = " AND (depots.date>='%s' and depots.date<='%s') " % (
self.filtreDepots_dateDebut, self.filtreDepots_dateFin)
conditionReglements = ""
if self.filtreReglements == True and self.filtreReglements_dateDebut != None and self.filtreReglements_dateFin != None:
conditionReglements = " AND (reglements.date_saisie>='%s' and reglements.date_saisie<='%s') " % (
self.filtreReglements_dateDebut, self.filtreReglements_dateFin)
req = """SELECT
ventilation.IDventilation, ventilation.IDreglement, ventilation.IDprestation, ventilation.montant,
reglements.date, reglements.date_saisie, depots.date,
prestations.date
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
WHERE prestations.date>='%s' AND prestations.date <='%s' %s %s
ORDER BY prestations.date; """ % (self.date_debut, self.date_fin,
conditionDepots, conditionReglements)
DB.ExecuterReq(req)
listeVentilation = DB.ResultatReq()
dictVentilation = {}
for IDventilation, IDreglement, IDprestation, montantVentilation, dateReglement, dateSaisieReglement, dateDepotReglement, datePrestation in listeVentilation:
if dictVentilation.has_key(IDprestation) == False:
dictVentilation[IDprestation] = 0.0
dictVentilation[IDprestation] += montantVentilation
# Condition Afficher Cotisations et/ou Consommations ?
listeAffichage = []
if self.afficher_cotisations == True:
listeAffichage.append("cotisation")
if self.afficher_consommations == True:
listeAffichage.append("consommation")
if self.afficher_autres == True: listeAffichage.append("autre")
if len(listeAffichage) == 0: conditionAfficher = "categorie='xxxxxxx' "
elif len(listeAffichage) == 1:
conditionAfficher = "categorie='%s'" % listeAffichage[0]
else:
conditionAfficher = "categorie IN %s" % str(tuple(listeAffichage))
# Condition Activités affichées
if len(self.listeActivites) == 0:
conditionActivites = "prestations.IDactivite=9999999"
elif len(self.listeActivites) == 1:
conditionActivites = "prestations.IDactivite=%d" % self.listeActivites[
0]
else:
conditionActivites = "prestations.IDactivite IN %s" % str(
tuple(self.listeActivites))
# Filtre Prestation facturée / non facturée
conditionFacturee = ""
if "facturee" in self.mode_affichage:
conditionFacturee = " AND prestations.IDfacture IS NOT NULL"
if "nonfacturee" in self.mode_affichage:
conditionFacturee = " AND prestations.IDfacture IS NULL"
# Récupération de toutes les prestations de la période
req = """SELECT IDprestation, date, categorie, label, montant, prestations.IDactivite, prestations.IDcategorie_tarif, IDfamille, IDindividu, activites.nom, categories_tarifs.nom
FROM prestations
LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = prestations.IDcategorie_tarif
WHERE date>='%s' AND date <='%s'
AND %s AND (%s OR prestations.IDactivite IS NULL)
%s
ORDER BY date; """ % (self.date_debut, self.date_fin,
conditionAfficher, conditionActivites,
conditionFacturee)
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
# Récupération des tranches de tarifs paramétrées
if len(self.listeActivites) == 0:
condition = ""
else:
condition = "AND %s" % conditionActivites.replace(
"prestations.", "")
req = """SELECT IDligne, qf_min, qf_max
FROM tarifs_lignes
WHERE qf_min IS NOT NULL AND qf_max IS NOT NULL
%s
;""" % condition
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
liste_tranches = []
for IDligne, qf_min, qf_max in listeDonnees:
tranche = (int(qf_min), int(qf_max))
if tranche not in liste_tranches:
liste_tranches.append(tranche)
liste_tranches.sort()
DB.Close()
dictPrestations = {}
listeRegroupements = []
dictLabelsRegroupements = {}
for IDprestation, date, categorie, label, montant, IDactivite, IDcategorie_tarif, IDfamille, IDindividu, nom_activite, nom_categorie in listePrestations:
date = UTILS_Dates.DateEngEnDateDD(date)
annee = date.year
mois = date.month
if montant == None:
montant = 0.0
regroupement = None
if self.mode_regroupement == "jour":
regroupement = date
labelRegroupement = UTILS_Dates.DateEngFr(date)
if self.mode_regroupement == "mois":
regroupement = (annee, mois)
labelRegroupement = PeriodeComplete(mois, annee)
if self.mode_regroupement == "annee":
regroupement = annee
labelRegroupement = str(annee)
if self.mode_regroupement == "activite":
regroupement = IDactivite
labelRegroupement = nom_activite
if self.mode_regroupement == "categorie_tarif":
regroupement = IDcategorie_tarif
labelRegroupement = nom_categorie
if self.mode_regroupement == "ville_residence" and IDindividu not in (
0, None):
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_VILLE"]
labelRegroupement = regroupement
if self.mode_regroupement == "secteur" and IDindividu not in (
0, None):
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_SECTEUR"]
labelRegroupement = regroupement
if self.mode_regroupement == "age" and IDindividu not in (0, None):
regroupement = self.dictInfosIndividus[IDindividu][
"INDIVIDU_AGE_INT"]
labelRegroupement = str(regroupement)
if self.mode_regroupement == "nom_ecole" and IDindividu not in (
0, None):
regroupement = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_ECOLE"]
labelRegroupement = regroupement
if self.mode_regroupement == "nom_classe" and IDindividu not in (
0, None):
regroupement = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_CLASSE"]
labelRegroupement = regroupement
if self.mode_regroupement == "nom_niveau_scolaire" and IDindividu not in (
0, None):
regroupement = self.dictInfosIndividus[IDindividu][
"SCOLARITE_NOM_NIVEAU"]
labelRegroupement = regroupement
if self.mode_regroupement == "regime":
regroupement = self.dictInfosFamilles[IDfamille][
"FAMILLE_NOM_REGIME"]
labelRegroupement = regroupement
if self.mode_regroupement == "caisse":
regroupement = self.dictInfosFamilles[IDfamille][
"FAMILLE_NOM_CAISSE"]
labelRegroupement = regroupement
# QF
if self.mode_regroupement.startswith("qf"):
regroupement = None
if self.dictInfosFamilles[IDfamille].has_key(
"FAMILLE_QF_ACTUEL_INT"):
qf = self.dictInfosFamilles[IDfamille][
"FAMILLE_QF_ACTUEL_INT"]
# Tranches de 100
if self.mode_regroupement == "qf_100":
for x in range(0, 10000, 100):
min, max = x, x + 99
if qf >= min and qf <= max:
regroupement = (min, max)
labelRegroupement = "%s - %s" % (min, max)
# Tranches paramétrées
if self.mode_regroupement == "qf_tarifs":
for min, max in liste_tranches:
if qf >= min and qf <= max:
regroupement = (min, max)
labelRegroupement = "%s - %s" % (min, max)
# Questionnaires
if self.mode_regroupement.startswith(
"question_") and "famille" in self.mode_regroupement:
regroupement = self.dictInfosFamilles[IDfamille][
"QUESTION_%s" % self.mode_regroupement[17:]]
labelRegroupement = unicode(regroupement)
if self.mode_regroupement.startswith(
"question_"
) and "individu" in self.mode_regroupement and IDindividu not in (
0, None):
regroupement = self.dictInfosIndividus[IDindividu][
"QUESTION_%s" % self.mode_regroupement[18:]]
labelRegroupement = unicode(regroupement)
if regroupement in ("", None):
regroupement = _(u"- Autre -")
labelRegroupement = regroupement
# Mémorisation du regroupement
if regroupement not in listeRegroupements:
listeRegroupements.append(regroupement)
dictLabelsRegroupements[regroupement] = labelRegroupement
# Total
if dictPrestations.has_key(label) == False:
dictPrestations[label] = {
"nbre": 0,
"facture": 0.0,
"regle": 0.0,
"impaye": 0.0,
"regroupements": {}
}
dictPrestations[label]["nbre"] += 1
dictPrestations[label]["facture"] += montant
# Détail par période
if dictPrestations[label]["regroupements"].has_key(
regroupement) == False:
dictPrestations[label]["regroupements"][regroupement] = {
"nbre": 0,
"facture": 0.0,
"regle": 0.0,
"impaye": 0.0,
"categories": {}
}
dictPrestations[label]["regroupements"][regroupement]["nbre"] += 1
dictPrestations[label]["regroupements"][regroupement][
"facture"] += montant
# Détail par catégorie de tarifs
if dictPrestations[label]["regroupements"][regroupement][
"categories"].has_key(IDcategorie_tarif) == False:
dictPrestations[label]["regroupements"][regroupement][
"categories"][IDcategorie_tarif] = {
"nbre": 0,
"facture": 0.0,
"regle": 0.0,
"impaye": 0.0
}
dictPrestations[label]["regroupements"][regroupement][
"categories"][IDcategorie_tarif]["nbre"] += 1
dictPrestations[label]["regroupements"][regroupement][
"categories"][IDcategorie_tarif]["facture"] += montant
# Ajoute la ventilation
if dictVentilation.has_key(IDprestation):
dictPrestations[label]["regle"] += dictVentilation[
IDprestation]
dictPrestations[label]["regroupements"][regroupement][
"regle"] += dictVentilation[IDprestation]
dictPrestations[label]["regroupements"][regroupement][
"categories"][IDcategorie_tarif][
"regle"] += dictVentilation[IDprestation]
# Calcule les impayés
dictPrestations[label]["impaye"] = dictPrestations[label][
"regle"] - dictPrestations[label]["facture"]
dictPrestations[label]["regroupements"][regroupement][
"impaye"] = dictPrestations[label]["regroupements"][
regroupement]["regle"] - dictPrestations[label][
"regroupements"][regroupement]["facture"]
dictPrestations[label]["regroupements"][regroupement][
"categories"][IDcategorie_tarif]["impaye"] = dictPrestations[
label]["regroupements"][regroupement]["categories"][
IDcategorie_tarif]["regle"] - dictPrestations[label][
"regroupements"][regroupement]["categories"][
IDcategorie_tarif]["facture"]
listeRegroupements.sort()
return dictPrestations, listeRegroupements, dictLabelsRegroupements
def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur(
"couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
liste_Colonnes = [
ColumnDefn(_(u"ID"), "left", 0, "IDfamille", typeDonnee="entier"),
ColumnDefn(_(u"Famille"),
'left',
250,
"nomTitulaires",
typeDonnee="texte"),
ColumnDefn(_(u"Rue"), "left", 160, "rue", typeDonnee="texte"),
ColumnDefn(_(u"C.P."), "left", 45, "cp", typeDonnee="texte"),
ColumnDefn(_(u"Ville"), "left", 120, "ville", typeDonnee="texte"),
ColumnDefn(_(u"Secteur"),
"left",
100,
"secteur",
typeDonnee="texte"),
ColumnDefn(_(u"Régime"),
"left",
130,
"regime",
typeDonnee="texte"),
ColumnDefn(_(u"Caisse"), "left", 130, "caisse",
typeDonnee="texte"),
ColumnDefn(_(u"Numéro Alloc."),
"left",
120,
"numAlloc",
typeDonnee="texte"),
]
# # Insertion des champs infos de base individus
# listeChamps = self.infosIndividus.GetNomsChampsPresents(mode="famille")
# for nomChamp in listeChamps :
# typeDonnee = UTILS_Infos_individus.GetTypeChamp(nomChamp)
# liste_Colonnes.append(ColumnDefn(nomChamp, "left", 100, nomChamp, typeDonnee=typeDonnee, visible=False))
listeChamps = UTILS_Infos_individus.GetNomsChampsPossibles(
mode="famille")
for titre, exemple, code in listeChamps:
if "_x_" in code:
nbre = 4
else:
nbre = 1
for x in range(1, nbre + 1):
titre2 = copy.copy(titre)
code2 = copy.copy(code)
typeDonnee = UTILS_Infos_individus.GetTypeChamp(code2)
code2 = code2.replace("{", "").replace("}", "").replace(
u"_x_", u"_%d_" % x)
titre2 = titre2.replace(u"n°x", u"n°%d" % x)
liste_Colonnes.append(
ColumnDefn(titre2,
"left",
100,
code2,
typeDonnee=typeDonnee,
visible=False))
# if u"n°" not in titre and "_x_" not in code:
# typeDonnee = UTILS_Infos_individus.GetTypeChamp(code)
# code = code.replace("{", "").replace("}", "")
# liste_Colonnes.append(ColumnDefn(titre, "left", 100, code, typeDonnee=typeDonnee, visible=False))
self.SetColumns2(colonnes=liste_Colonnes, nomListe="OL_Liste_familles")
self.SetEmptyListMsg(_(u"Aucune famille"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
if len(self.columns) > 1:
self.SetSortColumn(self.columns[1])
self.SetObjects(self.donnees)
def OnBoutonOk(self, event):
dictOptions = self.ctrl_parametres.GetOptions()
if dictOptions == False:
return
# Récupération des paramètres
listeIDfactures = []
montantTotal = FloatToDecimal(0.0)
for track in self.tracks:
listeIDfactures.append(track.IDfacture)
montantTotal += track.total
if len(listeIDfactures) == 0: conditionFactures = "()"
elif len(listeIDfactures) == 1:
conditionFactures = "(%d)" % listeIDfactures[0]
else:
conditionFactures = str(tuple(listeIDfactures))
DB = GestionDB.DB()
req = """
SELECT prestations.IDprestation, prestations.IDfacture, prestations.label, prestations.montant,
prestations.IDindividu, individus.nom, individus.prenom,
prestations.IDactivite, activites.nom
FROM prestations
LEFT JOIN individus ON prestations.IDindividu = individus.IDindividu
LEFT JOIN activites ON activites.IDactivite = prestations.IDactivite
WHERE prestations.IDfacture IN %s
GROUP BY prestations.IDprestation
ORDER BY prestations.date
;""" % conditionFactures
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
# Récupération des prélèvements
req = """SELECT
prelevements.IDprelevement, prelevements.prelevement_iban,
prelevements.IDfacture, lots_prelevements.date,
prelevement_reference_mandat, titulaire
FROM prelevements
LEFT JOIN lots_prelevements ON lots_prelevements.IDlot = prelevements.IDlot
WHERE prelevements.IDfacture IN %s
;""" % conditionFactures
DB.ExecuterReq(req)
listePrelevements = DB.ResultatReq()
# Pièces PES ORMC
req = """SELECT
pes_pieces.IDpiece, pes_pieces.prelevement_iban, pes_pieces.IDfacture,
pes_lots.date_prelevement, pes_pieces.prelevement_IDmandat, pes_pieces.prelevement_titulaire
FROM pes_pieces
LEFT JOIN pes_lots ON pes_lots.IDlot = pes_pieces.IDlot
WHERE pes_pieces.prelevement_IDmandat IS NOT NULL AND pes_pieces.prelevement=1 AND pes_pieces.IDfacture IN %s
;""" % conditionFactures
DB.ExecuterReq(req)
listePieces = DB.ResultatReq()
dictPrelevements = {}
for listeDonneesPrel in (listePrelevements, listePieces):
for IDprelevement, iban, IDfacture, datePrelevement, rum, titulaire in (
listeDonneesPrel):
datePrelevement = UTILS_Dates.DateEngFr(datePrelevement)
dictPrelevements[IDfacture] = {
"IDprelevement": IDprelevement,
"datePrelevement": datePrelevement,
"iban": iban,
"rum": rum,
"titulaire": titulaire
}
DB.Close()
# Calcul totaux prélèvements
nbrFactPrelev = len(dictPrelevements)
montantTotalPrelev = 0.0
for track in self.tracks:
if track.IDfacture in dictPrelevements:
montantTotalPrelev += -track.solde
dictPrestations = {}
dictIndividus = {}
dictActivites = {}
dictTotaux = {}
for IDprestation, IDfacture, label, montant, IDindividu, nom, prenom, IDactivite, nomActivite in listePrestations:
if dictActivites != None and (IDactivite
in dictActivites) == False:
dictActivites[IDactivite] = nomActivite
if IDindividu != None and (
IDindividu in dictIndividus) == False and prenom != None:
dictIndividus[IDindividu] = u"%s %s" % (nom, prenom)
if (IDfacture in dictPrestations) == False:
dictPrestations[IDfacture] = {}
if (IDindividu in dictPrestations[IDfacture]) == False:
dictPrestations[IDfacture][IDindividu] = {}
if (label in dictPrestations[IDfacture][IDindividu]) == False:
dictPrestations[IDfacture][IDindividu][label] = {
"quantite": 0,
"montant": 0.0,
"IDactivite": IDactivite
}
if (IDactivite in dictTotaux) == False:
dictTotaux[IDactivite] = {}
if (label in dictTotaux[IDactivite]) == False:
dictTotaux[IDactivite][label] = {"quantite": 0, "montant": 0.0}
dictTotaux[IDactivite][label]["quantite"] += 1
dictTotaux[IDactivite][label]["montant"] += montant
dictPrestations[IDfacture][IDindividu][label]["quantite"] += 1
dictPrestations[IDfacture][IDindividu][label]["montant"] += montant
# Création du PDF
from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
from reportlab.platypus.flowables import ParagraphAndImage, Image
from reportlab.rl_config import defaultPageSize
from reportlab.lib.units import inch, cm
from reportlab.lib.utils import ImageReader
from reportlab.lib import colors
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
self.hauteur_page = defaultPageSize[1]
self.largeur_page = defaultPageSize[0]
# Initialisation du PDF
PAGE_WIDTH, PAGE_HEIGHT = defaultPageSize
nomDoc = FonctionsPerso.GenerationNomDoc("RECAP_FACTURES", "pdf")
if sys.platform.startswith("win"): nomDoc = nomDoc.replace("/", "\\")
doc = SimpleDocTemplate(nomDoc, topMargin=30, bottomMargin=30)
story = []
largeurContenu = 520
# Création du titre du document
def Header():
dataTableau = []
largeursColonnes = ((420, 100))
dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today()))
dataTableau.append(
(dictOptions["titre_texte"], _(u"%s\nEdité le %s") %
(UTILS_Organisateur.GetNom(), dateDuJour)))
style = TableStyle([
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'TOP'),
('ALIGN', (0, 0), (0, 0),
ConvertAlignement1(dictOptions["titre_alignement"])),
('FONT', (0, 0), (0, 0), "Helvetica-Bold",
dictOptions["titre_taille_texte"]),
('ALIGN', (1, 0), (1, 0), 'RIGHT'),
('FONT', (1, 0), (1, 0), "Helvetica", 6),
])
tableau = Table(dataTableau, largeursColonnes)
tableau.setStyle(style)
story.append(tableau)
story.append(Spacer(0, 20))
# Insère un header
Header()
couleurFond1 = ConvertCouleurWXpourPDF(dictOptions["couleur_fond_1"])
couleurFond2 = ConvertCouleurWXpourPDF(dictOptions["couleur_fond_2"])
styleIntroduction = ParagraphStyle(
name="introduction",
fontName="Helvetica",
alignment=ConvertAlignement2(dictOptions["intro_alignement"]),
fontSize=dictOptions["intro_taille_texte"],
spaceAfter=0,
leading=8,
spaceBefore=0)
styleConclusion = ParagraphStyle(
name="conclusion",
fontName="Helvetica",
alignment=ConvertAlignement2(dictOptions["conclusion_alignement"]),
fontSize=dictOptions["conclusion_taille_texte"],
spaceAfter=0,
leading=8,
spaceBefore=0)
styleLabel = ParagraphStyle(name="label",
fontName="Helvetica",
alignment=1,
fontSize=5,
spaceAfter=0,
leading=8,
spaceBefore=0)
styleTexte = ParagraphStyle(name="label",
fontName="Helvetica",
alignment=0,
fontSize=7,
spaceAfter=0,
leading=8,
spaceBefore=0)
styleTexte2 = ParagraphStyle(name="label",
fontName="Helvetica",
alignment=1,
fontSize=7,
spaceAfter=0,
leading=8,
spaceBefore=0)
styleMontant = ParagraphStyle(name="label",
fontName="Helvetica",
alignment=2,
fontSize=7,
spaceAfter=0,
leading=8,
spaceBefore=0)
# Intro
story.append(Paragraph(dictOptions["intro_texte"], styleIntroduction))
story.append(Spacer(0, 20))
# Factures
if dictOptions["type_document"] in (0, 1):
for track in self.tracks:
numero = track.numero
if track.etat == "annulation":
numero = u"%s (Annulée)" % numero
solde = track.solde
if solde != 0.0:
solde = -solde
# Numéro de facture
dataTableau = []
largeursColonnes = [100, 100, largeurContenu - 100 - 100]
dataTableau.append((
_(u"Facture n°%s") % numero,
u"%.2f %s" % (solde, SYMBOLE),
_(u"Edité le %s | Echéance le %s | Période du %s au %s")
% (UTILS_Dates.DateDDEnFr(track.date_edition),
UTILS_Dates.DateDDEnFr(track.date_echeance),
UTILS_Dates.DateDDEnFr(track.date_debut),
UTILS_Dates.DateDDEnFr(track.date_fin)),
))
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('FONT', (0, 0), (1, -1), "Helvetica-Bold", 7),
('FONT', (2, -1), (2, -1), "Helvetica", 6),
('BACKGROUND', (0, 0), (-1, -1), couleurFond1),
('ALIGN', (2, -1), (2, -1), 'RIGHT'),
('BOX', (0, 0), (-1, -1), 0.25, colors.black),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
# Famille
if track.prelevement == True:
if track.IDfacture in dictPrelevements:
textePrelevement = _(
u"IBAN : %s | RUM : %s | Titulaire : %s | Le : %s "
) % (dictPrelevements[track.IDfacture]["iban"],
dictPrelevements[track.IDfacture]["rum"],
dictPrelevements[track.IDfacture]["titulaire"],
dictPrelevements[
track.IDfacture]["datePrelevement"])
else:
textePrelevement = _(
u"N° Compte : %s | Etab : %s | Guichet : %s | Clé : %s | Titulaire : %s"
) % (track.prelevement_numero, track.prelevement_etab,
track.prelevement_guichet, track.prelevement_cle,
track.prelevement_payeur)
else:
textePrelevement = u""
if track.adresse_famille["rue"] != None:
rue = track.adresse_famille["rue"]
else:
rue = u""
if track.adresse_famille["cp"] != None:
cp = track.adresse_famille["cp"]
else:
cp = u""
if track.adresse_famille["ville"] != None:
ville = track.adresse_famille["ville"]
else:
ville = u""
dataTableau = []
dataTableau.append(
(Paragraph(_(u"Famille"),
styleLabel), Paragraph(_(u"Adresse"),
styleLabel),
Paragraph(_(u"Prélèvement bancaire"), styleLabel)))
dataTableau.append(
(Paragraph(track.nomsTitulaires,
styleTexte), (Paragraph(rue, styleTexte),
Paragraph(u"%s %s" % (cp, ville),
styleTexte)),
Paragraph(textePrelevement, styleTexte)))
largeursColonnes = [180, 140, largeurContenu - 320]
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('TOPPADDING', (0, 0), (-1, 0), 0),
('BOTTOMPADDING', (0, 0), (-1, 0), -1),
('FONT', (0, -1), (-1, -1), "Helvetica", 7),
('GRID', (0, 0), (-1, 0), 0.25, colors.black),
('BOX', (0, 1), (-1, 1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
('BACKGROUND', (0, 0), (-1, 0), couleurFond2),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
# Récupération des champs personnalisés
dataTableau = []
label_1, label_2, label_3, question_1, question_2, question_3 = "", "", "", "", "", ""
for dictReponse in self.Questionnaires.GetDonnees(
track.IDfamille):
if dictReponse["champ"] == dictOptions["question_1"]:
label_1, question_1 = dictReponse[
"label"], dictReponse["reponse"]
if dictReponse["champ"] == dictOptions["question_2"]:
label_2, question_2 = dictReponse[
"label"], dictReponse["reponse"]
if dictReponse["champ"] == dictOptions["question_3"]:
label_3, question_3 = dictReponse[
"label"], dictReponse["reponse"]
if len(label_1) > 0 or len(label_2) > 0 or len(label_3) > 0:
dataTableau.append(
(Paragraph(label_1,
styleLabel), Paragraph(label_2, styleLabel),
Paragraph(label_3, styleLabel)))
dataTableau.append((Paragraph(question_1, styleTexte),
Paragraph(question_2, styleTexte),
Paragraph(question_3, styleTexte)))
largeursColonnes = [
largeurContenu / 3.0, largeurContenu / 3.0,
largeurContenu / 3.0
]
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('TOPPADDING', (0, 0), (-1, 0), 0),
('BOTTOMPADDING', (0, 0), (-1, 0), -1),
('FONT', (0, -1), (-1, -1), "Helvetica", 7),
('GRID', (0, 0), (-1, 0), 0.25, colors.black),
('BOX', (0, 1), (-1, 1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
('BACKGROUND', (0, 0), (-1, 0), couleurFond2),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
# Détail des prestations
if dictOptions[
"type_document"] == 0 and track.IDfacture in dictPrestations:
# Préparation des champs individuels supplémentaires
liste_champs_ind = []
for key in ("champ_ind_1", "champ_ind_2", "champ_ind_3"):
if dictOptions[key] not in ("non", "", None):
liste_champs_ind.append(dictOptions[key])
if len(liste_champs_ind) == 0:
dataTableau = [
(Paragraph(_(u"Individu"), styleLabel),
Paragraph(_(u"Activité"), styleLabel),
Paragraph(_(u"Prestation"), styleLabel),
Paragraph(_(u"Quantité"), styleLabel),
Paragraph(_(u"Montant total"), styleLabel)),
]
largeursColonnes = [130, 120, 185, 35, 50]
else:
# On rajoute la colonne Infos individuelles :
dataTableau = [
(Paragraph(_(u"Individu"), styleLabel),
Paragraph(_(u"Informations"), styleLabel),
Paragraph(_(u"Activité"), styleLabel),
Paragraph(_(u"Prestation"), styleLabel),
Paragraph(_(u"Quantité"), styleLabel),
Paragraph(_(u"Montant total"), styleLabel)),
]
largeursColonnes = [120, 110, 100, 105, 35, 50]
for IDindividu, dictLabels in dictPrestations[
track.IDfacture].items():
if IDindividu in dictIndividus:
labelIndividu = dictIndividus[IDindividu]
else:
labelIndividu = u""
listeActivites = []
listeLabels = []
listeQuantites = []
listeMontants = []
for labelPrestation, dictTemp in dictLabels.items():
if dictTemp["IDactivite"] != None and dictTemp[
"IDactivite"] in dictActivites:
labelActivite = dictActivites[
dictTemp["IDactivite"]]
else:
labelActivite = u""
listeActivites.append(
Paragraph(labelActivite[:35], styleTexte2))
listeLabels.append(
Paragraph(labelPrestation[:40], styleTexte2))
listeQuantites.append(
Paragraph(str(dictTemp["quantite"]),
styleTexte2))
listeMontants.append(
Paragraph(
u"%.2f %s" %
(dictTemp["montant"], SYMBOLE),
styleMontant))
ligne = [
Paragraph(labelIndividu, styleTexte2),
listeActivites,
listeLabels,
listeQuantites,
listeMontants,
]
# Récupération des infos individuelles
if len(liste_champs_ind) > 0:
liste_textes_ind = []
for key in liste_champs_ind:
# Ecole
if "ecole" in key or "classe" in key or "niveau" in key:
if "date_debut" in key:
date_reference = track.date_debut
else:
date_reference = track.date_fin
infosIndividus = UTILS_Infos_individus.Informations(
date_reference=date_reference,
qf=False,
inscriptions=False,
messages=False,
infosMedicales=False,
cotisationsManquantes=False,
piecesManquantes=False,
questionnaires=False,
scolarite=True)
dictInfosIndividus = infosIndividus.GetDictValeurs(
mode="individu",
ID=IDindividu,
formatChamp=False)
texte = ""
if "ecole" in key and "SCOLARITE_NOM_ECOLE" in dictInfosIndividus:
texte = dictInfosIndividus[
"SCOLARITE_NOM_ECOLE"]
if "classe" in key and "SCOLARITE_NOM_CLASSE" in dictInfosIndividus:
texte = dictInfosIndividus[
"SCOLARITE_NOM_CLASSE"]
if "niveau" in key and "SCOLARITE_NOM_NIVEAU" in dictInfosIndividus:
texte = dictInfosIndividus[
"SCOLARITE_NOM_NIVEAU"]
liste_textes_ind.append(
Paragraph(texte, styleTexte2))
ligne.insert(1, liste_textes_ind)
# Insertion de la ligne dans le tableau
dataTableau.append(ligne)
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('TOPPADDING', (0, 0), (-1, 0), 0),
('BOTTOMPADDING', (0, 0), (-1, 0), -1),
('FONT', (0, -1), (-1, -1), "Helvetica", 7),
('GRID', (0, 0), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
('BACKGROUND', (0, 0), (-1, 0), couleurFond2),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
story.append(Spacer(0, 10))
# Totaux
dataTableau = [
(_(u"Totaux par activités et prestations"), "", "", ""),
(Paragraph(_(u"Activités"),
styleLabel), Paragraph(_(u"Prestations"), styleLabel),
Paragraph(_(u"Quantité"),
styleLabel), Paragraph(_(u"Montant"), styleLabel)),
]
largeursColonnes = [195, 240, 35, 50]
for IDactivite, dictLabels in dictTotaux.items():
if IDactivite == None:
nomActivite = _(u"Prestations diverses")
else:
nomActivite = dictActivites[IDactivite]
listeLabels = []
listeQuantites = []
listeMontants = []
quantiteActivite = 0
totalActivite = 0.0
for label, dictTemp in dictLabels.items():
listeLabels.append(Paragraph(label, styleTexte2))
listeQuantites.append(
Paragraph(str(dictTemp["quantite"]), styleTexte2))
listeMontants.append(
Paragraph(u"%.2f %s" % (dictTemp["montant"], SYMBOLE),
styleMontant))
quantiteActivite += dictTemp["quantite"]
totalActivite += dictTemp["montant"]
listeLabels.append(
Paragraph(_(u"<b><i>Total de l'activité</i></b>"),
styleTexte2))
listeQuantites.append(
Paragraph("<b><i>%d</i></b>" % quantiteActivite, styleTexte2))
listeMontants.append(
Paragraph(u"<b><i>%.2f %s</i></b>" % (totalActivite, SYMBOLE),
styleMontant))
dataTableau.append((
Paragraph(nomActivite, styleTexte2),
listeLabels,
listeQuantites,
listeMontants,
))
tableau = Table(dataTableau, largeursColonnes)
listeStyles = [
('TOPPADDING', (0, 1), (-1, 1), 0),
('BOTTOMPADDING', (0, 1), (-1, 1), -1),
('FONT', (1, -1), (-1, -1), "Helvetica", 7),
('FONT', (0, 0), (0, 0), "Helvetica-Bold", 7),
('BOX', (0, 0), (-1, 0), 0.25, colors.black),
('GRID', (0, 1), (-1, -1), 0.25, colors.black),
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
('BACKGROUND', (0, 0), (-1, 0), couleurFond1),
('BACKGROUND', (0, 1), (-1, 1), couleurFond2),
]
tableau.setStyle(TableStyle(listeStyles))
story.append(tableau)
story.append(Spacer(0, 10))
# Texte de conclusion
conclusion_texte = dictOptions["conclusion_texte"]
conclusion_texte = conclusion_texte.replace("{NBRE_FACTURES}",
str(len(self.tracks)))
conclusion_texte = conclusion_texte.replace(
"{TOTAL_FACTURES}", u"%.2f %s" % (montantTotal, SYMBOLE))
conclusion_texte = conclusion_texte.replace("{NBRE_FACT_PRELEV}",
str(nbrFactPrelev))
conclusion_texte = conclusion_texte.replace(
"{TOTAL_FACT_PRELEV}", u"%.2f %s" % (montantTotalPrelev, SYMBOLE))
story.append(Paragraph(conclusion_texte, styleConclusion))
# Enregistrement et ouverture du PDF
try:
doc.build(story)
except Exception as err:
print("Erreur dans ouverture PDF :", err)
if "Permission denied" in err:
dlg = wx.MessageDialog(
None,
_(u"Noethys ne peut pas créer le PDF.\n\nVeuillez vérifier qu'un autre PDF n'est pas déjà ouvert en arrière-plan..."
), _(u"Erreur d'édition"), wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
FonctionsPerso.LanceFichierExterne(nomDoc)
def CreationPDF(self,
nomDoc=FonctionsPerso.GenerationNomDoc(
"INSCRIPTION", "pdf"),
afficherDoc=True):
dictChampsFusion = {}
# Récupération des valeurs de base
dictDonnees = DICT_DONNEES
# Récupération des infos sur l'organisme
DB = GestionDB.DB()
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
dictOrganisme["nom"] = nom
dictOrganisme["rue"] = rue
dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
dictOrganisme["ville"] = ville
dictOrganisme["tel"] = tel
dictOrganisme["fax"] = fax
dictOrganisme["mail"] = mail
dictOrganisme["site"] = site
dictOrganisme["num_agrement"] = num_agrement
dictOrganisme["num_siret"] = num_siret
dictOrganisme["code_ape"] = code_ape
DB.Close()
date_editionDD = datetime.date.today()
# Adresse
self.IDindividu = self.dictInscription["IDINDIVIDU"]
individus = UTILS_Titulaires.GetIndividus()
self.dictInscription["INDIVIDU_RUE"] = individus[
self.IDindividu]["rue"]
self.dictInscription["INDIVIDU_CP"] = individus[self.IDindividu]["cp"]
self.dictInscription["INDIVIDU_VILLE"] = individus[
self.IDindividu]["ville"]
# Nom Titulaires
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille=[
self.IDfamille,
])
self.dictInscription["FAMILLE_NOM"] = dictTitulaires[
self.IDfamille]["titulairesSansCivilite"]
# Civilité
dictCivilites = Civilites.GetDictCivilites()
if self.dictInscription["IDCIVILITE"] == None or self.dictInscription[
"IDCIVILITE"] == "":
IDcivilite = 1
else:
IDcivilite = self.dictInscription["IDCIVILITE"]
self.dictInscription["INDIVIDU_GENRE"] = dictCivilites[IDcivilite][
"sexe"]
self.dictInscription["INDIVIDU_CIVILITE_LONG"] = dictCivilites[
IDcivilite]["civiliteLong"]
self.dictInscription["INDIVIDU_CIVILITE_COURT"] = dictCivilites[
IDcivilite]["civiliteAbrege"]
# Date de naissance
if self.dictInscription["INDIVIDU_DATE_NAISS"] == None:
self.dictInscription["INDIVIDU_AGE"] = None
else:
datenaissDD = datetime.date(
year=int(self.dictInscription["INDIVIDU_DATE_NAISS"][:4]),
month=int(self.dictInscription["INDIVIDU_DATE_NAISS"][5:7]),
day=int(self.dictInscription["INDIVIDU_DATE_NAISS"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
self.dictInscription["INDIVIDU_AGE"] = age
# Insertion des données de base dans le dictValeurs
IDfamille = self.IDfamille
dictValeurs = {
"IDfamille":
self.IDfamille,
"{IDFAMILLE}":
str(self.IDfamille),
"{DATE_EDITION}":
DateEngFr(str(date_editionDD)),
"{DATE_EDITION_LONG}":
DateComplete(date_editionDD),
"{DATE_EDITION_COURT}":
DateEngFr(str(date_editionDD)),
"{ORGANISATEUR_NOM}":
dictOrganisme["nom"],
"{ORGANISATEUR_RUE}":
dictOrganisme["rue"],
"{ORGANISATEUR_CP}":
dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}":
dictOrganisme["ville"],
"{ORGANISATEUR_TEL}":
dictOrganisme["tel"],
"{ORGANISATEUR_FAX}":
dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}":
dictOrganisme["mail"],
"{ORGANISATEUR_SITE}":
dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}":
dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}":
dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}":
dictOrganisme["code_ape"],
"{IDINSCRIPTION}":
FormateStr(self.dictInscription["IDINSCRIPTION"]),
"{DATE_INSCRIPTION}":
FormateDate(self.dictInscription["DATE_INSCRIPTION"]),
"{EST_PARTI}":
FormateBool(self.dictInscription["EST_PARTI"]),
"{IDACTIVITE}":
FormateStr(self.dictInscription["IDACTIVITE"]),
"{ACTIVITE_NOM_LONG}":
FormateStr(self.dictInscription["ACTIVITE_NOM_LONG"]),
"{ACTIVITE_NOM_COURT}":
FormateStr(self.dictInscription["ACTIVITE_NOM_COURT"]),
"{IDGROUPE}":
FormateStr(self.dictInscription["IDGROUPE"]),
"{GROUPE_NOM_LONG}":
FormateStr(self.dictInscription["GROUPE_NOM_LONG"]),
"{GROUPE_NOM_COURT}":
FormateStr(self.dictInscription["GROUPE_NOM_COURT"]),
"{IDCATEGORIETARIF}":
FormateStr(self.dictInscription["IDCATEGORIETARIF"]),
"{NOM_CATEGORIE_TARIF}":
FormateStr(self.dictInscription["NOM_CATEGORIE_TARIF"]),
"{IDINDIVIDU}":
FormateStr(self.dictInscription["IDINDIVIDU"]),
"{INDIVIDU_CIVILITE_LONG}":
FormateStr(self.dictInscription["INDIVIDU_CIVILITE_LONG"]),
"{INDIVIDU_CIVILITE_COURT}":
FormateStr(self.dictInscription["INDIVIDU_CIVILITE_COURT"]),
"{INDIVIDU_GENRE}":
FormateStr(self.dictInscription["INDIVIDU_GENRE"]),
"{INDIVIDU_NOM}":
FormateStr(self.dictInscription["INDIVIDU_NOM"]),
"{INDIVIDU_PRENOM}":
FormateStr(self.dictInscription["INDIVIDU_PRENOM"]),
"{INDIVIDU_DATE_NAISS}":
FormateDate(self.dictInscription["INDIVIDU_DATE_NAISS"]),
"{INDIVIDU_AGE}":
FormateStr(self.dictInscription["INDIVIDU_AGE"]),
"{INDIVIDU_CP_NAISS}":
FormateStr(self.dictInscription["INDIVIDU_CP_NAISS"]),
"{INDIVIDU_VILLE_NAISS}":
FormateStr(self.dictInscription["INDIVIDU_VILLE_NAISS"]),
"{INDIVIDU_RUE}":
FormateStr(self.dictInscription["INDIVIDU_RUE"]),
"{INDIVIDU_CP}":
FormateStr(self.dictInscription["INDIVIDU_CP"]),
"{INDIVIDU_VILLE}":
FormateStr(self.dictInscription["INDIVIDU_VILLE"]),
"{INDIVIDU_PROFESSION}":
FormateStr(self.dictInscription["INDIVIDU_PROFESSION"]),
"{INDIVIDU_EMPLOYEUR}":
FormateStr(self.dictInscription["INDIVIDU_EMPLOYEUR"]),
"{INDIVIDU_TEL_DOMICILE}":
FormateStr(self.dictInscription["INDIVIDU_TEL_DOMICILE"]),
"{INDIVIDU_TEL_MOBILE}":
FormateStr(self.dictInscription["INDIVIDU_TEL_MOBILE"]),
"{INDIVIDU_FAX}":
FormateStr(self.dictInscription["INDIVIDU_FAX"]),
"{INDIVIDU_EMAIL}":
FormateStr(self.dictInscription["INDIVIDU_EMAIL"]),
"{INDIVIDU_TEL_PRO}":
FormateStr(self.dictInscription["INDIVIDU_TEL_PRO"]),
"{INDIVIDU_FAX_PRO}":
FormateStr(self.dictInscription["INDIVIDU_FAX_PRO"]),
"{INDIVIDU_EMAIL_PRO}":
FormateStr(self.dictInscription["INDIVIDU_EMAIL_PRO"]),
"{FAMILLE_NOM}":
FormateStr(self.dictInscription["FAMILLE_NOM"]),
"{FAMILLE_CAISSE}":
FormateStr(self.dictInscription["FAMILLE_CAISSE"]),
"{FAMILLE_REGIME}":
FormateStr(self.dictInscription["FAMILLE_REGIME"]),
"{FAMILLE_NUMALLOC}":
FormateStr(self.dictInscription["FAMILLE_NUMALLOC"]),
}
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
dictValeurs.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
dictValeurs.update(
self.infosIndividus.GetDictValeurs(
mode="individu",
ID=self.dictInscription["IDINDIVIDU"],
formatChamp=True))
# Récupération des questionnaires
Questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="famille")
for dictReponse in Questionnaires.GetDonnees(IDfamille):
dictValeurs[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictValeurs["{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
# Récupération du signataire
infosSignataire = self.ctrl_signataire.GetInfos()
if infosSignataire == None:
dlg = wx.MessageDialog(
self, _(u"Vous n'avez sélectionné aucun signataire !"),
_(u"Annulation"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
nomSignataire = infosSignataire["nom"]
fonctionSignataire = infosSignataire["fonction"]
sexeSignataire = infosSignataire["sexe"]
if sexeSignataire == "H":
genreSignataire = u""
else:
genreSignataire = u"e"
# Récupération et transformation du texte d'intro
if self.ctrl_intro.GetValue() == True:
textIntro = self.ctrl_texte_intro.GetValue()
textIntro = textIntro.replace("{SIGNATAIRE_GENRE}",
genreSignataire)
textIntro = textIntro.replace("{SIGNATAIRE_NOM}", nomSignataire)
textIntro = textIntro.replace("{SIGNATAIRE_FONCTION}",
fonctionSignataire)
for key, valeur in dictValeurs.items():
if key.startswith("{"):
if valeur == None: valeur = ""
if type(valeur) == int: valeur = str(valeur)
textIntro = textIntro.replace(key, valeur)
dictValeurs["intro"] = textIntro
else:
dictValeurs["intro"] = None
# Tableau
dictValeurs["tableau"] = self.ctrl_tableau.GetValue()
for key, valeur in dictValeurs.items():
if valeur == None: valeur = ""
dictChampsFusion[key] = valeur
# Préparation des données pour une sauvegarde dans l'historique
self.dictSave = {}
self.dictSave["activite"] = self.dictInscription["ACTIVITE_NOM_LONG"]
self.dictSave["groupe"] = self.dictInscription["GROUPE_NOM_LONG"]
# Récupération du modèle
IDmodele = self.ctrl_modele.GetID()
if IDmodele == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un modèle !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Fabrication du PDF
from Utils import UTILS_Impression_inscription
UTILS_Impression_inscription.Impression(dictValeurs,
IDmodele=IDmodele,
nomDoc=nomDoc,
afficherDoc=afficherDoc)
return dictChampsFusion
def InitObjectListView(self):
# Couleur en alternance des lignes
self.oddRowsBackColor = UTILS_Interface.GetValeur("couleur_tres_claire", wx.Colour(240, 251, 237))
self.evenRowsBackColor = wx.Colour(255, 255, 255)
self.useExpansionColumn = True
# Préparation de la listeImages
imgOk = self.AddNamedImages("ok", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ok.png"), wx.BITMAP_TYPE_PNG))
imgPasOk = self.AddNamedImages("pasok", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Interdit.png"), wx.BITMAP_TYPE_PNG))
self.imgVert = self.AddNamedImages("vert", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ventilation_vert.png"), wx.BITMAP_TYPE_PNG))
self.imgRouge = self.AddNamedImages("rouge", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ventilation_rouge.png"), wx.BITMAP_TYPE_PNG))
self.imgOrange = self.AddNamedImages("orange", wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Ventilation_orange.png"), wx.BITMAP_TYPE_PNG))
def GetImageCreation(track):
if track.date_creation_carte == None : return "pasok"
else: return "ok"
def GetImageDepot(track):
if track.IDdepot_cotisation == None : return "pasok"
else: return "ok"
def FormateDate(dateDD):
if dateDD == None : return ""
if dateDD == "2999-01-01" : return _(u"Illimitée")
date = str(dateDD)
text = str(date[8:10]) + "/" + str(date[5:7]) + "/" + str(date[:4])
return text
def GetImageVentilation(track):
if track.montant == None :
return None
if track.montant == track.ventilation :
return self.imgVert
if track.ventilation == 0.0 or track.ventilation == None :
return self.imgRouge
if track.ventilation < track.montant :
return self.imgOrange
return self.imgRouge
def FormateMontant(montant):
if montant == None or montant == "" : return ""
return u"%.2f %s" % (montant, SYMBOLE)
def rowFormatter(listItem, track):
if track.valide == False and self.mode != "liste" :
listItem.SetTextColour((180, 180, 180))
dictColonnes = {
"IDcotisation" : ColumnDefn(u"", "left", 0, "IDcotisation", typeDonnee="entier"),
"date_debut" : ColumnDefn(u"Du", 'left', 80, "date_debut", typeDonnee="date", stringConverter=FormateDate),
"date_fin" : ColumnDefn(_(u"Au"), 'left', 80, "date_fin", typeDonnee="date", stringConverter=FormateDate),
"date_saisie" : ColumnDefn(_(u"Date saisie"), 'left', 80, "date_saisie", typeDonnee="date", stringConverter=FormateDate),
"beneficiaires" : ColumnDefn(_(u"Bénéficiaires"), 'left', 150, "beneficiaires", typeDonnee="texte"),
"rue" : ColumnDefn(_(u"Rue"), 'left', 120, "rue", typeDonnee="texte"),
"cp" : ColumnDefn(_(u"CP"), 'left', 70, "cp", typeDonnee="texte"),
"ville" : ColumnDefn(_(u"Ville"), 'left', 100, "ville", typeDonnee="texte"),
"type" : ColumnDefn(_(u"Type"), 'left', 110, "typeStr", typeDonnee="texte"),
"nom" : ColumnDefn(_(u"Nom"), 'left', 210, "nomCotisation", typeDonnee="texte"),
"type_cotisation" : ColumnDefn(_(u"Type"), 'left', 210, "nomTypeCotisation", typeDonnee="texte"),
"unite_cotisation" : ColumnDefn(_(u"Unité"), 'left', 90, "nomUniteCotisation", typeDonnee="texte"),
"numero" : ColumnDefn(_(u"Numéro"), 'left', 70, "numero", typeDonnee="texte"),
"montant" : ColumnDefn(_(u"Montant"), 'left', 70, "montant", typeDonnee="montant", stringConverter=FormateMontant),
"regle" : ColumnDefn(_(u"Réglé"), 'left', 70, "ventilation", typeDonnee="montant", stringConverter=FormateMontant),
"date_reglement" : ColumnDefn(_(u"Date réglement"), 'left', 80, "dateReglement", typeDonnee="date", stringConverter=FormateDate),
"mode_reglement" : ColumnDefn(_(u"Mode réglement"), 'left', 80, "modeReglement", typeDonnee="texte"),
"solde" : ColumnDefn(_(u"Solde"), 'left', 80, "solde", typeDonnee="montant", stringConverter=FormateMontant, imageGetter=GetImageVentilation),
"date_creation_carte" : ColumnDefn(_(u"Création carte"), 'left', 100, "date_creation_carte", typeDonnee="date", stringConverter=FormateDate, imageGetter=GetImageCreation),
"depot_nom" : ColumnDefn(_(u"Dépôt carte"), 'left', 100, "depotStr", typeDonnee="texte", imageGetter=GetImageDepot),
"activites" : ColumnDefn(_(u"Activités"), 'left', 150, "activitesStr", typeDonnee="texte"),
"observations" : ColumnDefn(_(u"Notes"), 'left', 150, "observations", typeDonnee="texte"),
}
self.rowFormatter = rowFormatter
listeColonnes = []
tri = None
index = 0
for codeColonne in self.codesColonnes :
listeColonnes.append(dictColonnes[codeColonne])
# Checkbox
if codeColonne == self.triColonne :
tri = index
index += 1
if self.mode == "liste":
listeChamps = UTILS_Infos_individus.GetNomsChampsPossibles(mode="individu+famille")
for titre, exemple, code in listeChamps :
if u"n°" not in titre and "_x_" not in code:
typeDonnee = UTILS_Infos_individus.GetTypeChamp(code)
code = code.replace("{", "").replace("}", "")
listeColonnes.append(ColumnDefn(titre, "left", 100, code, typeDonnee=typeDonnee, visible=False))
self.SetColumns2(colonnes=listeColonnes, nomListe="OL_Liste_cotisations")
else :
self.SetColumns(listeColonnes)
if self.checkColonne == True :
self.CreateCheckStateColumn(1)
if tri != None :
try:
if self.checkColonne == True : tri += 1
self.SetSortColumn(self.columns[tri])
except:
pass
self.SetEmptyListMsg(_(u"Aucune cotisation"))
self.SetEmptyListMsgFont(wx.FFont(11, wx.DEFAULT, False, "Tekton"))
self.SetObjects(self.donnees)
