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()
