def FormateDateCourt(dateDD): if dateDD == None: return _(u"Jamais") else: return UTILS_Dates.DateEngFr(str(dateDD))
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
def GetDonneesImpression(self, listeInscriptions=[]): """ Impression des inscriptions """ dlgAttente = wx.BusyInfo(_(u"Recherche des données..."), None) # Récupère les données de la facture if len(listeInscriptions) == 0: conditions = "()" elif len(listeInscriptions) == 1: conditions = "(%d)" % listeInscriptions[0] else: conditions = str(tuple(listeInscriptions)) # Récupération des informations sur l'inscription dictChamps = { "inscriptions.IDinscription": "IDINSCRIPTION", "inscriptions.date_inscription": "DATE_INSCRIPTION", "inscriptions.date_desinscription": "EST_PARTI", "activites.IDactivite": "IDACTIVITE", "activites.nom": "ACTIVITE_NOM_LONG", "activites.abrege": "ACTIVITE_NOM_COURT", "groupes.IDgroupe": "IDGROUPE", "groupes.nom": "GROUPE_NOM_LONG", "groupes.abrege": "GROUPE_NOM_COURT", "categories_tarifs.IDcategorie_tarif": "IDCATEGORIETARIF", "categories_tarifs.nom": "NOM_CATEGORIE_TARIF", "individus.IDindividu": "IDINDIVIDU", "individus.IDcivilite": "IDCIVILITE", "individus.nom": "INDIVIDU_NOM", "individus.prenom": "INDIVIDU_PRENOM", "individus.date_naiss": "INDIVIDU_DATE_NAISS", "individus.cp_naiss": "INDIVIDU_CP_NAISS", "individus.ville_naiss": "INDIVIDU_VILLE_NAISS", "individus.adresse_auto": "INDIVIDU_ADRESSE_AUTO", "individus.rue_resid": "INDIVIDU_RUE", "individus.cp_resid": "INDIVIDU_CP", "individus.ville_resid": "INDIVIDU_VILLE", "individus.profession": "INDIVIDU_PROFESSION", "individus.employeur": "INDIVIDU_EMPLOYEUR", "individus.tel_domicile": "INDIVIDU_TEL_DOMICILE", "individus.tel_mobile": "INDIVIDU_TEL_MOBILE", "individus.tel_fax": "INDIVIDU_FAX", "individus.mail": "INDIVIDU_EMAIL", "individus.travail_tel": "INDIVIDU_TEL_PRO", "individus.travail_fax": "INDIVIDU_FAX_PRO", "individus.travail_mail": "INDIVIDU_EMAIL_PRO", "familles.IDfamille": "IDFAMILLE", "caisses.nom": "FAMILLE_CAISSE", "regimes.nom": "FAMILLE_REGIME", "familles.num_allocataire": "FAMILLE_NUMALLOC", } listeChamps = list(dictChamps.keys()) DB = GestionDB.DB() req = """SELECT %s FROM inscriptions LEFT JOIN activites ON activites.IDactivite = inscriptions.IDactivite LEFT JOIN groupes ON groupes.IDgroupe = inscriptions.IDgroupe LEFT JOIN categories_tarifs ON categories_tarifs.IDcategorie_tarif = inscriptions.IDcategorie_tarif LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu LEFT JOIN familles ON familles.IDfamille = inscriptions.IDfamille LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse LEFT JOIN regimes ON regimes.IDregime = caisses.IDregime WHERE IDinscription IN %s """ % (", ".join(listeChamps), conditions) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() DB.Close() if len(listeDonnees) == 0: del dlgAttente return False dictDonnees = {} dictChampsFusion = {} for item in listeDonnees: dictDonnee = {} index = 0 for nomChamp in listeChamps: code = dictChamps[nomChamp] valeur = item[index] dictDonnee["{%s}" % code] = valeur index += 1 IDinscription = dictDonnee["{IDINSCRIPTION}"] IDfamille = dictDonnee["{IDFAMILLE}"] IDindividu = dictDonnee["{IDINDIVIDU}"] # Famille if IDfamille != None: nomTitulaires = self.dictTitulaires[IDfamille][ "titulairesAvecCivilite"] famille_rue = self.dictTitulaires[IDfamille]["adresse"]["rue"] famille_cp = self.dictTitulaires[IDfamille]["adresse"]["cp"] famille_ville = self.dictTitulaires[IDfamille]["adresse"][ "ville"] else: nomTitulaires = "Famille inconnue" famille_rue = "" famille_cp = "" famille_ville = "" # Mémorisation des données dictDonnee.update({ "select": True, "{IDFAMILLE}": str(IDfamille), "{FAMILLE_NOM}": nomTitulaires, "{FAMILLE_RUE}": famille_rue, "{FAMILLE_CP}": famille_cp, "{FAMILLE_VILLE}": famille_ville, "{ORGANISATEUR_NOM}": self.dictOrganisme["nom"], "{ORGANISATEUR_RUE}": self.dictOrganisme["rue"], "{ORGANISATEUR_CP}": self.dictOrganisme["cp"], "{ORGANISATEUR_VILLE}": self.dictOrganisme["ville"], "{ORGANISATEUR_TEL}": self.dictOrganisme["tel"], "{ORGANISATEUR_FAX}": self.dictOrganisme["fax"], "{ORGANISATEUR_MAIL}": self.dictOrganisme["mail"], "{ORGANISATEUR_SITE}": self.dictOrganisme["site"], "{ORGANISATEUR_AGREMENT}": self.dictOrganisme["num_agrement"], "{ORGANISATEUR_SIRET}": self.dictOrganisme["num_siret"], "{ORGANISATEUR_APE}": self.dictOrganisme["code_ape"], "{DATE_EDITION_COURT}": UTILS_Dates.DateDDEnFr(datetime.date.today()), "{DATE_EDITION_LONG}": UTILS_Dates.DateComplete(datetime.date.today()), }) # Formatage spécial dictDonnee["{DATE_INSCRIPTION}"] = UTILS_Dates.DateEngFr( dictDonnee["{DATE_INSCRIPTION}"]) dictDonnee["{INDIVIDU_DATE_NAISS}"] = UTILS_Dates.DateEngFr( dictDonnee["{INDIVIDU_DATE_NAISS}"]) # Autres données if IDfamille != None: dictDonnee.update( self.infosIndividus.GetDictValeurs(mode="famille", ID=IDfamille, formatChamp=True)) # Ajoute les réponses des questionnaires for dictReponse in self.Questionnaires_familles.GetDonnees( IDfamille): dictDonnee[dictReponse["champ"]] = dictReponse["reponse"] if dictReponse["controle"] == "codebarres": dictDonnee[ "{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"] for dictReponse in self.Questionnaires_individus.GetDonnees( IDindividu): dictDonnee[dictReponse["champ"]] = dictReponse["reponse"] if dictReponse["controle"] == "codebarres": dictDonnee[ "{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"] for dictReponse in self.Questionnaires_inscriptions.GetDonnees( IDinscription): dictDonnee[dictReponse["champ"]] = dictReponse["reponse"] if dictReponse["controle"] == "codebarres": dictDonnee[ "{CODEBARRES_QUESTION_%d}" % dictReponse["IDquestion"]] = dictReponse["reponse"] dictDonnees[IDinscription] = dictDonnee # Champs de fusion pour Email dictChampsFusion[IDinscription] = {} for key, valeur in dictDonnee.items(): if key[0] == "{": dictChampsFusion[IDinscription][key] = valeur del dlgAttente return dictDonnees, dictChampsFusion
def Sauvegarde(self): # Récupération des tracks liste_tracks = self.ctrl_listview.GetTracksCoches() # Récupération des paramètres IDtype_cotisation = self.ctrl_parametres.ctrl_type.GetID() IDunite_cotisation = self.ctrl_parametres.ctrl_unite.GetID() date_saisie = self.ctrl_parametres.date_saisie IDutilisateur = self.ctrl_parametres.IDutilisateur date_debut = self.ctrl_parametres.ctrl_date_debut.GetDate() date_fin = self.ctrl_parametres.ctrl_date_fin.GetDate() activites = self.ctrl_parametres.ctrl_activites.GetDonnees( format="texte") observations = self.ctrl_parametres.ctrl_observations.GetValue() # Création de la carte if self.ctrl_parametres.ctrl_creation.GetValue() == True: numero_manuel = self.ctrl_parametres.radio_numero_manuel.GetValue() date_creation_carte = self.ctrl_parametres.ctrl_date_creation.GetDate( ) numero = self.ctrl_parametres.ctrl_numero.GetValue() else: numero_manuel = False date_creation_carte = None numero = None # Confirmation dlg = wx.MessageDialog( self, _(u"Confirmez-vous la génération de %d cotisations ?") % len(liste_tracks), _(u"Confirmation"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return False # Sauvegarde DB = GestionDB.DB() dlgprogress = wx.ProgressDialog(_(u"Génération des cotisations"), _(u"Veuillez patienter..."), maximum=len(liste_tracks), parent=None, style=wx.PD_SMOOTH | wx.PD_AUTO_HIDE | wx.PD_APP_MODAL) index = 1 for track in liste_tracks: dlgprogress.Update( index, _(u"Génération de la cotisation %d sur %d") % (index, len(liste_tracks))) if numero_manuel == True: numero = track.numero listeDonnees = [ ("IDfamille", track.IDfamille), ("IDindividu", track.IDindividu), ("IDtype_cotisation", IDtype_cotisation), ("IDunite_cotisation", IDunite_cotisation), ("date_saisie", date_saisie), ("IDutilisateur", IDutilisateur), ("date_creation_carte", date_creation_carte), ("numero", numero), ("date_debut", date_debut), ("date_fin", date_fin), ("observations", observations), ("activites", activites), ] IDcotisation = DB.ReqInsert("cotisations", listeDonnees) # Sauvegarde de la prestation facturer = self.ctrl_parametres.ctrl_facturer.GetValue() date_facturation = self.ctrl_parametres.ctrl_date_prestation.GetDate( ) montant = self.ctrl_parametres.ctrl_montant.GetMontant() label_prestation = self.ctrl_parametres.ctrl_label.GetValue() if facturer == True: # Création d'une prestation listeDonnees = [ ("IDcompte_payeur", track.IDcompte_payeur), ("date", date_facturation), ("categorie", "cotisation"), ("label", label_prestation), ("montant_initial", montant), ("montant", montant), ("IDfamille", track.IDfamille), ("IDindividu", track.IDindividu), ] listeDonnees.append( ("date_valeur", str(datetime.date.today()))) IDprestation = DB.ReqInsert("prestations", listeDonnees) # Insertion du IDprestation dans la cotisation DB.ReqMAJ("cotisations", [ ("IDprestation", IDprestation), ], "IDcotisation", IDcotisation) # Mémorise l'action dans l'historique date_debut_periode = UTILS_Dates.DateEngFr(str(date_debut)) date_fin_periode = UTILS_Dates.DateEngFr(str(date_fin)) UTILS_Historique.InsertActions([ { "IDindividu": track.IDindividu, "IDfamille": track.IDfamille, "IDcategorie": 21, "action": _(u"Saisie de la cotisation ID%d '%s' pour la période du %s au %s" ) % (IDcotisation, label_prestation, date_debut_periode, date_fin_periode), }, ]) # Génération du prochain numéro de cotisation if numero != None: numero = UTILS_Texte.Incrementer(numero) index += 1 DB.Close() dlgprogress.Destroy() # Succès dlg = wx.MessageDialog( self, _(u"Les %d cotisations ont été générées avec succès.") % len(liste_tracks), _(u"Fin"), wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() dlg.Destroy() return True
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 dictPieces["familles"].has_key(IDfamille) == False : dictPieces["familles"][IDfamille] = [] dictPieces["familles"][IDfamille].append(dictPiece) if public == "individu" : if dictPieces["individus"].has_key(IDindividu) == 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 dictCotisations["familles"].has_key(IDfamille) == False : dictCotisations["familles"][IDfamille] = [] dictCotisations["familles"][IDfamille].append(dictCotisation) if dictCotisation["type"] == "individu" : IDindividu = dictCotisation["IDindividu"] if dictCotisations["individus"].has_key(IDindividu) == 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 dictPrestations.has_key(IDfamille) == 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 dictConsommations.has_key(IDfamille) == False : dictConsommations[IDfamille] = {} if dictConsommations[IDfamille].has_key(IDindividu) == 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 dictVentilationFactures.has_key(IDfacture) : totalVentilation = FloatToDecimal(dictVentilationFactures[IDfacture]) else : totalVentilation = FloatToDecimal(0.0) if dictPrestationsFactures.has_key(IDfacture) : 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 dictFactures.has_key(IDfamille) == 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 dictReglements.has_key(IDfamille) == 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].iteritems(): if key.startswith("FAMILLE_"): node = doc.createElement(key.replace("FAMILLE_", "").lower()) node.setAttribute("valeur", unicode(valeur)) node_famille.appendChild(node) # Famille : Quotients if infos.dictFamilles[IDfamille].has_key("qf"): 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 infos.dictFamilles[IDfamille].has_key("messages"): 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 infos.dictFamilles[IDfamille].has_key("questionnaires"): 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", unicode(dictQuestionnaire["reponse"])) node_questionnaires.appendChild(node) # Famille : Pièces if dictPieces["familles"].has_key(IDfamille): 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 dictCotisations["familles"].has_key(IDfamille): 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 dictPrestations.has_key(IDfamille): 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 dictFactures.has_key(IDfamille): 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 dictReglements.has_key(IDfamille): 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 infos.dictRattachements["familles"].has_key(IDfamille): 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, (unicode, str)): node = doc.createElement(key.replace("INDIVIDU_", "").lower()) node.setAttribute("valeur", unicode(valeur)) node_individu.appendChild(node) # Individu : Messages if infos.dictIndividus[IDindividu].has_key("messages"): 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 infos.dictIndividus[IDindividu].has_key("medical"): 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 infos.dictIndividus[IDindividu].has_key("inscriptions"): 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 infos.dictIndividus[IDindividu].has_key("questionnaires"): 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", unicode(dictQuestionnaire["reponse"])) node_questionnaires.appendChild(node) # Individu : Scolarité if infos.dictIndividus[IDindividu].has_key("scolarite"): 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 dictPieces["individus"].has_key(IDindividu): 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 dictCotisations["individus"].has_key(IDindividu): 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 dictConsommations.has_key(IDfamille): if dictConsommations[IDfamille].has_key(IDindividu): 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 OnBoutonOk(self, event): dictOptions = self.ctrl_parametres.GetOptions() if dictOptions == False: return # Récupération des paramètres listeIDfactures = [] montantTotal = 0.0 for track in self.tracks: listeIDfactures.append(track.IDfacture) montantTotal += -track.solde 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 dictPrelevements.has_key(track.IDfacture): montantTotalPrelev += -track.solde dictPrestations = {} dictIndividus = {} dictActivites = {} dictTotaux = {} for IDprestation, IDfacture, label, montant, IDindividu, nom, prenom, IDactivite, nomActivite in listePrestations: if dictActivites != None and dictActivites.has_key( IDactivite) == False: dictActivites[IDactivite] = nomActivite if IDindividu != None and dictIndividus.has_key( IDindividu) == False and prenom != None: dictIndividus[IDindividu] = u"%s %s" % (nom, prenom) if dictPrestations.has_key(IDfacture) == False: dictPrestations[IDfacture] = {} if dictPrestations[IDfacture].has_key(IDindividu) == False: dictPrestations[IDfacture][IDindividu] = {} if dictPrestations[IDfacture][IDindividu].has_key(label) == False: dictPrestations[IDfacture][IDindividu][label] = { "quantite": 0, "montant": 0.0, "IDactivite": IDactivite } if dictTotaux.has_key(IDactivite) == False: dictTotaux[IDactivite] = {} if dictTotaux[IDactivite].has_key(label) == 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 dictPrelevements.has_key(track.IDfacture): 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 = [ (Paragraph(_(u"Famille"), styleLabel), Paragraph(_(u"Adresse"), styleLabel), Paragraph(_(u"Prélèvement bancaire"), styleLabel)), ] largeursColonnes = [180, 140, largeurContenu - 320] dataTableau.append(( Paragraph(track.nomsTitulaires, styleTexte), (Paragraph(rue, styleTexte), Paragraph(u"%s %s" % (cp, ville), styleTexte)), Paragraph(textePrelevement, styleTexte), )) 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 dictPrestations.has_key( track.IDfacture): 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] for IDindividu, dictLabels in dictPrestations[ track.IDfacture].iteritems(): if dictIndividus.has_key(IDindividu): labelIndividu = dictIndividus[IDindividu] else: labelIndividu = u"" listeActivites = [] listeLabels = [] listeQuantites = [] listeMontants = [] for labelPrestation, dictTemp in dictLabels.iteritems( ): if dictTemp[ "IDactivite"] != None and dictActivites.has_key( dictTemp["IDactivite"]): 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)) dataTableau.append(( Paragraph(labelIndividu, styleTexte2), listeActivites, listeLabels, listeQuantites, listeMontants, )) 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.iteritems(): if IDactivite == None: nomActivite = _(u"Prestations familiales") else: nomActivite = dictActivites[IDactivite] listeLabels = [] listeQuantites = [] listeMontants = [] quantiteActivite = 0 totalActivite = 0.0 for label, dictTemp in dictLabels.iteritems(): 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, 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
def Sauvegarde(self): # Récupération des tracks liste_tracks = self.ctrl_listview.GetTracksCoches() # Récupération des paramètres IDtype_cotisation = self.ctrl_parametres.ctrl_type.GetID() IDunite_cotisation = self.ctrl_parametres.ctrl_unite.GetID() date_saisie = self.ctrl_parametres.date_saisie IDutilisateur = self.ctrl_parametres.IDutilisateur date_debut = self.ctrl_parametres.ctrl_date_debut.GetDate() date_fin = self.ctrl_parametres.ctrl_date_fin.GetDate() activites = self.ctrl_parametres.ctrl_activites.GetDonnees( format="texte") observations = self.ctrl_parametres.ctrl_observations.GetValue() type_cotisation = self.ctrl_parametres.ctrl_type.GetDetailDonnees( )["type"] # Vérifie que les cotisations n'existent pas déj� liste_IDindividu = [ track.IDindividu for track in liste_tracks if track.IDindividu != None ] if len(liste_IDindividu) == 1: condition_individus = "AND cotisations.IDindividu == %d" % liste_IDindividu[ 0] elif len(liste_IDindividu) > 1: condition_individus = "AND cotisations.IDindividu IN %s" % str( tuple(liste_IDindividu)) else: condition_individus = "" liste_IDfamille = [ track.IDfamille for track in liste_tracks if track.IDfamille != None ] if len(liste_IDfamille) == 1: condition_familles = "AND cotisations.IDfamille == %d" % liste_IDfamille[ 0] elif len(liste_IDfamille) > 1: condition_familles = "AND cotisations.IDfamille IN %s" % str( tuple(liste_IDfamille)) else: condition_familles = "" DB = GestionDB.DB() req = """SELECT IDcotisation, IDfamille, cotisations.IDindividu, numero, individus.prenom, individus.nom FROM cotisations LEFT JOIN individus ON individus.IDindividu = cotisations.IDindividu WHERE IDtype_cotisation=%d AND IDunite_cotisation=%d %s %s;""" % (IDtype_cotisation, IDunite_cotisation, condition_individus, condition_familles) DB.ExecuterReq(req) listeCotisationsExistantes = DB.ResultatReq() DB.Close() if len(listeCotisationsExistantes) > 0: dictTitulaires = UTILS_Titulaires.GetTitulaires() liste_details = [] for IDcotisation, IDfamille, IDindividu, numero, prenom_individu, nom_individu in listeCotisationsExistantes: # Si cotisation familiale if IDfamille != None and IDfamille in dictTitulaires: nom_famille = dictTitulaires[IDfamille][ "titulairesSansCivilite"] liste_details.append( _(u"Famille de %s : Cotisation n°%s") % (nom_famille, numero)) # Si cotisation individuelle if IDindividu != None: if prenom_individu == None: prenom_individu = "" liste_details.append( _(u"%s %s : Cotisation n°%s") % (nom_individu, prenom_individu, numero)) # Demande si on continue ou non intro = _( u"Les cotisations suivantes existent déjà avec le même type et la même unité de cotisation :" ) conclusion = _( u"Souhaitez-vous quand même les générer une nouvelle fois ?" ) detail = "\n".join(liste_details) dlg = DLG_Messagebox.Dialog( self, titre=_(u"Avertissement"), introduction=intro, detail=detail, conclusion=conclusion, icone=wx.ICON_EXCLAMATION, boutons=[_(u"Oui"), _(u"Non"), _(u"Annuler")]) reponse = dlg.ShowModal() dlg.Destroy() if reponse in (1, 2): return False # Création de la carte if self.ctrl_parametres.ctrl_creation.GetValue() == True: numero_manuel = self.ctrl_parametres.radio_numero_manuel.GetValue() date_creation_carte = self.ctrl_parametres.ctrl_date_creation.GetDate( ) numero = self.ctrl_parametres.ctrl_numero.GetValue() else: numero_manuel = False date_creation_carte = None numero = None # Confirmation dlg = wx.MessageDialog( self, _(u"Confirmez-vous la génération de %d cotisations ?") % len(liste_tracks), _(u"Confirmation"), wx.YES_NO | wx.NO_DEFAULT | wx.CANCEL | wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES: return False # Sauvegarde DB = GestionDB.DB() dlgprogress = wx.ProgressDialog(_(u"Génération des cotisations"), _(u"Veuillez patienter..."), maximum=len(liste_tracks), parent=None, style=wx.PD_SMOOTH | wx.PD_AUTO_HIDE | wx.PD_APP_MODAL) index = 1 for track in liste_tracks: dlgprogress.Update( index, _(u"Génération de la cotisation %d sur %d") % (index, len(liste_tracks))) if numero_manuel == True: numero = track.numero if type_cotisation == "famille": IDfamille = track.IDfamille else: IDfamille = None listeDonnees = [ ("IDfamille", IDfamille), ("IDindividu", track.IDindividu), ("IDtype_cotisation", IDtype_cotisation), ("IDunite_cotisation", IDunite_cotisation), ("date_saisie", date_saisie), ("IDutilisateur", IDutilisateur), ("date_creation_carte", date_creation_carte), ("numero", numero), ("date_debut", date_debut), ("date_fin", date_fin), ("observations", observations), ("activites", activites), ] IDcotisation = DB.ReqInsert("cotisations", listeDonnees) # Sauvegarde de la prestation facturer = self.ctrl_parametres.ctrl_facturer.GetValue() date_facturation = self.ctrl_parametres.ctrl_date_prestation.GetDate( ) montant = self.ctrl_parametres.ctrl_montant.GetMontant() label_prestation = self.ctrl_parametres.ctrl_label.GetValue() if facturer == True: # Création d'une prestation listeDonnees = [ ("IDcompte_payeur", track.IDcompte_payeur), ("date", date_facturation), ("categorie", "cotisation"), ("label", label_prestation), ("montant_initial", montant), ("montant", montant), ("IDfamille", track.IDfamille), ("IDindividu", track.IDindividu), ] listeDonnees.append( ("date_valeur", str(datetime.date.today()))) IDprestation = DB.ReqInsert("prestations", listeDonnees) # Insertion du IDprestation dans la cotisation DB.ReqMAJ("cotisations", [ ("IDprestation", IDprestation), ], "IDcotisation", IDcotisation) # Mémorise l'action dans l'historique date_debut_periode = UTILS_Dates.DateEngFr(str(date_debut)) date_fin_periode = UTILS_Dates.DateEngFr(str(date_fin)) UTILS_Historique.InsertActions([ { "IDindividu": track.IDindividu, "IDfamille": track.IDfamille, "IDcategorie": 21, "action": _(u"Saisie de la cotisation ID%d '%s' pour la période du %s au %s" ) % (IDcotisation, label_prestation, date_debut_periode, date_fin_periode), }, ]) # Génération du prochain numéro de cotisation if numero != None: numero = UTILS_Texte.Incrementer(numero) index += 1 DB.Close() dlgprogress.Destroy() # Succès dlg = wx.MessageDialog( self, _(u"Les %d cotisations ont été générées avec succès.") % len(liste_tracks), _(u"Fin"), wx.OK | wx.ICON_INFORMATION) dlg.ShowModal() dlg.Destroy() # MAJ self.ctrl_listview.MAJ() return True
def Imprimer(self): # 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.pagesizes import A4 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 hauteur_page = A4[0] largeur_page = A4[1] # Initialisation du PDF nomDoc = FonctionsPerso.GenerationNomDoc("SYNTHESE_PRESTATIONS", "pdf") if sys.platform.startswith("win"): nomDoc = nomDoc.replace("/", "\\") doc = SimpleDocTemplate(nomDoc, pagesize=(largeur_page, hauteur_page), topMargin=30, bottomMargin=20, leftMargin=40, rightMargin=40) story = [] # Création du titre du document dataTableau = [] largeursColonnes = ((largeur_page - 175, 100)) dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today())) dataTableau.append( (_(u"Synthèse des prestations"), _(u"%s\nEdité le %s") % (UTILS_Organisateur.GetNom(), dateDuJour))) style = TableStyle([ ('BOX', (0, 0), (-1, -1), 0.25, colors.black), ('VALIGN', (0, 0), (-1, -1), 'TOP'), ('ALIGN', (0, 0), (0, 0), 'LEFT'), ('FONT', (0, 0), (0, 0), "Helvetica-Bold", 16), ('ALIGN', (1, 0), (1, 0), 'RIGHT'), ('FONT', (1, 0), (1, 0), "Helvetica", 6), ]) tableau = Table(dataTableau, largeursColonnes) tableau.setStyle(style) story.append(tableau) story.append(Spacer(0, 10)) # Intro styleA = ParagraphStyle(name="A", fontName="Helvetica", fontSize=6, spaceAfter=20) story.append(Paragraph(self.labelParametres, styleA)) # Tableau dataTableau = [] largeursColonnes = [ 160, ] for x in range(0, len(self.dictImpression["entete"]) - 1): largeursColonnes.append(45) # Entetes labels dataTableau.append(self.dictImpression["entete"]) # Contenu du tableau listeRubriques = ("contenu", "total") for rubrique in listeRubriques: listeLignes = self.dictImpression[rubrique] for ligne in listeLignes: dataTableau.append(ligne) positionLigneTotal = len(self.dictImpression["contenu"]) + 1 listeStyles = [ ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), # Centre verticalement toutes les cases ('FONT', (0, 0), (-1, -1), "Helvetica", 7), # Donne la police de caract. + taille de police ('GRID', (0, 0), (-1, -1), 0.25, colors.black), # Crée la bordure noire pour tout le tableau ('ALIGN', (0, 0), (-1, -1), 'CENTRE'), # Centre les cases ## ('ALIGN', (0,1), (-1,1), 'CENTRE'), # Ligne de labels colonne alignée au centre ## ('FONT',(0,1),(-1,1), "Helvetica", 6), # Donne la police de caract. + taille de police des labels ## ## ('SPAN',(0,0),(-1,0)), # Fusionne les lignes du haut pour faire le titre du groupe ## ('FONT',(0,0),(0,0), "Helvetica-Bold", 10), # Donne la police de caract. + taille de police du titre de groupe ('BACKGROUND', (0, 0), (-1, 0), (0.6, 0.6, 0.6) ), # Donne la couleur de fond du label ('BACKGROUND', (0, positionLigneTotal), (-1, positionLigneTotal), (0.6, 0.6, 0.6)), # Donne la couleur de fond du label ] # Formatage des lignes "Activités" for indexColoration in self.dictImpression["coloration"]: listeStyles.append( ('FONT', (0, indexColoration + 1), (-1, indexColoration + 1), "Helvetica-Bold", 7)) listeStyles.append(('BACKGROUND', (0, indexColoration + 1), (-1, indexColoration + 1), (0.8, 0.8, 0.8))) # Création du tableau tableau = Table(dataTableau, largeursColonnes) tableau.setStyle(TableStyle(listeStyles)) story.append(tableau) story.append(Spacer(0, 20)) # Enregistrement du PDF doc.build(story) # Affichage du PDF FonctionsPerso.LanceFichierExterne(nomDoc)
def Remplissage(self): # Tri des écoles par nom listeEcoles = [] for IDecole, dictEcole in self.dictEcoles.items(): listeEcoles.append((dictEcole["nom"], IDecole)) listeEcoles.sort() # Remplissage for nomEcole, IDecole in listeEcoles: dictEcole = self.dictEcoles[IDecole] # Initialise l'état des coches pour l'école if IDecole not in self.cochesActives: if self.cocherParDefaut is True: self.cochesEcolesActives.add(IDecole) self.cochesActives[IDecole] = set( [d["IDclasse"] for d in dictEcole["classes"]]) else: self.cochesActives[IDecole] = set() # Niveau Ecole niveauEcole = self.AppendItem(self.root, nomEcole, ct_type=1) self.SetPyData(niveauEcole, { "type": "ecole", "ID": IDecole, "nom": nomEcole }) self.SetItemBold(niveauEcole, True) # Niveau Classes for dictClasse in dictEcole["classes"]: IDclasse = dictClasse["IDclasse"] nomClasse = dictClasse["nom"] label = u"{0} (du {1} au {2})".format( nomClasse, UTILS_Dates.DateEngFr(dictClasse["date_debut"]), UTILS_Dates.DateEngFr(dictClasse["date_fin"]), ) niveauClasse = self.AppendItem(niveauEcole, label, ct_type=1) self.SetPyData( niveauClasse, { "type": "classe", "ID": IDclasse, "nom": nomClasse, "IDecole": IDecole, }) if IDclasse in self.cochesActives[IDecole]: self.CheckItem(niveauClasse) # Coche l'école et active ses classes if IDecole in self.cochesEcolesActives: self.CheckItem(niveauEcole) self.EnableChildren(niveauEcole, True) else: self.EnableChildren(niveauEcole, False) # Ajoute une entrée pour les enfants dont la scolarité est inconnue item = self.AppendItem(self.root, u"Scolarité inconnue", ct_type=1) self.SetPyData(item, {"type": "inconnu"}) if self.cocheInconnue: self.CheckItem(item) self.ExpandAllChildren(self.root)
def OnBoutonOk(self, event): dictParametres = self.ctrl_notebook.GetParametres() # Récupération et vérification des données listeActivites = dictParametres["liste_activites"] if len(listeActivites) == 0: self.ctrl_notebook.AffichePage("generalites") dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement cocher au moins une activité !" ), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Récupération et vérification des données listeGroupes = dictParametres["liste_groupes"] if len(dictParametres["liste_groupes"]) == 0: self.ctrl_notebook.AffichePage("generalites") dlg = wx.MessageDialog( self, _(u"Vous devez obligatoirement cocher au moins un groupe !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return False # Recherche les catégories utilisées liste_categories_utilisees = [] for nom_categorie, categories in dictParametres["colonnes"]: for IDcategorie in UTILS_Texte.ConvertStrToListe(categories): if IDcategorie not in liste_categories_utilisees: liste_categories_utilisees.append(IDcategorie) # Création du PDF from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak from reportlab.platypus.flowables import ParagraphAndImage, Image from reportlab.lib.pagesizes import A4 from reportlab.lib import colors from reportlab.lib.styles import ParagraphStyle self.taille_page = A4 if dictParametres["orientation"] == "portrait": self.hauteur_page = self.taille_page[1] self.largeur_page = self.taille_page[0] else: self.hauteur_page = self.taille_page[0] self.largeur_page = self.taille_page[1] # Création des conditions pour les requêtes SQL conditionsPeriodes = GetSQLdates(dictParametres["liste_periodes"]) if len(listeActivites) == 0: conditionActivites = "()" elif len(listeActivites) == 1: conditionActivites = "(%d)" % listeActivites[0] else: conditionActivites = str(tuple(listeActivites)) if len(listeGroupes) == 0: conditionGroupes = "()" elif len(listeGroupes) == 1: conditionGroupes = "(%d)" % listeGroupes[0] else: conditionGroupes = str(tuple(listeGroupes)) # Récupération des noms des groupes dictGroupes = dictParametres["dict_groupes"] DB = GestionDB.DB() # ------------ MODE PRESENTS --------------------------------- if dictParametres["mode"] == "presents": # Récupération de la liste des groupes ouverts sur cette période req = """SELECT IDouverture, IDactivite, IDunite, IDgroupe FROM ouvertures WHERE ouvertures.IDactivite IN %s AND %s AND IDgroupe IN %s ; """ % (conditionActivites, conditionsPeriodes, conditionGroupes) DB.ExecuterReq(req) listeOuvertures = DB.ResultatReq() dictOuvertures = {} for IDouverture, IDactivite, IDunite, IDgroupe in listeOuvertures: if dictOuvertures.has_key(IDactivite) == False: dictOuvertures[IDactivite] = [] if IDgroupe not in dictOuvertures[IDactivite]: dictOuvertures[IDactivite].append(IDgroupe) # Récupération des individus grâce à leurs consommations req = """SELECT individus.IDindividu, IDactivite, IDgroupe, IDcivilite, nom, prenom, date_naiss FROM consommations LEFT JOIN individus ON individus.IDindividu = consommations.IDindividu WHERE consommations.etat IN ("reservation", "present") AND IDactivite IN %s AND %s GROUP BY individus.IDindividu ORDER BY nom, prenom ;""" % (conditionActivites, conditionsPeriodes) DB.ExecuterReq(req) listeIndividus = DB.ResultatReq() # ------------ MODE INSCRITS --------------------------------- if dictParametres["mode"] == "inscrits": dictOuvertures = {} for IDgroupe, dictGroupe in dictGroupes.iteritems(): IDactivite = dictGroupe["IDactivite"] if dictOuvertures.has_key(IDactivite) == False: dictOuvertures[IDactivite] = [] if IDgroupe not in dictOuvertures[IDactivite]: dictOuvertures[IDactivite].append(IDgroupe) # Récupération des individus grâce à leurs consommations req = """SELECT individus.IDindividu, IDactivite, IDgroupe, IDcivilite, nom, prenom, date_naiss FROM individus LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu WHERE inscriptions.statut='ok' AND IDactivite IN %s GROUP BY individus.IDindividu ORDER BY nom, prenom ;""" % conditionActivites DB.ExecuterReq(req) listeIndividus = DB.ResultatReq() # Analyse des individus dictIndividus = {} listeIDindividus = [] for IDindividu, IDactivite, IDgroupe, IDcivilite, nom, prenom, date_naiss in listeIndividus: if date_naiss != None: date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss) age = self.GetAge(date_naiss) # Mémorisation de l'individu dictIndividus[IDindividu] = { "IDcivilite": IDcivilite, "nom": nom, "prenom": prenom, "age": age, "date_naiss": date_naiss, "IDgroupe": IDgroupe, "IDactivite": IDactivite, } # Mémorisation du IDindividu if IDindividu not in listeIDindividus: listeIDindividus.append(IDindividu) # Dict Informations médicales req = """SELECT IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical, description_traitement, date_debut_traitement, date_fin_traitement, eviction, date_debut_eviction, date_fin_eviction FROM problemes_sante WHERE diffusion_listing_enfants=1 ;""" DB.ExecuterReq(req) listeInformations = DB.ResultatReq() DB.Close() dictInfosMedicales = {} for IDprobleme, IDindividu, IDtype, intitule, date_debut, date_fin, description, traitement_medical, description_traitement, date_debut_traitement, date_fin_traitement, eviction, date_debut_eviction, date_fin_eviction in listeInformations: if dictInfosMedicales.has_key(IDindividu) == False: dictInfosMedicales[IDindividu] = [] dictTemp = { "IDprobleme": IDprobleme, "IDcategorie": IDtype, "intitule": intitule, "date_debut": date_debut, "date_fin": date_fin, "description": description, "traitement_medical": traitement_medical, "description_traitement": description_traitement, "date_debut_traitement": date_debut_traitement, "date_fin_traitement": date_fin_traitement, "eviction": eviction, "date_debut_eviction": date_debut_eviction, "date_fin_eviction": date_fin_eviction, } dictInfosMedicales[IDindividu].append(dictTemp) # Récupération des photos individuelles dictPhotos = {} taillePhoto = 128 if dictParametres["afficher_photos"] == "petite": tailleImageFinal = 16 if dictParametres["afficher_photos"] == "moyenne": tailleImageFinal = 32 if dictParametres["afficher_photos"] == "grande": tailleImageFinal = 64 if dictParametres["afficher_photos"] != "non": for IDindividu in listeIDindividus: IDcivilite = dictIndividus[IDindividu]["IDcivilite"] nomFichier = Chemins.GetStaticPath( "Images/128x128/%s" % DICT_CIVILITES[IDcivilite]["nomImage"]) IDphoto, bmp = CTRL_Photo.GetPhoto(IDindividu=IDindividu, nomFichier=nomFichier, taillePhoto=(taillePhoto, taillePhoto), qualite=100) # Création de la photo dans le répertoire Temp nomFichier = UTILS_Fichiers.GetRepTemp( fichier="photoTmp%d.jpg" % IDindividu) bmp.SaveFile(nomFichier, type=wx.BITMAP_TYPE_JPEG) img = Image(nomFichier, width=tailleImageFinal, height=tailleImageFinal) dictPhotos[IDindividu] = img # ---------------- Création du PDF ------------------- # Initialisation du PDF nomDoc = FonctionsPerso.GenerationNomDoc( "LISTE_INFORMATIONS_MEDICALES", "pdf") if sys.platform.startswith("win"): nomDoc = nomDoc.replace("/", "\\") doc = SimpleDocTemplate(nomDoc, pagesize=(self.largeur_page, self.hauteur_page), topMargin=30, bottomMargin=30) story = [] largeurContenu = self.largeur_page - 75 # Création du titre du document def Header(): dataTableau = [] largeursColonnes = ((largeurContenu - 100, 100)) dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today())) dataTableau.append( (_(u"Informations médicales"), _(u"%s\nEdité le %s") % (UTILS_Organisateur.GetNom(), dateDuJour))) style = TableStyle([ ('BOX', (0, 0), (-1, -1), 0.25, colors.black), ('VALIGN', (0, 0), (-1, -1), 'TOP'), ('ALIGN', (0, 0), (0, 0), 'LEFT'), ('FONT', (0, 0), (0, 0), "Helvetica-Bold", 16), ('ALIGN', (1, 0), (1, 0), 'RIGHT'), ('FONT', (1, 0), (1, 0), "Helvetica", 6), ]) tableau = Table(dataTableau, largeursColonnes) tableau.setStyle(style) story.append(tableau) story.append(Spacer(0, 20)) # Insère un header Header() # Activités for IDactivite in listeActivites: # Groupes if dictOuvertures.has_key(IDactivite): nbreGroupes = len(dictOuvertures[IDactivite]) indexGroupe = 1 for IDgroupe in dictOuvertures[IDactivite]: nomGroupe = dictGroupes[IDgroupe]["nom"] # Initialisation du tableau dataTableau = [] largeursColonnes = [] labelsColonnes = [] # Recherche des entêtes de colonnes : if dictParametres["afficher_photos"] != "non": labelsColonnes.append(_(u"Photo")) largeursColonnes.append(tailleImageFinal + 6) labelsColonnes.append(_(u"Nom - prénom")) if dictParametres["largeur_colonne_nom"] == "automatique": largeursColonnes.append(120) else: largeursColonnes.append( int(dictParametres["largeur_colonne_nom"])) if dictParametres["afficher_age"] == True: labelsColonnes.append(_(u"Âge")) if dictParametres[ "largeur_colonne_age"] == "automatique": largeursColonnes.append(20) else: largeursColonnes.append( int(dictParametres["largeur_colonne_age"])) # Calcule la largeur restante largeurRestante = largeurContenu - sum(largeursColonnes) # Calcul des largeurs de colonnes largeurColonnes = largeurRestante * 1.0 / len( dictParametres["colonnes"]) for nom_categorie, categories in dictParametres[ "colonnes"]: labelsColonnes.append(nom_categorie) largeursColonnes.append(largeurColonnes) # Création de l'entete de groupe ligne = [ nomGroupe, ] for x in range(0, len(labelsColonnes) - 1): ligne.append("") dataTableau.append(ligne) # Création des entêtes ligne = [] for label in labelsColonnes: ligne.append(label) dataTableau.append(ligne) # --------- Création des lignes ----------- # Création d'une liste temporaire pour le tri listeIndividus = [] if dictOuvertures.has_key(IDactivite): if IDgroupe in dictOuvertures[IDactivite]: for IDindividu in listeIDindividus: dictIndividu = dictIndividus[IDindividu] if dictIndividu["IDgroupe"] == IDgroupe: valeursTri = (IDindividu, dictIndividu["nom"], dictIndividu["prenom"], dictIndividu["age"]) # + Sélection uniquement des individus avec infos if dictParametres[ "individus_avec_infos"] == False or ( dictParametres[ "individus_avec_infos"] == True and dictInfosMedicales. has_key(IDindividu)): listeIndividus.append(valeursTri) if dictParametres["tri"] == "nom": paramTri = 1 # Nom if dictParametres["tri"] == "prenom": paramTri = 2 # Prénom if dictParametres["tri"] == "age": paramTri = 3 # Age if dictParametres["ordre"] == "croissant": ordreDecroissant = False else: ordreDecroissant = True listeIndividus = sorted(listeIndividus, key=operator.itemgetter(paramTri), reverse=ordreDecroissant) # Récupération des lignes individus for IDindividu, nom, prenom, age in listeIndividus: dictIndividu = dictIndividus[IDindividu] ligne = [] # Photo if dictParametres[ "afficher_photos"] != "non" and IDindividu in dictPhotos: img = dictPhotos[IDindividu] ligne.append(img) # Nom ligne.append(u"%s %s" % (nom, prenom)) # Age if dictParametres["afficher_age"] == True: if age != None: ligne.append(age) else: ligne.append("") # Informations médicales paraStyle = ParagraphStyle( name="infos", fontName="Helvetica", fontSize=7, leading=8, spaceAfter=2, ) # Création des colonnes has_infos = False for nom_categorie, categories in dictParametres[ "colonnes"]: liste_categories = UTILS_Texte.ConvertStrToListe( categories) case = [] # Recherche s'il y a une info médicale dans cette case if dictInfosMedicales.has_key(IDindividu): for infoMedicale in dictInfosMedicales[ IDindividu]: IDcategorie = infoMedicale["IDcategorie"] if IDcategorie in liste_categories or ( 0 in liste_categories and IDcategorie not in liste_categories_utilisees): intitule = infoMedicale["intitule"] description = infoMedicale[ "description"] traitement = infoMedicale[ "traitement_medical"] description_traitement = infoMedicale[ "description_traitement"] date_debut_traitement = infoMedicale[ "date_debut_traitement"] date_fin_traitement = infoMedicale[ "date_fin_traitement"] # Intitulé et description if description != None and description != "": texteInfos = u"<b>%s</b> : %s" % ( intitule, description) else: texteInfos = u"%s" % intitule if len(texteInfos ) > 0 and texteInfos[-1] != ".": texteInfos += u"." # Traitement médical if traitement == 1 and description_traitement != None and description_traitement != "": texteDatesTraitement = u"" if date_debut_traitement != None and date_fin_traitement != None: texteDatesTraitement = _( u" du %s au %s" ) % (UTILS_Dates.DateEngFr( date_debut_traitement), UTILS_Dates.DateEngFr( date_fin_traitement)) if date_debut_traitement != None and date_fin_traitement == None: texteDatesTraitement = _( u" à partir du %s" ) % UTILS_Dates.DateEngFr( date_debut_traitement) if date_debut_traitement == None and date_fin_traitement != None: texteDatesTraitement = _( u" jusqu'au %s" ) % UTILS_Dates.DateEngFr( date_fin_traitement) texteInfos += _( u"Traitement%s : %s.") % ( texteDatesTraitement, description_traitement) # Création du paragraphe case.append( Paragraph(texteInfos, paraStyle)) has_infos = True # Ajoute la case à la ligne ligne.append(case) # Ajout de la ligne individuelle dans le tableau if dictParametres["individus_avec_infos"] == False or ( dictParametres["individus_avec_infos"] == True and has_infos == True): dataTableau.append(ligne) # Création des lignes vierges for x in range(0, dictParametres["nbre_lignes_vierges"]): ligne = [] for col in labelsColonnes: ligne.append("") dataTableau.append(ligne) # Style du tableau couleur_fond_entetes = UTILS_Divers.ConvertCouleurWXpourPDF( dictParametres["couleur_fond_entetes"]) style = TableStyle([ ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), # Centre verticalement toutes les cases ('FONT', (0, 0), (-1, -1), "Helvetica", 7), # Donne la police de caract. + taille de police ('GRID', (0, 0), (-1, -1), 0.25, colors.black ), # Crée la bordure noire pour tout le tableau ('ALIGN', (0, 1), (-2, -1), 'CENTRE'), # Centre les cases ('ALIGN', (0, 1), (-1, 1), 'CENTRE' ), # Ligne de labels colonne alignée au centre ( 'FONT', (0, 1), (-1, 1), "Helvetica", 6 ), # Donne la police de caract. + taille de police des labels ( 'SPAN', (0, 0), (-1, 0) ), # Fusionne les lignes du haut pour faire le titre du groupe ( 'FONT', (0, 0), (0, 0), "Helvetica-Bold", 10 ), # Donne la police de caract. + taille de police du titre de groupe ('BACKGROUND', (0, 0), (-1, 0), couleur_fond_entetes ), # Donne la couleur de fond du titre de groupe ]) # Création du tableau tableau = Table(dataTableau, largeursColonnes) tableau.setStyle(style) story.append(tableau) story.append(Spacer(0, 20)) # Saut de page après un groupe if dictParametres["saut_page_groupe"] == True: story.append(PageBreak()) # Insère un header if indexGroupe < nbreGroupes: Header() indexGroupe += 1 # Enregistrement du PDF doc.build(story) # Affichage du PDF FonctionsPerso.LanceFichierExterne(nomDoc)
def FormateValeur(valeur): if type(valeur) == datetime.date: return UTILS_Dates.DateEngFr(str(valeur)) if valeur == None: return "" return valeur
def InitGrid(self): self.ResetGrid() # Récupération des données dictResultats, listeUnites, listeGroupes = self.Importation() if self.affichage_valeurs == "quantite": defaut = 0 else: defaut = datetime.timedelta(hours=0, minutes=0) listeGroupesUtilises = [] listeUnitesUtilises = [] listeRegroupement = [] dictTotaux = {"lignes": {}, "colonnes": {}} for IDgroupe, dictGroupe in dictResultats.items(): if IDgroupe not in listeGroupesUtilises: listeGroupesUtilises.append(IDgroupe) for IDunite, dictUnite in dictGroupe.items(): if IDunite not in listeUnitesUtilises: listeUnitesUtilises.append(IDunite) for regroupement, valeur in dictUnite.items(): if regroupement not in listeRegroupement: listeRegroupement.append(regroupement) # Calcul des totaux if ((IDgroupe, IDunite) in dictTotaux["lignes"]) == False: dictTotaux["lignes"][(IDgroupe, IDunite)] = defaut dictTotaux["lignes"][(IDgroupe, IDunite)] += valeur if (regroupement in dictTotaux["colonnes"]) == False: dictTotaux["colonnes"][regroupement] = defaut dictTotaux["colonnes"][regroupement] += valeur # Création des colonnes largeur_colonne = 80 dictColonnes = {} if self.affichage_colonnes == "unites_groupes": self.AppendCols(len(listeGroupes) * len(listeUnites)) index = 0 for IDunite, nomUnite, abregeUnite in listeUnites: for IDgroupe, nomGroupe, abregeGroupe in listeGroupes: self.SetColSize(index, largeur_colonne) if abregeGroupe == "" or abregeGroupe == None: abregeGroupe = nomGroupe if abregeUnite == "" or abregeUnite == None: abregeUnite = nomUnite self.SetColLabelValue( index, u"%s\n%s" % (abregeGroupe, abregeUnite)) dictColonnes[(IDgroupe, IDunite)] = index index += 1 elif self.affichage_colonnes == "unites_evenements": index = 0 for IDunite, nomUnite, abregeUnite in listeUnites: liste_events = [(dict_evenement["date"], dict_evenement["nom"], IDevenement) for IDevenement, dict_evenement in self.dictEvenements.items() if dict_evenement["IDunite"] == IDunite] if liste_events: liste_events.sort() self.AppendCols(len(liste_events)) for date, nomEvent, IDevenement in liste_events: if len(nomEvent) > 15: nomEvent = nomEvent[:15] + "." self.SetColSize(index, largeur_colonne + 25) self.SetColLabelValue( index, u"%s\n%s\n%s" % (nomEvent, UTILS_Dates.DateEngFr(date), abregeUnite)) dictColonnes[(IDevenement, IDunite)] = index index += 1 else: self.AppendCols(1) self.SetColLabelValue(index, u"%s" % abregeUnite) dictColonnes[(None, IDunite)] = index index += 1 else: self.AppendCols(len(listeUnites)) index = 0 for IDunite, nomUnite, abregeUnite in listeUnites: if abregeUnite == "" or abregeUnite == None: abregeUnite = nomUnite self.SetColSize(index, largeur_colonne) self.SetColLabelValue(index, u"%s" % abregeUnite) dictColonnes[(None, IDunite)] = index index += 1 # Colonne Total self.AppendCols(1) self.SetColSize(index, largeur_colonne) self.SetColLabelValue(index, _(u"TOTAL")) dictColonnes["total"] = index # Création des lignes listeRegroupement.sort() self.AppendRows(len(listeRegroupement)) index = 0 dictLignes = {} for regroupement in listeRegroupement: if self.affichage_lignes == "jour": label = DateComplete(regroupement) elif self.affichage_lignes == "mois": label = FormateMois(regroupement) elif self.affichage_lignes == "annee": label = str(regroupement) elif self.affichage_lignes == "evenement" and regroupement in self.dictEvenements: label = self.dictEvenements[regroupement]["nom"] elif self.affichage_lignes == "evenement_date" and regroupement in self.dictEvenements: label = u"%s (%s)" % ( self.dictEvenements[regroupement]["nom"], UTILS_Dates.DateDDEnFr( self.dictEvenements[regroupement]["date"])) elif self.affichage_lignes == "qf" and type(regroupement) == tuple: label = u"%d-%d" % regroupement else: label = six.text_type(regroupement) self.SetRowLabelValue(index, label) self.SetRowSize(index, 30) dictLignes[regroupement] = index index += 1 # Ligne Total self.AppendRows(1) self.SetRowLabelValue(index, _(u"TOTAL")) self.SetRowSize(index, 30) dictLignes["total"] = index # Remplissage des valeurs for IDgroupe, dictGroupe in dictResultats.items(): for IDunite, dictUnite in dictGroupe.items(): for regroupement, valeur in dictUnite.items(): label = FormateValeur(valeur, self.affichage_valeurs) numLigne = dictLignes[regroupement] numColonne = dictColonnes[(IDgroupe, IDunite)] self.SetCellValue(numLigne, numColonne, label) self.SetCellAlignment(numLigne, numColonne, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self.SetReadOnly(numLigne, numColonne, True) # Remplissage des totaux for (IDgroupe, IDunite), valeur in dictTotaux["lignes"].items(): label = FormateValeur(valeur, self.affichage_valeurs) numLigne = dictLignes["total"] numColonne = dictColonnes[(IDgroupe, IDunite)] self.SetCellValue(numLigne, numColonne, label) self.SetCellAlignment(numLigne, numColonne, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self.SetReadOnly(numLigne, numColonne, True) total_general = defaut for regroupement, valeur in dictTotaux["colonnes"].items(): total_general += valeur label = FormateValeur(valeur, self.affichage_valeurs) numLigne = dictLignes[regroupement] numColonne = dictColonnes["total"] self.SetCellValue(numLigne, numColonne, label) self.SetCellAlignment(numLigne, numColonne, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self.SetReadOnly(numLigne, numColonne, True) # Total général label = FormateValeur(total_general, self.affichage_valeurs) numLigne = dictLignes["total"] numColonne = dictColonnes["total"] self.SetCellValue(numLigne, numColonne, label) self.SetCellAlignment(numLigne, numColonne, wx.ALIGN_CENTRE, wx.ALIGN_CENTRE) self.SetReadOnly(numLigne, numColonne, True) # Coloration des TOTAUX couleurFond = (240, 240, 240) for x in range(0, numLigne + 1): self.SetCellBackgroundColour(x, numColonne, couleurFond) for y in range(0, numColonne): self.SetCellBackgroundColour(numLigne, y, couleurFond)
def GetCondition(titre="", typeDonnee="", choix="", criteres=""): description = u"" # TEXTE if typeDonnee == "texte": if choix == "EGAL": description = _(u"'%s' est égal à '%s'") % (titre, criteres) if choix == "DIFFERENT": description = _(u"'%s' est différent de '%s'") % (titre, criteres) if choix == "CONTIENT": description = _(u"'%s' contient '%s'") % (titre, criteres) if choix == "CONTIENTPAS": description = _(u"'%s' ne contient pas '%s'") % (titre, criteres) if choix == "VIDE": description = _(u"'%s' est vide") % titre if choix == "PASVIDE": description = _(u"'%s' n'est pas vide") % titre # BOOL if typeDonnee == "bool": if choix == "TRUE": description = _(u"'%s' est vrai") % titre if choix == "FALSE": description = _(u"'%s' est faux") % titre # ENTIER if typeDonnee == "entier": if choix == "EGAL": description = _(u"'%s' est égal à '%s'") % (titre, criteres) if choix == "DIFFERENT": description = _(u"'%s' est différent de '%s'") % (titre, criteres) if choix == "SUP": description = _(u"'%s' est supérieur à '%s'") % (titre, criteres) if choix == "SUPEGAL": description = _(u"'%s' est supérieur ou égal à '%s'") % ( titre, criteres) if choix == "INF": description = _(u"'%s' est inférieur à '%s'") % (titre, criteres) if choix == "INFEGAL": description = _(u"'%s' est inférieur ou égal à '%s'") % ( titre, criteres) if choix == "COMPRIS": description = _(u"'%s' est compris entre '%s' et '%s'") % ( titre, criteres.split(";")[0], criteres.split(";")[1]) # MONTANT if typeDonnee == "montant": if choix == "EGAL": description = _(u"'%s' est égal à %.2f %s") % ( titre, float(criteres), SYMBOLE) if choix == "DIFFERENT": description = _(u"'%s' est différent de %.2f %s") % ( titre, float(criteres), SYMBOLE) if choix == "SUP": description = _(u"'%s' est supérieur à %.2f %s") % ( titre, float(criteres), SYMBOLE) if choix == "SUPEGAL": description = _(u"'%s' est supérieur ou égal à %.2f %s") % ( titre, float(criteres), SYMBOLE) if choix == "INF": description = _(u"'%s' est inférieur à %.2f %s") % ( titre, float(criteres), SYMBOLE) if choix == "INFEGAL": description = _(u"'%s' est inférieur ou égal à %.2f %s") % ( titre, float(criteres), SYMBOLE) if choix == "COMPRIS": description = _(u"'%s' est compris entre %.2f %s et %.2f %s") % ( titre, float(criteres.split(";")[0]), SYMBOLE, float(criteres.split(";")[1]), SYMBOLE) # DATE if typeDonnee == "date": if choix == "EGAL": description = _(u"'%s' est égal au '%s'") % ( titre, UTILS_Dates.DateEngFr(criteres)) if choix == "DIFFERENT": description = _(u"'%s' est différent du '%s'") % ( titre, UTILS_Dates.DateEngFr(criteres)) if choix == "SUP": description = _(u"'%s' est supérieur au '%s'") % ( titre, UTILS_Dates.DateEngFr(criteres)) if choix == "SUPEGAL": description = _(u"'%s' est supérieur ou égal au '%s'") % ( titre, UTILS_Dates.DateEngFr(criteres)) if choix == "INF": description = _(u"'%s' est inférieur au '%s'") % ( titre, UTILS_Dates.DateEngFr(criteres)) if choix == "INFEGAL": description = _(u"'%s' est inférieur ou égal au '%s'") % ( titre, UTILS_Dates.DateEngFr(criteres)) if choix == "COMPRIS": description = _(u"'%s' est compris entre le '%s' et le '%s'") % ( titre, UTILS_Dates.DateEngFr(criteres.split(";")[0]), UTILS_Dates.DateEngFr(criteres.split(";")[1])) # DATE ET HEURE if typeDonnee == "dateheure": if choix == "EGAL": description = _(u"'%s' est égal au '%s'") % ( titre, UTILS_Dates.DatetimeEnFr(criteres)) if choix == "DIFFERENT": description = _(u"'%s' est différent du '%s'") % ( titre, UTILS_Dates.DatetimeEnFr(criteres)) if choix == "SUP": description = _(u"'%s' est supérieur au '%s'") % ( titre, UTILS_Dates.DatetimeEnFr(criteres)) if choix == "SUPEGAL": description = _(u"'%s' est supérieur ou égal au '%s'") % ( titre, UTILS_Dates.DatetimeEnFr(criteres)) if choix == "INF": description = _(u"'%s' est inférieur au '%s'") % ( titre, UTILS_Dates.DatetimeEnFr(criteres)) if choix == "INFEGAL": description = _(u"'%s' est inférieur ou égal au '%s'") % ( titre, UTILS_Dates.DatetimeEnFr(criteres)) if choix == "COMPRIS": description = _(u"'%s' est compris entre le '%s' et le '%s'") % ( titre, UTILS_Dates.DatetimeEnFr(criteres.split(";")[0]), UTILS_Dates.DatetimeEnFr(criteres.split(";")[1])) # INSCRITS if typeDonnee == "inscrits": if choix == "INSCRITS": description = _( u"L'individu est inscrit sur les activités sélectionnées") if choix == "PRESENTS": description = _( u"L'individu est inscrit sur les activités sélectionnées et présent entre le %s et le %s" ) % (UTILS_Dates.DateDDEnFr(criteres["date_debut"]), UTILS_Dates.DateDDEnFr(criteres["date_fin"])) # COTISATIONS if typeDonnee == "cotisations": if choix == "AJOUR": description = _(u"Les cotisations sélectionnées sont à jour") return description
def FormateDate(dateDD): if dateDD == None: return u"" return UTILS_Dates.DateEngFr(str(dateDD))
def MAJ(self, forcerActualisation=False): # Conditions conditions = self.GetSQLdates(self.listePeriodes) if len(conditions) > 0 : conditionDates = " AND %s" % conditions else: conditionDates = "" if len(self.listeActivites) == 0 : conditionActivites = "()" elif len(self.listeActivites) == 1 : conditionActivites = "(%d)" % self.listeActivites[0] else : conditionActivites = str(tuple(self.listeActivites)) # Recherche des évènements DB = GestionDB.DB() req = """SELECT IDevenement, evenements.IDactivite, evenements.nom, date, heure_debut, heure_fin, capacite_max, activites.nom FROM evenements LEFT JOIN activites ON activites.IDactivite = evenements.IDactivite WHERE evenements.IDactivite IN %s %s ORDER BY date, heure_debut;""" % (conditionActivites, conditionDates) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() dictEvenements = {} dictDonnees = {} for IDevenement, IDactivite, nom, date, heure_debut, heure_fin, capacite_max, nomActivite in listeDonnees : if nomActivite == None : nomActivite = _(u"Activité inconnue") date = UTILS_Dates.DateEngEnDateDD(date) dictEvenement = {"nom" : nom, "IDactivite" : IDactivite, "date" : date, "heure_debut" : heure_debut, "heure_fin" : heure_fin, "nomActivite" : nomActivite, "nbre_max" : capacite_max, "nbre_inscrits" : 0, "nbre_attente" : 0} dictEvenements[IDevenement] = dictEvenement # Filtre infos = " ".join([nom, UTILS_Dates.DateEngFr(str(date))]) if self.filtre == None or (self.filtre.lower() in infos.lower()): # Mémorisation de l'évènement key = (nomActivite, IDactivite) if (key in dictDonnees) == False : dictDonnees[key] = {} if (date in dictDonnees[key]) == False : dictDonnees[key][date] = [] dictDonnees[key][date].append(IDevenement) req = """SELECT IDconso, IDevenement, etat FROM consommations WHERE IDevenement IS NOT NULL AND consommations.etat in ('reservation', 'present', 'attente') AND consommations.IDactivite IN %s %s ;""" % (conditionActivites, conditionDates) DB.ExecuterReq(req) listeDonnees = DB.ResultatReq() for IDconso, IDevenement, etat in listeDonnees : if IDevenement in dictEvenements : if etat in ("reservation", "present") : dictEvenements[IDevenement]["nbre_inscrits"] += 1 if etat == "attente" : dictEvenements[IDevenement]["nbre_attente"] += 1 DB.Close() # Vérifie si actualisation nécessaire if self.dictEvenements != dictEvenements or forcerActualisation == True : self.dictEvenements = dictEvenements else : return # MAJ du contrôle self.DeleteChildren(self.root) # Préparation pour impression self.dictImpression["contenu"] = [] self.dictImpression["coloration"] = [] # Tri par activités listeActivites = list(dictDonnees.keys()) listeActivites.sort() # Niveau Activité for key in listeActivites : nomActivite, IDactivite = key label = nomActivite.upper() niveau_activite = self.AppendItem(self.root, label) self.SetItemBackgroundColour(niveau_activite, wx.Colour(221, 221, 221)) self.dictImpression["contenu"].append([label, ]) self.dictImpression["coloration"].append((len(self.dictImpression["contenu"]) - 1, "regroup")) # Dates listeDates = list(dictDonnees[key].keys()) listeDates.sort() for date in listeDates : label = UTILS_Dates.DateComplete(date) niveau_date = self.AppendItem(niveau_activite, label) font = self.GetFont() font.SetWeight(wx.BOLD) self.SetItemFont(niveau_date, font) # Mémorisation ligne pour impression self.dictImpression["contenu"].append([label,]) # Evènements for IDevenement in dictDonnees[key][date] : dictEvenement = dictEvenements[IDevenement] label = dictEvenement["nom"] niveau_evenement = self.AppendItem(niveau_date, label) nbre_inscrits = dictEvenement["nbre_inscrits"] if nbre_inscrits == None : nbre_inscrits = 0 texte_inscrits = str(nbre_inscrits) self.SetItemText(niveau_evenement, texte_inscrits, 1) nbre_max = dictEvenement["nbre_max"] if nbre_max == None : texte_inscrits_max = "" else : texte_inscrits_max = str(nbre_max) self.SetItemText(niveau_evenement, texte_inscrits_max, 2) if nbre_max != None : nbre_places_libres = nbre_max - nbre_inscrits texte_places_libres = str(nbre_places_libres) else : nbre_places_libres = None texte_places_libres = "" self.SetItemText(niveau_evenement, texte_places_libres, 3) nbre_attente = dictEvenement["nbre_attente"] if nbre_attente in (0, None) : texte_attente = "" else : texte_attente = str(nbre_attente) self.SetItemText(niveau_evenement, texte_attente, 4) # Couleur de la ligne couleur_fond = self.GetCouleurLigne(nbre_places_libres) if couleur_fond != None : self.SetItemBackgroundColour(niveau_evenement, couleur_fond) # Mémorisation ligne activité pour impression self.dictImpression["contenu"].append([u" %s" % label, texte_inscrits, texte_inscrits_max, texte_places_libres]) self.ExpandAllChildren(self.root)
def FormateDateCourt(dateDD): if dateDD == None : return "" else: return UTILS_Dates.DateEngFr(str(dateDD))
def __init__(self, dictComptes={}, dictOptions={}, IDmodele=None, ouverture=True, nomFichier=None): """ Impression """ global DICT_COMPTES, DICT_OPTIONS DICT_COMPTES = dictComptes DICT_OPTIONS = dictOptions # Initialisation du document if nomFichier == None: nomDoc = FonctionsPerso.GenerationNomDoc("ATTESTATIONS_FISCALES", "pdf") else: nomDoc = nomFichier doc = BaseDocTemplate(nomDoc, pagesize=TAILLE_PAGE, showBoundary=False) # Mémorise le ID du modèle modeleDoc = DLG_Noedoc.ModeleDoc(IDmodele=IDmodele) doc.modeleDoc = modeleDoc # Vérifie qu'un cadre principal existe bien dans le document if doc.modeleDoc.FindObjet("cadre_principal") == None: raise Exception( "Votre modele de document doit obligatoirement comporter un cadre principal. Retournez dans l'editeur de document et utilisez pour votre modele la commande 'Inserer un objet special > Inserer le cadre principal'." ) # Mémorise le ID du modèle modeleDoc = DLG_Noedoc.ModeleDoc(IDmodele=IDmodele) doc.modeleDoc = modeleDoc # Importe le template de la première page doc.addPageTemplates(MyPageTemplate(pageSize=TAILLE_PAGE, doc=doc)) story = [] styleSheet = getSampleStyleSheet() h3 = styleSheet['Heading3'] styleTexte = styleSheet['BodyText'] styleTexte.fontName = "Helvetica" styleTexte.fontSize = 9 styleTexte.borderPadding = 9 styleTexte.leading = 12 ## # Définit le template des pages suivantes ## story.append(NextPageTemplate("suivante")) # ----------- Insertion du contenu des frames -------------- listeNomsSansCivilite = [] for IDcompte_payeur, dictCompte in dictComptes.items(): listeNomsSansCivilite.append( (dictCompte["{FAMILLE_NOM}"], IDcompte_payeur)) listeNomsSansCivilite.sort() for nomSansCivilite, IDcompte_payeur in listeNomsSansCivilite: dictCompte = dictComptes[IDcompte_payeur] story.append(DocAssign("IDcompte_payeur", IDcompte_payeur)) nomSansCivilite = dictCompte["{FAMILLE_NOM}"] story.append(Bookmark(nomSansCivilite, str(IDcompte_payeur))) # ------------------- TITRE ----------------- dataTableau = [] largeursColonnes = [ TAILLE_CADRE_CONTENU[2], ] dataTableau.append((dictOptions["titre"], )) texteDateReference = UTILS_Dates.DateEngFr( str(datetime.date.today())) dataTableau.append( (_(u"Période du %s au %s") % (UTILS_Dates.DateDDEnFr(dictOptions["date_debut"]), UTILS_Dates.DateDDEnFr(dictOptions["date_fin"])), )) style = TableStyle([ ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), ('FONT', (0, 0), (0, 0), "Helvetica-Bold", 19), ('FONT', (0, 1), (0, 1), "Helvetica", 8), ('LINEBELOW', (0, 0), (0, 0), 0.25, colors.black), ('ALIGN', (0, 0), (-1, -1), 'LEFT'), ]) tableau = Table(dataTableau, largeursColonnes) tableau.setStyle(style) story.append(tableau) story.append(Spacer(0, 30)) couleurFond = (0.8, 0.8, 1) couleurFondActivite = (0.92, 0.92, 1) # TEXTE CONTENU paraStyle = ParagraphStyle( name="contenu", fontName="Helvetica", fontSize=11, leading=16, spaceBefore=0, spaceafter=0, leftIndent=6, rightIndent=6, ) # INTRO texte = dictCompte["{INTRO}"] if texte != "": listeParagraphes = texte.split("</para>") for paragraphe in listeParagraphes: textePara = Paragraph(u"%s" % paragraphe, paraStyle) story.append(textePara) story.append(Spacer(0, 25)) # DETAIL par enfant dataTableau = [ (_(u"Nom et prénom"), _(u"Date de naissance"), _(u"Montant")), ] largeursColonnes = [220, 80, 80] paraStyle = ParagraphStyle( name="detail", fontName="Helvetica-Bold", fontSize=9, ) for nomCompletIndividu, dictIndividu in dictCompte["individus"]: dataTableau.append( (nomCompletIndividu, dictIndividu["date_naiss"], u"%.2f %s" % (dictIndividu["regle"], SYMBOLE))) dataTableau.append(("", "Total :", dictCompte["{MONTANT_REGLE}"])) style = TableStyle([ ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), ('ALIGN', (0, 0), (-1, -1), 'CENTER'), ('GRID', (0, 0), (-1, -2), 0.25, colors.black), ('FONT', (0, 0), (-1, 0), "Helvetica", 6), ('FONT', (0, 1), (-1, -1), "Helvetica", 10), ('TOPPADDING', (0, 1), (-1, -2), 10), ('BOTTOMPADDING', (0, 1), (-1, -2), 10), ('GRID', (-1, -1), (-1, -1), 0.25, colors.black), ('FONT', (-1, -1), (-1, -1), "Helvetica-Bold", 10), ('ALIGN', (-2, -1), (-2, -1), 'RIGHT'), ('FONT', (-2, -1), (-2, -1), "Helvetica", 6), ]) tableau = Table(dataTableau, largeursColonnes) tableau.setStyle(style) story.append(tableau) # Saut de page story.append(PageBreak()) # Finalisation du PDF doc.build(story) # Ouverture du PDF if ouverture == True: FonctionsPerso.LanceFichierExterne(nomDoc)
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 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 Imprimer(self, event=None): # Création du PDF from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle from reportlab.lib.pagesizes import A4 from reportlab.lib import colors from reportlab.lib.styles import ParagraphStyle hauteur_page = A4[1] largeur_page = A4[0] # Initialisation du PDF nomDoc = FonctionsPerso.GenerationNomDoc("INSCRIPTIONS", "pdf") if sys.platform.startswith("win"): nomDoc = nomDoc.replace("/", "\\") doc = SimpleDocTemplate(nomDoc, pagesize=(largeur_page, hauteur_page), topMargin=30, bottomMargin=30, leftMargin=40, rightMargin=40) story = [] # Création du titre du document dataTableau = [] largeursColonnes = ((largeur_page - 175, 100)) dateDuJour = UTILS_Dates.DateEngFr(str(datetime.date.today())) dataTableau.append((_(u"Inscriptions"), _(u"%s\nEdité le %s") % (UTILS_Organisateur.GetNom(), dateDuJour))) style = TableStyle([ ('BOX', (0, 0), (-1, -1), 0.25, colors.black), ('VALIGN', (0, 0), (-1, -1), 'TOP'), ('ALIGN', (0, 0), (0, 0), 'LEFT'), ('FONT', (0, 0), (0, 0), "Helvetica-Bold", 16), ('ALIGN', (1, 0), (1, 0), 'RIGHT'), ('FONT', (1, 0), (1, 0), "Helvetica", 6), ]) tableau = Table(dataTableau, largeursColonnes) tableau.setStyle(style) story.append(tableau) story.append(Spacer(0, 10)) # Intro styleA = ParagraphStyle(name="A", fontName="Helvetica", fontSize=6, spaceAfter=20) #story.append(Paragraph(self.labelParametres, styleA)) # Tableau dataTableau = [] largeurColonnesSuivantes = 70 largeurColonne1 = largeur_page - 80 - 1.0 * ( len(self.dictImpression["entete"]) - 1) * largeurColonnesSuivantes largeursColonnes = [ largeurColonne1, ] for x in range(0, len(self.dictImpression["entete"]) - 1): largeursColonnes.append(largeurColonnesSuivantes) # Entetes labels dataTableau.append(self.dictImpression["entete"]) # Contenu du tableau listeRubriques = ("contenu", "total") for rubrique in listeRubriques: listeLignes = self.dictImpression[rubrique] for ligne in listeLignes: dataTableau.append(ligne) positionLigneTotal = len(self.dictImpression["contenu"]) + 1 listeStyles = [ ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'), # Centre verticalement toutes les cases ('FONT', (0, 0), (-1, -1), "Helvetica", 7), # Donne la police de caract. + taille de police ('GRID', (0, 0), (-1, -1), 0.25, colors.black), # Crée la bordure noire pour tout le tableau ('ALIGN', (1, 0), (-1, -1), 'CENTRE'), # Centre les cases ('BACKGROUND', (0, 0), (-1, 0), (0.6, 0.6, 0.6)), # Donne la couleur de fond du label ('BACKGROUND', (0, positionLigneTotal), (-1, positionLigneTotal), (0.8, 0.8, 0.8)), # Donne la couleur de fond du total ] # Formatage des lignes "Activités" for indexColoration, typeColoration in self.dictImpression[ "coloration"]: if typeColoration == "activite": listeStyles.append( ('FONT', (0, indexColoration + 1), (-1, indexColoration + 1), "Helvetica-Bold", 7)) listeStyles.append( ('BACKGROUND', (0, indexColoration + 1), (-1, indexColoration + 1), (0.91, 0.91, 0.91))) if typeColoration == "regroup": listeStyles.append( ('FONT', (0, indexColoration + 1), (-1, indexColoration + 1), "Helvetica-Bold", 7)) listeStyles.append(('TEXTCOLOR', (0, indexColoration + 1), (-1, indexColoration + 1), (1, 1, 1))) listeStyles.append(('BACKGROUND', (0, indexColoration + 1), (-1, indexColoration + 1), (0, 0, 0))) # Création du tableau tableau = Table(dataTableau, largeursColonnes, repeatRows=1) tableau.setStyle(TableStyle(listeStyles)) story.append(tableau) story.append(Spacer(0, 20)) # Enregistrement du PDF doc.build(story) # Affichage du PDF FonctionsPerso.LanceFichierExterne(nomDoc)
class CTRL(HTL.HyperTreeList): def __init__(self, parent): HTL.HyperTreeList.__init__(self, parent, -1) self.parent = parent self.dictParametres = {} self.dictComptes = {} # Création des colonnes listeColonnes = [ (_(u"Famille/Individu"), 200, wx.ALIGN_LEFT), (u"Du", 70, wx.ALIGN_CENTER), (_(u"Au"), 70, wx.ALIGN_CENTER), (_(u"Retard"), 60, wx.ALIGN_CENTRE), (_(u"Solde"), 60, wx.ALIGN_RIGHT), (_(u"Document"), 170, wx.ALIGN_LEFT), ] numColonne = 0 for label, largeur, alignement in listeColonnes: self.AddColumn(label) self.SetColumnWidth(numColonne, largeur) self.SetColumnAlignment(numColonne, alignement) numColonne += 1 ## # Création de l'ImageList ## il = wx.ImageList(16, 16) ## self.img_ok = il.Add(wx.Bitmap(Chemins.GetStaticPath('Images/16x16/Ok.png'), wx.BITMAP_TYPE_PNG)) ## self.img_pasok = il.Add(wx.Bitmap(Chemins.GetStaticPath('Images/16x16/Interdit.png'), wx.BITMAP_TYPE_PNG)) ## self.AssignImageList(il) self.SetBackgroundColour(wx.WHITE) self.SetAGWWindowStyleFlag( wx.TR_COLUMN_LINES | wx.TR_HAS_BUTTONS | wx.TR_HIDE_ROOT | wx.TR_HAS_VARIABLE_ROW_HEIGHT | wx.TR_FULL_ROW_HIGHLIGHT | HTL.TR_AUTO_CHECK_CHILD | HTL.TR_AUTO_CHECK_PARENT) # HTL.TR_NO_HEADER self.EnableSelectionVista(True) # Binds self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnContextMenu) self.Bind(EVT_TREE_ITEM_CHECKED, self.OnCheckItem) def SetParametres(self, dictParametres={}): self.dictParametres = dictParametres self.MAJ() def AfficheNbreComptes(self, nbreComptes=0): if self.parent.GetName() == "DLG_Rappels_generation_selection": if nbreComptes == 0: label = _(u"Aucune lettre de rappel sélectionnée") elif nbreComptes == 1: label = _(u"1 lettre de rappel sélectionnée") else: label = _( u"%d lettres de rappel sélectionnées") % nbreComptes self.parent.box_rappels_staticbox.SetLabel(label) def OnCheckItem(self, event): if self.MAJenCours == False: item = event.GetItem() if self.GetPyData(item)["type"] == "individu": # Récupère les données sur le compte payeur itemParent = self.GetItemParent(item) IDcompte_payeur = self.GetPyData(itemParent)["valeur"] ## compte_total = self.dictComptes[IDcompte_payeur]["total"] ## compte_ventilation = self.dictComptes[IDcompte_payeur]["ventilation"] compte_reports = self.dictComptes[IDcompte_payeur][ "total_reports"] # Récupère les données sur l'individu IDindividu = self.GetPyData(item)["valeur"] ## individu_total = self.dictComptes[IDcompte_payeur]["individus"][IDindividu]["total"] ## individu_ventilation = self.dictComptes[IDcompte_payeur]["individus"][IDindividu]["ventilation"] individu_reports = self.dictComptes[IDcompte_payeur][ "individus"][IDindividu]["total_reports"] self.AfficheNbreComptes(len(self.GetCoches())) def CocheTout(self): self.MAJenCours = True item = self.root for index in range(0, self.GetChildrenCount(self.root)): item = self.GetNext(item) self.CheckItem(item, True) self.MAJenCours = False self.AfficheNbreComptes(len(self.GetCoches())) def DecocheTout(self): self.MAJenCours = True item = self.root for index in range(0, self.GetChildrenCount(self.root)): item = self.GetNext(item) self.CheckItem(item, False) self.MAJenCours = False self.AfficheNbreComptes(len(self.GetCoches())) def SelectImpayes(self): """ Sélectionne uniquement les familles avec un compte débiteur """ self.MAJenCours = True item = self.root for index in range(0, self.GetChildrenCount(self.root)): item = self.GetNext(item) if self.GetPyData(item)["type"] == "compte": IDcompte_payeur = self.GetPyData(item)["valeur"] total = self.dictComptes[IDcompte_payeur]["total"] ventilation = self.dictComptes[IDcompte_payeur]["ventilation"] solde = total - ventilation if solde > 0.0: self.CheckItem(item, True) else: self.CheckItem(item, False) self.MAJenCours = False self.AfficheNbreComptes(len(self.GetCoches())) def GetCoches(self): dictCoches = {} # Parcours des items COMPTE parent = self.root for index in range(0, self.GetChildrenCount(self.root)): parent = self.GetNext(parent) if self.IsItemChecked(parent): IDcompte_payeur = self.GetPyData(parent)["valeur"] dictCoches[IDcompte_payeur] = [] return dictCoches def MAJ(self): """ Met à jour (redessine) tout le contrôle """ self.DeleteAllItems() self.root = self.AddRoot(_(u"Racine")) self.Remplissage() self.CocheTout() def Remplissage(self): dlgAttente = PBI.PyBusyInfo( _(u"Recherche des impayés en cours..."), parent=None, title=_(u"Veuillez patienter..."), icon=wx.Bitmap(Chemins.GetStaticPath("Images/16x16/Logo.png"), wx.BITMAP_TYPE_ANY)) wx.Yield() try: facturation = UTILS_Rappels.Facturation() self.dictComptes = facturation.GetDonnees( liste_activites=self.dictParametres["listeActivites"], listeExceptionsComptes=self. dictParametres["listeExceptionsComptes"], date_reference=self.dictParametres["date_reference"], date_edition=self.dictParametres["date_edition"], prestations=self.dictParametres["prestations"], ) del dlgAttente except Exception, 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 rappels : \n\n%s" ) % err, _(u"Erreur"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return False # Condition famille unique if self.dictParametres["IDcompte_payeur"] != None: IDcompte_payeur = self.dictParametres["IDcompte_payeur"] if self.dictComptes.has_key(IDcompte_payeur): self.dictComptes = { IDcompte_payeur: self.dictComptes[IDcompte_payeur], } else: self.dictComptes = {} # Branches COMPTE listeNomsSansCivilite = [] self.dictControles = {} for IDcompte_payeur, dictCompte in self.dictComptes.iteritems(): listeNomsSansCivilite.append( (dictCompte["nomSansCivilite"], IDcompte_payeur)) listeNomsSansCivilite.sort() index = 0 for nomSansCivilite, IDcompte_payeur in listeNomsSansCivilite: dictCompte = self.dictComptes[IDcompte_payeur] IDfamille = dictCompte["IDfamille"] solde = dictCompte["solde"] date_debut = dictCompte["date_min"] date_fin = dictCompte["date_max"] nbreJoursRetard = (datetime.date.today() - date_fin).days # Texte du retard if nbreJoursRetard < 31: texteRetard = _(u"%d jours") % nbreJoursRetard else: nbreMois = nbreJoursRetard / 30 nbreJours = nbreJoursRetard - (nbreMois * 30) texteRetard = _(u"%d jours") % nbreJoursRetard niveauCompte = self.AppendItem(self.root, nomSansCivilite, ct_type=1) self.SetItemText(niveauCompte, UTILS_Dates.DateEngFr(str(date_debut)), 1) self.SetItemText(niveauCompte, UTILS_Dates.DateEngFr(str(date_fin)), 2) self.SetItemText(niveauCompte, texteRetard, 3) self.SetItemText(niveauCompte, solde, 4) ctrl_document = CTRL_document( self.GetMainWindow(), -1, branche=niveauCompte, IDcompte_payeur=IDcompte_payeur, nbreJoursRetard=nbreJoursRetard, infobulle=_(u"Sélectionnez un document")) self.SetItemWindow(niveauCompte, ctrl_document, 5) self.dictControles[IDcompte_payeur] = ctrl_document self.SetPyData( niveauCompte, { "type": "compte", "valeur": IDcompte_payeur, "IDcompte_payeur": IDcompte_payeur, "IDfamille": IDfamille, "nom": nomSansCivilite, "ctrl_document": ctrl_document }) index += 1
def Supprimer(self, event): if len(self.Selection()) == 0 and len(self.GetTracksCoches()) == 0 : dlg = wx.MessageDialog(self, _(u"Vous n'avez sélectionné aucune cotisation à supprimer dans la liste !"), _(u"Erreur de saisie"), wx.OK | wx.ICON_EXCLAMATION) dlg.ShowModal() dlg.Destroy() return if len(self.GetTracksCoches()) > 0 : # Suppression multiple listeSelections = self.GetTracksCoches() dlg = wx.MessageDialog(self, _(u"Souhaitez-vous vraiment supprimer les %d cotisations cochées ?") % len(listeSelections), _(u"Suppression"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES : return else : # Suppression unique listeSelections = self.Selection() dlg = wx.MessageDialog(self, _(u"Souhaitez-vous vraiment supprimer la cotisation n°%s ?") % listeSelections[0].numero, _(u"Suppression"), wx.YES_NO|wx.NO_DEFAULT|wx.CANCEL|wx.ICON_INFORMATION) reponse = dlg.ShowModal() dlg.Destroy() if reponse != wx.ID_YES : return for track in listeSelections : # Vérifie les droits utilisateur if track.IDfamille != None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("familles_cotisations", "supprimer") == False : return if track.IDindividu != None and UTILS_Utilisateurs.VerificationDroitsUtilisateurActuel("individus_cotisations", "supprimer") == False : return # Vérifie les périodes gestion verrouillées if self.gestion.Verification("cotisations", track.date_creation_carte) == False: return False # Recherche si prestation déjà présente sur facture listeID = [] for track in listeSelections : listeID.append(track.IDcotisation) if len(listeID) == 0 : conditionIDcotisation = "()" if len(listeID) == 1 : conditionIDcotisation = "(%d)" % listeID[0] else : conditionIDcotisation = str(tuple(listeID)) DB = GestionDB.DB() req = """SELECT IDcotisation, prestations.date, MIN(IDfacture) FROM prestations LEFT JOIN cotisations ON cotisations.IDprestation = prestations.IDprestation WHERE IDcotisation IN %s GROUP BY cotisations.IDcotisation;""" % conditionIDcotisation DB.ExecuterReq(req) listeFactures = DB.ResultatReq() DB.Close() if len(listeFactures) > 0 : nbreCotisations = 0 for IDcotisation, date, IDfacture in listeFactures : if self.gestion.Verification("prestations", date) == False: return False if IDfacture != None : nbreCotisations += 1 if nbreCotisations > 0 : if nbreCotisations == 1 : message = _(u"Cette cotisation apparaît déjà sur une facture. Il est donc impossible de la supprimer.") else : message = _(u"%d de ces cotisations apparaissent déjà sur une ou plusieurs factures. Il est donc impossible d'effectuer la suppression.") % len(listeFactures) dlg = wx.MessageDialog(self, message, _(u"Suppression impossible"), wx.OK | wx.ICON_ERROR) dlg.ShowModal() dlg.Destroy() return # Suppression DB = GestionDB.DB() for track in listeSelections : DB.ReqDEL("cotisations", "IDcotisation", track.IDcotisation) if track.IDprestation != None : DB.ReqDEL("prestations", "IDprestation", track.IDprestation) # Mémorise l'action dans l'historique UTILS_Historique.InsertActions([{ "IDindividu" : track.IDindividu, "IDfamille" : track.IDfamille, "IDcategorie" : 23, "action" : _(u"Suppression de la cotisation ID%d '%s' pour la période du %s au %s") % (track.IDcotisation, track.nomCotisation, UTILS_Dates.DateEngFr(str(track.date_debut)), UTILS_Dates.DateEngFr(str(track.date_fin))), },]) # Actualisation de l'affichage self.MAJ() DB.Close() dlg.Destroy()