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)