def __init__(self):
""" Récupération de toutes les données de base """
DB = GestionDB.DB()
# Récupération des infos sur l'organisme
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
self.dictOrganisme["nom"] = nom
self.dictOrganisme["rue"] = rue
self.dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
self.dictOrganisme["ville"] = ville
self.dictOrganisme["tel"] = tel
self.dictOrganisme["fax"] = fax
self.dictOrganisme["mail"] = mail
self.dictOrganisme["site"] = site
self.dictOrganisme["num_agrement"] = num_agrement
self.dictOrganisme["num_siret"] = num_siret
self.dictOrganisme["code_ape"] = code_ape
DB.Close()
# Get noms Titulaires et individus
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
self.dictIndividus = UTILS_Titulaires.GetIndividus()
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
# Récupération des questionnaires
self.Questionnaires_familles = UTILS_Questionnaires.ChampsEtReponses(
type="famille")
self.Questionnaires_locations = UTILS_Questionnaires.ChampsEtReponses(
type="location")
self.Questionnaires_produits = UTILS_Questionnaires.ChampsEtReponses(
type="produit")
def CreationPDF(self,
nomDoc=FonctionsPerso.GenerationNomDoc(
"INSCRIPTION", "pdf"),
afficherDoc=True):
dictChampsFusion = {}
# Récupération des valeurs de base
dictDonnees = DICT_DONNEES
# Récupération des infos sur l'organisme
DB = GestionDB.DB()
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
dictOrganisme["nom"] = nom
dictOrganisme["rue"] = rue
dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
dictOrganisme["ville"] = ville
dictOrganisme["tel"] = tel
dictOrganisme["fax"] = fax
dictOrganisme["mail"] = mail
dictOrganisme["site"] = site
dictOrganisme["num_agrement"] = num_agrement
dictOrganisme["num_siret"] = num_siret
dictOrganisme["code_ape"] = code_ape
DB.Close()
date_editionDD = datetime.date.today()
# Adresse
self.IDindividu = self.dictInscription["IDINDIVIDU"]
individus = UTILS_Titulaires.GetIndividus()
self.dictInscription["INDIVIDU_RUE"] = individus[
self.IDindividu]["rue"]
self.dictInscription["INDIVIDU_CP"] = individus[self.IDindividu]["cp"]
self.dictInscription["INDIVIDU_VILLE"] = individus[
self.IDindividu]["ville"]
# Nom Titulaires
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille=[
self.IDfamille,
])
self.dictInscription["FAMILLE_NOM"] = dictTitulaires[
self.IDfamille]["titulairesSansCivilite"]
# Civilité
dictCivilites = Civilites.GetDictCivilites()
if self.dictInscription["IDCIVILITE"] == None or self.dictInscription[
"IDCIVILITE"] == "":
IDcivilite = 1
else:
IDcivilite = self.dictInscription["IDCIVILITE"]
self.dictInscription["INDIVIDU_GENRE"] = dictCivilites[IDcivilite][
"sexe"]
self.dictInscription["INDIVIDU_CIVILITE_LONG"] = dictCivilites[
IDcivilite]["civiliteLong"]
self.dictInscription["INDIVIDU_CIVILITE_COURT"] = dictCivilites[
IDcivilite]["civiliteAbrege"]
# Date de naissance
if self.dictInscription["INDIVIDU_DATE_NAISS"] == None:
self.dictInscription["INDIVIDU_AGE"] = None
else:
datenaissDD = datetime.date(
year=int(self.dictInscription["INDIVIDU_DATE_NAISS"][:4]),
month=int(self.dictInscription["INDIVIDU_DATE_NAISS"][5:7]),
day=int(self.dictInscription["INDIVIDU_DATE_NAISS"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
self.dictInscription["INDIVIDU_AGE"] = age
# Insertion des données de base dans le dictValeurs
IDfamille = self.IDfamille
dictValeurs = {
"IDfamille":
self.IDfamille,
"{IDFAMILLE}":
str(self.IDfamille),
"{DATE_EDITION}":
DateEngFr(str(date_editionDD)),
"{DATE_EDITION_LONG}":
DateComplete(date_editionDD),
"{DATE_EDITION_COURT}":
DateEngFr(str(date_editionDD)),
"{ORGANISATEUR_NOM}":
dictOrganisme["nom"],
"{ORGANISATEUR_RUE}":
dictOrganisme["rue"],
"{ORGANISATEUR_CP}":
dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}":
dictOrganisme["ville"],
"{ORGANISATEUR_TEL}":
dictOrganisme["tel"],
"{ORGANISATEUR_FAX}":
dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}":
dictOrganisme["mail"],
"{ORGANISATEUR_SITE}":
dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}":
dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}":
dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}":
dictOrganisme["code_ape"],
"{IDINSCRIPTION}":
FormateStr(self.dictInscription["IDINSCRIPTION"]),
"{DATE_INSCRIPTION}":
FormateDate(self.dictInscription["DATE_INSCRIPTION"]),
"{EST_PARTI}":
FormateBool(self.dictInscription["EST_PARTI"]),
"{IDACTIVITE}":
FormateStr(self.dictInscription["IDACTIVITE"]),
"{ACTIVITE_NOM_LONG}":
FormateStr(self.dictInscription["ACTIVITE_NOM_LONG"]),
"{ACTIVITE_NOM_COURT}":
FormateStr(self.dictInscription["ACTIVITE_NOM_COURT"]),
"{IDGROUPE}":
FormateStr(self.dictInscription["IDGROUPE"]),
"{GROUPE_NOM_LONG}":
FormateStr(self.dictInscription["GROUPE_NOM_LONG"]),
"{GROUPE_NOM_COURT}":
FormateStr(self.dictInscription["GROUPE_NOM_COURT"]),
"{IDCATEGORIETARIF}":
FormateStr(self.dictInscription["IDCATEGORIETARIF"]),
"{NOM_CATEGORIE_TARIF}":
FormateStr(self.dictInscription["NOM_CATEGORIE_TARIF"]),
"{IDINDIVIDU}":
FormateStr(self.dictInscription["IDINDIVIDU"]),
"{INDIVIDU_CIVILITE_LONG}":
FormateStr(self.dictInscription["INDIVIDU_CIVILITE_LONG"]),
"{INDIVIDU_CIVILITE_COURT}":
FormateStr(self.dictInscription["INDIVIDU_CIVILITE_COURT"]),
"{INDIVIDU_GENRE}":
FormateStr(self.dictInscription["INDIVIDU_GENRE"]),
"{INDIVIDU_NOM}":
FormateStr(self.dictInscription["INDIVIDU_NOM"]),
"{INDIVIDU_PRENOM}":
FormateStr(self.dictInscription["INDIVIDU_PRENOM"]),
"{INDIVIDU_DATE_NAISS}":
FormateDate(self.dictInscription["INDIVIDU_DATE_NAISS"]),
"{INDIVIDU_AGE}":
FormateStr(self.dictInscription["INDIVIDU_AGE"]),
"{INDIVIDU_CP_NAISS}":
FormateStr(self.dictInscription["INDIVIDU_CP_NAISS"]),
"{INDIVIDU_VILLE_NAISS}":
FormateStr(self.dictInscription["INDIVIDU_VILLE_NAISS"]),
"{INDIVIDU_RUE}":
FormateStr(self.dictInscription["INDIVIDU_RUE"]),
"{INDIVIDU_CP}":
FormateStr(self.dictInscription["INDIVIDU_CP"]),
"{INDIVIDU_VILLE}":
FormateStr(self.dictInscription["INDIVIDU_VILLE"]),
"{INDIVIDU_PROFESSION}":
FormateStr(self.dictInscription["INDIVIDU_PROFESSION"]),
"{INDIVIDU_EMPLOYEUR}":
FormateStr(self.dictInscription["INDIVIDU_EMPLOYEUR"]),
"{INDIVIDU_TEL_DOMICILE}":
FormateStr(self.dictInscription["INDIVIDU_TEL_DOMICILE"]),
"{INDIVIDU_TEL_MOBILE}":
FormateStr(self.dictInscription["INDIVIDU_TEL_MOBILE"]),
"{INDIVIDU_FAX}":
FormateStr(self.dictInscription["INDIVIDU_FAX"]),
"{INDIVIDU_EMAIL}":
FormateStr(self.dictInscription["INDIVIDU_EMAIL"]),
"{INDIVIDU_TEL_PRO}":
FormateStr(self.dictInscription["INDIVIDU_TEL_PRO"]),
"{INDIVIDU_FAX_PRO}":
FormateStr(self.dictInscription["INDIVIDU_FAX_PRO"]),
"{INDIVIDU_EMAIL_PRO}":
FormateStr(self.dictInscription["INDIVIDU_EMAIL_PRO"]),
"{FAMILLE_NOM}":
FormateStr(self.dictInscription["FAMILLE_NOM"]),
"{FAMILLE_CAISSE}":
FormateStr(self.dictInscription["FAMILLE_CAISSE"]),
"{FAMILLE_REGIME}":
FormateStr(self.dictInscription["FAMILLE_REGIME"]),
"{FAMILLE_NUMALLOC}":
FormateStr(self.dictInscription["FAMILLE_NUMALLOC"]),
}
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
dictValeurs.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
dictValeurs.update(
self.infosIndividus.GetDictValeurs(
mode="individu",
ID=self.dictInscription["IDINDIVIDU"],
formatChamp=True))
# Récupération des questionnaires
Questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="famille")
for dictReponse in Questionnaires.GetDonnees(IDfamille):
dictValeurs[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictValeurs["{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
# Récupération du signataire
infosSignataire = self.ctrl_signataire.GetInfos()
if infosSignataire == None:
dlg = wx.MessageDialog(
self, _(u"Vous n'avez sélectionné aucun signataire !"),
_(u"Annulation"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
nomSignataire = infosSignataire["nom"]
fonctionSignataire = infosSignataire["fonction"]
sexeSignataire = infosSignataire["sexe"]
if sexeSignataire == "H":
genreSignataire = u""
else:
genreSignataire = u"e"
# Récupération et transformation du texte d'intro
if self.ctrl_intro.GetValue() == True:
textIntro = self.ctrl_texte_intro.GetValue()
textIntro = textIntro.replace("{SIGNATAIRE_GENRE}",
genreSignataire)
textIntro = textIntro.replace("{SIGNATAIRE_NOM}", nomSignataire)
textIntro = textIntro.replace("{SIGNATAIRE_FONCTION}",
fonctionSignataire)
for key, valeur in dictValeurs.items():
if key.startswith("{"):
if valeur == None: valeur = ""
if type(valeur) == int: valeur = str(valeur)
textIntro = textIntro.replace(key, valeur)
dictValeurs["intro"] = textIntro
else:
dictValeurs["intro"] = None
# Tableau
dictValeurs["tableau"] = self.ctrl_tableau.GetValue()
for key, valeur in dictValeurs.items():
if valeur == None: valeur = ""
dictChampsFusion[key] = valeur
# Préparation des données pour une sauvegarde dans l'historique
self.dictSave = {}
self.dictSave["activite"] = self.dictInscription["ACTIVITE_NOM_LONG"]
self.dictSave["groupe"] = self.dictInscription["GROUPE_NOM_LONG"]
# Récupération du modèle
IDmodele = self.ctrl_modele.GetID()
if IDmodele == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un modèle !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Fabrication du PDF
from Utils import UTILS_Impression_inscription
UTILS_Impression_inscription.Impression(dictValeurs,
IDmodele=IDmodele,
nomDoc=nomDoc,
afficherDoc=afficherDoc)
return dictChampsFusion
import datetime
import decimal
import GestionDB
from Utils import UTILS_Dates
from Utils import UTILS_Identification
from Utils import UTILS_Mandats
import wx.lib.dialogs as dialogs
from Utils import UTILS_Config
SYMBOLE = UTILS_Config.GetParametre("monnaie_symbole", u"¤")
from Utils import UTILS_Interface
from Ctrl.CTRL_ObjectListView import FastObjectListView, ColumnDefn, Filter, CTRL_Outils
from Utils import UTILS_Titulaires
DICT_INDIVIDUS = UTILS_Titulaires.GetIndividus()
class Track(object):
def __init__(self, donnees, dictTitulaires):
self.dictTitulaires = dictTitulaires
self.IDpiece = donnees["IDpiece"]
self.IDlot = donnees["IDlot"]
self.IDfamille = donnees["IDfamille"]
self.IDcompte_payeur = donnees["IDcompte_payeur"]
self.prelevement = donnees["prelevement"]
self.prelevement_iban = donnees["prelevement_iban"]
self.prelevement_bic = donnees["prelevement_bic"]
self.prelevement_rum = donnees["prelevement_rum"]
self.prelevement_date_mandat = donnees["prelevement_date_mandat"]
def CreationPDF(self, nomDoc=FonctionsPerso.GenerationNomDoc("MANDAT_SEPA", "pdf"), afficherDoc=True):
dictChampsFusion = {}
dictDonnees = {}
# Récupère infos sur organisateur
from Utils import UTILS_Organisateur
dictOrganisateur = UTILS_Organisateur.GetDonnees(tailleLogo=(200, 200))
# ICS
DB = GestionDB.DB()
req = """SELECT IDcompte, nom, numero, code_ics
FROM comptes_bancaires;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
ics = ""
if len(listeDonnees) > 0 :
IDcompte, nomCompte, numeroCompte, ics = listeDonnees[0]
if ics == None :
ics = ""
# Récupère données du mandat
titulaire_nom = ""
titulaire_rue = ""
titulaire_cp = ""
titulaire_ville = ""
if self.radio_membre.GetValue() :
IDindividu = self.ctrl_membre.GetID()
if IDindividu != None :
dictIndividus = UTILS_Titulaires.GetIndividus()
titulaire_nom = dictIndividus[IDindividu]["nom_complet"]
titulaire_rue = dictIndividus[IDindividu]["rue"]
titulaire_cp = dictIndividus[IDindividu]["cp"]
titulaire_ville = dictIndividus[IDindividu]["ville"]
else :
titulaire_nom = self.ctrl_individu_nom.GetValue()
titulaire_rue = self.ctrl_individu_rue.GetValue()
titulaire_cp = self.ctrl_individu_ville.GetValueCP()
titulaire_ville = self.ctrl_individu_ville.GetValueVille()
iban = self.ctrl_iban.GetValue()
bic = self.ctrl_bic.GetValue()
rum = self.ctrl_reference_mandat.GetValue()
date = self.ctrl_date_mandat.GetDate()
if date == None :
date = ""
if self.ctrl_type_mandat.GetSelection() == 0 :
typeMandat = "recurrent"
else :
typeMandat = "ponctuel"
dictDonnees = {
"titulaire_nom" : titulaire_nom,
"titulaire_rue" : titulaire_rue,
"titulaire_cp" : titulaire_cp,
"titulaire_ville" : titulaire_ville,
"iban" : iban,
"bic" : bic,
"rum" : rum,
"date" : date,
"typeMandat" : typeMandat,
"organisateur" : dictOrganisateur,
"ics" : ics,
}
# Mémorisation pour la fusion Emails
dictChampsFusion["{RUM}"] = rum
dictChampsFusion["{DATE}"] = date
# Lancement de l'édition du PDF
Impression(dictDonnees, nomDoc=nomDoc, afficherDoc=afficherDoc)
return dictChampsFusion
def GetTracks(self):
""" Récupération des données """
self.individus = UTILS_Titulaires.GetIndividus()
self.titulaires = UTILS_Titulaires.GetTitulaires()
listeID = None
DB = GestionDB.DB()
# Conditions
listeConditions = []
conditions = ""
## if self.IDfamille != None :
## listeConditions.append("cotisations.IDfamille = %d" % self.IDfamille)
##
## if self.IDindividu != None :
## listeConditions.append("cotisations.IDindividu = %d" % self.IDindividu)
# 1ère série de filtres
if self.filtres != None :
for filtre in self.filtres :
# IDcotisation_intervalle
if filtre["type"] == "IDcotisation_intervalle" :
listeConditions.append( "(cotisations.IDcotisation>=%d AND cotisations.IDcotisation<=%d)" % (filtre["IDcotisation_min"], filtre["IDcotisation_max"]) )
# IDcotisation_liste
if filtre["type"] == "IDcotisation_liste" :
if len(filtre["liste"]) == 0 : listeTemp = "()"
elif len(filtre["liste"]) == 1 : listeTemp = "(%d)" % filtre["liste"][0]
else : listeTemp = str(tuple(filtre["liste"]))
listeConditions.append( "cotisations.IDcotisation IN %s" % listeTemp)
# Type de cotisation
if filtre["type"] == "type" :
listeConditions.append("cotisations.IDtype_cotisation=%d" % filtre["IDtype_cotisation"])
# Unité de cotisation
if filtre["type"] == "unite" :
listeConditions.append("cotisations.IDunite_cotisation=%d" % filtre["IDunite_cotisation"])
## # Date d'échéance
## if filtre["type"] == "date_echeance" :
## listeConditions.append( "(factures.date_echeance>='%s' AND factures.date_echeance<='%s')" % (filtre["date_min"], filtre["date_max"]) )
# Carte créée
if filtre["type"] == "carte" :
if filtre["choix"] == True :
listeConditions.append( "cotisations.date_creation_carte IS NOT NULL")
else :
listeConditions.append( "cotisations.date_creation_carte IS NULL")
# Carte facturée
if filtre["type"] == "facturee" :
if filtre["choix"] == True :
listeConditions.append( "cotisations.IDprestation IS NOT NULL")
else :
listeConditions.append( "cotisations.IDprestation IS NULL")
# Dépôt
if filtre["type"] == "depot" :
listeConditions.append("cotisations.IDdepot_cotisation=%d" % filtre["IDdepot_cotisation"])
dictFacturation = {}
if self.mode == "liste" :
## if self.filtre == None or self.filtre["IDtype_cotisation"] == None or self.filtre["IDunite_cotisation"] == None :
## return []
## if self.filtre != None :
## conditionsCotisations = "WHERE cotisations.IDtype_cotisation=%d AND cotisations.IDunite_cotisation=%d" % (self.filtre["IDtype_cotisation"], self.filtre["IDunite_cotisation"])
# Pour le mode LISTE
if len(listeConditions) > 0 :
conditions = "WHERE %s" % " AND ".join(listeConditions)
# Récupère les prestations
## req = """SELECT IDcotisation, SUM(montant)
## FROM prestations
## LEFT JOIN cotisations ON cotisations.IDprestation = prestations.IDprestation
## %s
## GROUP BY cotisations.IDcotisation;""" % conditions
req = """SELECT prestations.IDprestation, SUM(montant)
FROM cotisations
LEFT JOIN prestations ON prestations.IDprestation = cotisations.IDprestation
%s
GROUP BY cotisations.IDprestation;""" % conditions
DB.ExecuterReq(req)
listePrestations = DB.ResultatReq()
for IDprestation, montant in listePrestations :
dictFacturation[IDprestation] = {"montant":montant, "ventilation":0.0, "dateReglement":None,"modeReglement":None}
# Recherche la ventilation
req = """SELECT IDprestation, SUM(ventilation.montant), MIN(reglements.date), MIN(modes_reglements.label)
FROM ventilation
LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement
LEFT JOIN modes_reglements ON modes_reglements.IDmode = reglements.IDmode
GROUP BY ventilation.IDprestation;"""
DB.ExecuterReq(req)
listeVentilations = DB.ResultatReq()
for IDprestation, ventilation, dateReglement, modeReglement in listeVentilations :
if dictFacturation.has_key(IDprestation) :
dictFacturation[IDprestation]["ventilation"] = ventilation
dictFacturation[IDprestation]["dateReglement"] = dateReglement
dictFacturation[IDprestation]["modeReglement"] = modeReglement
# Récupère la ventilation
## req = """SELECT IDcotisation, SUM(ventilation.montant), MIN(reglements.date), MIN(modes_reglements.label)
## FROM ventilation
## LEFT JOIN prestations ON prestations.IDprestation = ventilation.IDprestation
## LEFT JOIN cotisations ON cotisations.IDprestation = ventilation.IDprestation
## LEFT JOIN reglements ON reglements.IDreglement = ventilation.IDreglement
## LEFT JOIN modes_reglements ON modes_reglements.IDmode = reglements.IDmode
## %s
## GROUP BY cotisations.IDcotisation;""" % conditions
## DB.ExecuterReq(req)
## listeVentilations = DB.ResultatReq()
## for IDcotisation, ventilation, dateReglement, modeReglement in listeVentilations :
## if dictFacturation.has_key(IDcotisation) :
## dictFacturation[IDcotisation]["ventilation"] = ventilation
## dictFacturation[IDcotisation]["dateReglement"] = dateReglement
## dictFacturation[IDcotisation]["modeReglement"] = modeReglement
# Recherche les cotisations
req = """
SELECT
cotisations.IDcotisation,
cotisations.IDfamille, cotisations.IDindividu, cotisations.IDtype_cotisation, cotisations.IDunite_cotisation,
cotisations.date_saisie, cotisations.IDutilisateur, cotisations.date_creation_carte, cotisations.numero,
cotisations.IDdepot_cotisation, cotisations.date_debut, cotisations.date_fin, cotisations.IDprestation,
types_cotisations.nom, types_cotisations.type, types_cotisations.carte,
unites_cotisations.nom, comptes_payeurs.IDcompte_payeur, cotisations.observations, cotisations.activites
FROM cotisations
LEFT JOIN types_cotisations ON types_cotisations.IDtype_cotisation = cotisations.IDtype_cotisation
LEFT JOIN unites_cotisations ON unites_cotisations.IDunite_cotisation = cotisations.IDunite_cotisation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = cotisations.IDfamille
%s
ORDER BY cotisations.date_saisie
;""" % conditions
else :
if self.IDindividu != None :
# Pour une fiche individu
if self.dictFamillesRattachees != None :
listeIDfamille = []
for IDfamille, dictFamille in self.dictFamillesRattachees.iteritems() :
if dictFamille["IDcategorie"] in (1, 2) :
listeIDfamille.append(IDfamille)
if len(listeIDfamille) == 0 : conditionIDfamille = "()"
if len(listeIDfamille) == 1 : conditionIDfamille = "(%d)" % listeIDfamille[0]
else : conditionIDfamille = str(tuple(listeIDfamille))
else:
conditionIDfamille = "()"
listeConditions.append("(cotisations.IDindividu=%d OR (cotisations.IDfamille IN %s AND cotisations.IDindividu IS NULL))" % (self.IDindividu, conditionIDfamille))
if len(listeConditions) > 0 :
conditions = "WHERE %s" % " AND ".join(listeConditions)
req = """
SELECT
cotisations.IDcotisation,
cotisations.IDfamille, cotisations.IDindividu, cotisations.IDtype_cotisation, cotisations.IDunite_cotisation,
cotisations.date_saisie, cotisations.IDutilisateur, cotisations.date_creation_carte, cotisations.numero,
cotisations.IDdepot_cotisation, cotisations.date_debut, cotisations.date_fin, cotisations.IDprestation,
types_cotisations.nom, types_cotisations.type, types_cotisations.carte,
unites_cotisations.nom, comptes_payeurs.IDcompte_payeur, cotisations.observations, cotisations.activites
FROM cotisations
LEFT JOIN types_cotisations ON types_cotisations.IDtype_cotisation = cotisations.IDtype_cotisation
LEFT JOIN unites_cotisations ON unites_cotisations.IDunite_cotisation = cotisations.IDunite_cotisation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = cotisations.IDfamille
%s;
""" % conditions
else:
# Pour une fiche famille
req = """
SELECT IDindividu, IDcategorie
FROM rattachements
WHERE IDfamille=%d AND IDcategorie IN (1, 2);
""" % self.IDfamille
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeIDindividus = []
for IDindividu, IDcategorie in listeDonnees :
if IDindividu not in listeIDindividus :
listeIDindividus.append(IDindividu)
if len(listeIDindividus) == 0 : conditionIndividus = "()"
if len(listeIDindividus) == 1 : conditionIndividus = "(%d)" % listeIDindividus[0]
else : conditionIndividus = str(tuple(listeIDindividus))
listeConditions.append("(cotisations.IDfamille=%d OR (cotisations.IDindividu IN %s AND cotisations.IDfamille IS NULL))" % (self.IDfamille, conditionIndividus))
if len(listeConditions) > 0 :
conditions = "WHERE %s" % " AND ".join(listeConditions)
req = """
SELECT
cotisations.IDcotisation,
cotisations.IDfamille, cotisations.IDindividu, cotisations.IDtype_cotisation, cotisations.IDunite_cotisation,
cotisations.date_saisie, cotisations.IDutilisateur, cotisations.date_creation_carte, cotisations.numero,
cotisations.IDdepot_cotisation, cotisations.date_debut, cotisations.date_fin, cotisations.IDprestation,
types_cotisations.nom, types_cotisations.type, types_cotisations.carte,
unites_cotisations.nom, comptes_payeurs.IDcompte_payeur, cotisations.observations, cotisations.activites
FROM cotisations
LEFT JOIN types_cotisations ON types_cotisations.IDtype_cotisation = cotisations.IDtype_cotisation
LEFT JOIN unites_cotisations ON unites_cotisations.IDunite_cotisation = cotisations.IDunite_cotisation
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = cotisations.IDfamille
%s
""" % conditions
DB.ExecuterReq(req)
listeCotisations = DB.ResultatReq()
DB.Close()
listeListeView = []
listeIDfamilles = []
for item in listeCotisations :
track = Track(self, item, dictFacturation)
# Pour compter le nbre de familles
IDfamille = item[1]
if IDfamille not in listeIDfamilles and IDfamille != None :
listeIDfamilles.append(IDfamille)
valide = True
# 2ème série de filtres
if self.filtres != None :
for filtre in self.filtres :
# Montant
if filtre["type"] == "montant" :
montant = track.montant
if montant == None :
montant = 0.0
if self.ComparateurFiltre(montant, filtre["operateur"], filtre["montant"]) == False :
valide = False
# Solde actuel
if filtre["type"] == "solde_actuel" :
solde = track.solde
if solde == None :
solde = 0.0
if self.ComparateurFiltre(solde, filtre["operateur"], filtre["montant"]) == False :
valide = False
# numero_intervalle
if filtre["type"] == "numero_intervalle" :
if track.numero_int < filtre["numero_min"] or track.numero_int > filtre["numero_max"] :
valide = False
# numero_liste
if filtre["type"] == "numero_liste" :
if track.numero_int not in filtre["liste"] :
valide = False
## if filtre["type"] == "email" :
## if filtre["choix"] == True :
## if dictTemp["email_factures"] == None : valide = False
## else :
## if dictTemp["email_factures"] != None : valide = False
if listeID != None :
if item[0] not in listeID :
valide = False
if valide == True :
listeListeView.append(track)
if self.selectionID == item[0] :
self.selectionTrack = track
self.nbreFamilles = len(listeIDfamilles)
return listeListeView
