def GetTracks(self):
""" Récupération des données """
# Critères
listeID = None
self.criteres = ""
db = GestionDB.DB()
req = """SELECT IDindividu, IDcivilite, nom, prenom, date_naiss
FROM individus ORDER BY nom, prenom;"""
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
# Récupération du dictionnaire des civilités
dictCivilites = Civilites.GetDictCivilites()
listeListeView = []
for IDindividu, IDcivilite, nom, prenom, date_naiss in listeDonnees:
dictTemp = {}
dictTemp["IDindividu"] = IDindividu
dictTemp["IDcivilite"] = IDcivilite
dictTemp["nom"] = nom
dictTemp["prenom"] = prenom
dictTemp["date_naiss"] = date_naiss
# Infos sur la civilité
IDcivilite = dictTemp["IDcivilite"]
if IDcivilite == None: IDcivilite = 1
genre = dictCivilites[IDcivilite]["sexe"]
categorieCivilite = dictCivilites[IDcivilite]["categorie"]
civiliteLong = dictCivilites[IDcivilite]["civiliteLong"]
civiliteAbrege = dictCivilites[IDcivilite]["civiliteAbrege"]
nomImage = dictCivilites[IDcivilite]["nomImage"]
dictTemp["genre"] = genre
dictTemp["categorieCivilite"] = categorieCivilite
dictTemp["civiliteLong"] = civiliteLong
dictTemp["civiliteAbrege"] = civiliteAbrege
dictTemp["nomImage"] = nomImage
if dictTemp["date_naiss"] == None:
dictTemp["age"] = None
else:
datenaissDD = datetime.date(
year=int(dictTemp["date_naiss"][:4]),
month=int(dictTemp["date_naiss"][5:7]),
day=int(dictTemp["date_naiss"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
dictTemp["age"] = age
# Formatage sous forme de TRACK
track = Track(dictTemp)
listeListeView.append(track)
return listeListeView
import Chemins
from Utils import UTILS_Adaptations
from Utils.UTILS_Traduction import _
import wx
from Ctrl import CTRL_Bouton_image
import sys
import FonctionsPerso
import wx.lib.agw.hypertreelist as HTL
import datetime
import GestionDB
from Utils import UTILS_Transports
from Utils import UTILS_Organisateur
from Utils import UTILS_Utilisateurs
from Data import DATA_Civilites
DICT_CIVILITES = DATA_Civilites.GetDictCivilites()
from Data.DATA_Tables import DB_DATA as DICT_TABLES
from Ctrl.CTRL_Saisie_transport import DICT_CATEGORIES
COULEUR_FOND_REGROUPEMENT = (220, 220, 220)
def DateEngFr(textDate):
text = str(textDate[8:10]) + "/" + str(textDate[5:7]) + "/" + str(textDate[:4])
return text
def DateComplete(dateDD):
""" Transforme une date DD en date complète : Ex : lundi 15 janvier 2008 """
listeJours = (_(u"Lundi"), _(u"Mardi"), _(u"Mercredi"), _(u"Jeudi"), _(u"Vendredi"), _(u"Samedi"), _(u"Dimanche"))
listeMois = (_(u"janvier"), _(u"février"), _(u"mars"), _(u"avril"), _(u"mai"), _(u"juin"), _(u"juillet"), _(u"août"), _(u"septembre"), _(u"octobre"), _(u"novembre"), _(u"décembre"))
dateComplete = listeJours[dateDD.weekday()] + " " + str(dateDD.day) + " " + listeMois[dateDD.month-1] + " " + str(dateDD.year)
import traceback
import wx.lib.agw.pybusyinfo as PBI
import GestionDB
from Utils import UTILS_Dates
import FonctionsPerso
from Utils import UTILS_Impression_facture
from Dlg import DLG_Apercu_facture
from Utils import UTILS_Facturation
from Utils import UTILS_Titulaires
from Utils import UTILS_Config
SYMBOLE = UTILS_Config.GetParametre("monnaie_symbole", u"¤")
from Data import DATA_Civilites as Civilites
DICT_CIVILITES = Civilites.GetDictCivilites()
from Utils import UTILS_Interface
from ObjectListView import FastObjectListView, ColumnDefn, Filter, CTRL_Outils, PanelAvecFooter
class Track(object):
def __init__(self, IDcompte_payeur, dictCompte):
self.IDcompte_payeur = IDcompte_payeur
self.dictCompte = dictCompte
self.IDfamille = dictCompte["IDfamille"]
self.total = dictCompte["total"]
self.ventilation = dictCompte["ventilation"]
self.du_periode = self.total - self.ventilation
self.total_reports = dictCompte["total_reports"]
self.du_total = self.total - self.ventilation + self.total_reports
def CreationPDF(self,
nomDoc=FonctionsPerso.GenerationNomDoc(
"INSCRIPTION", "pdf"),
afficherDoc=True):
dictChampsFusion = {}
# Récupération des valeurs de base
dictDonnees = DICT_DONNEES
# Récupération des infos sur l'organisme
DB = GestionDB.DB()
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
dictOrganisme["nom"] = nom
dictOrganisme["rue"] = rue
dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
dictOrganisme["ville"] = ville
dictOrganisme["tel"] = tel
dictOrganisme["fax"] = fax
dictOrganisme["mail"] = mail
dictOrganisme["site"] = site
dictOrganisme["num_agrement"] = num_agrement
dictOrganisme["num_siret"] = num_siret
dictOrganisme["code_ape"] = code_ape
DB.Close()
date_editionDD = datetime.date.today()
# Adresse
self.IDindividu = self.dictInscription["IDINDIVIDU"]
individus = UTILS_Titulaires.GetIndividus()
self.dictInscription["INDIVIDU_RUE"] = individus[
self.IDindividu]["rue"]
self.dictInscription["INDIVIDU_CP"] = individus[self.IDindividu]["cp"]
self.dictInscription["INDIVIDU_VILLE"] = individus[
self.IDindividu]["ville"]
# Nom Titulaires
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille=[
self.IDfamille,
])
self.dictInscription["FAMILLE_NOM"] = dictTitulaires[
self.IDfamille]["titulairesSansCivilite"]
# Civilité
dictCivilites = Civilites.GetDictCivilites()
if self.dictInscription["IDCIVILITE"] == None or self.dictInscription[
"IDCIVILITE"] == "":
IDcivilite = 1
else:
IDcivilite = self.dictInscription["IDCIVILITE"]
self.dictInscription["INDIVIDU_GENRE"] = dictCivilites[IDcivilite][
"sexe"]
self.dictInscription["INDIVIDU_CIVILITE_LONG"] = dictCivilites[
IDcivilite]["civiliteLong"]
self.dictInscription["INDIVIDU_CIVILITE_COURT"] = dictCivilites[
IDcivilite]["civiliteAbrege"]
# Date de naissance
if self.dictInscription["INDIVIDU_DATE_NAISS"] == None:
self.dictInscription["INDIVIDU_AGE"] = None
else:
datenaissDD = datetime.date(
year=int(self.dictInscription["INDIVIDU_DATE_NAISS"][:4]),
month=int(self.dictInscription["INDIVIDU_DATE_NAISS"][5:7]),
day=int(self.dictInscription["INDIVIDU_DATE_NAISS"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
self.dictInscription["INDIVIDU_AGE"] = age
# Insertion des données de base dans le dictValeurs
IDfamille = self.IDfamille
dictValeurs = {
"IDfamille":
self.IDfamille,
"{IDFAMILLE}":
str(self.IDfamille),
"{DATE_EDITION}":
DateEngFr(str(date_editionDD)),
"{DATE_EDITION_LONG}":
DateComplete(date_editionDD),
"{DATE_EDITION_COURT}":
DateEngFr(str(date_editionDD)),
"{ORGANISATEUR_NOM}":
dictOrganisme["nom"],
"{ORGANISATEUR_RUE}":
dictOrganisme["rue"],
"{ORGANISATEUR_CP}":
dictOrganisme["cp"],
"{ORGANISATEUR_VILLE}":
dictOrganisme["ville"],
"{ORGANISATEUR_TEL}":
dictOrganisme["tel"],
"{ORGANISATEUR_FAX}":
dictOrganisme["fax"],
"{ORGANISATEUR_MAIL}":
dictOrganisme["mail"],
"{ORGANISATEUR_SITE}":
dictOrganisme["site"],
"{ORGANISATEUR_AGREMENT}":
dictOrganisme["num_agrement"],
"{ORGANISATEUR_SIRET}":
dictOrganisme["num_siret"],
"{ORGANISATEUR_APE}":
dictOrganisme["code_ape"],
"{IDINSCRIPTION}":
FormateStr(self.dictInscription["IDINSCRIPTION"]),
"{DATE_INSCRIPTION}":
FormateDate(self.dictInscription["DATE_INSCRIPTION"]),
"{EST_PARTI}":
FormateBool(self.dictInscription["EST_PARTI"]),
"{IDACTIVITE}":
FormateStr(self.dictInscription["IDACTIVITE"]),
"{ACTIVITE_NOM_LONG}":
FormateStr(self.dictInscription["ACTIVITE_NOM_LONG"]),
"{ACTIVITE_NOM_COURT}":
FormateStr(self.dictInscription["ACTIVITE_NOM_COURT"]),
"{IDGROUPE}":
FormateStr(self.dictInscription["IDGROUPE"]),
"{GROUPE_NOM_LONG}":
FormateStr(self.dictInscription["GROUPE_NOM_LONG"]),
"{GROUPE_NOM_COURT}":
FormateStr(self.dictInscription["GROUPE_NOM_COURT"]),
"{IDCATEGORIETARIF}":
FormateStr(self.dictInscription["IDCATEGORIETARIF"]),
"{NOM_CATEGORIE_TARIF}":
FormateStr(self.dictInscription["NOM_CATEGORIE_TARIF"]),
"{IDINDIVIDU}":
FormateStr(self.dictInscription["IDINDIVIDU"]),
"{INDIVIDU_CIVILITE_LONG}":
FormateStr(self.dictInscription["INDIVIDU_CIVILITE_LONG"]),
"{INDIVIDU_CIVILITE_COURT}":
FormateStr(self.dictInscription["INDIVIDU_CIVILITE_COURT"]),
"{INDIVIDU_GENRE}":
FormateStr(self.dictInscription["INDIVIDU_GENRE"]),
"{INDIVIDU_NOM}":
FormateStr(self.dictInscription["INDIVIDU_NOM"]),
"{INDIVIDU_PRENOM}":
FormateStr(self.dictInscription["INDIVIDU_PRENOM"]),
"{INDIVIDU_DATE_NAISS}":
FormateDate(self.dictInscription["INDIVIDU_DATE_NAISS"]),
"{INDIVIDU_AGE}":
FormateStr(self.dictInscription["INDIVIDU_AGE"]),
"{INDIVIDU_CP_NAISS}":
FormateStr(self.dictInscription["INDIVIDU_CP_NAISS"]),
"{INDIVIDU_VILLE_NAISS}":
FormateStr(self.dictInscription["INDIVIDU_VILLE_NAISS"]),
"{INDIVIDU_RUE}":
FormateStr(self.dictInscription["INDIVIDU_RUE"]),
"{INDIVIDU_CP}":
FormateStr(self.dictInscription["INDIVIDU_CP"]),
"{INDIVIDU_VILLE}":
FormateStr(self.dictInscription["INDIVIDU_VILLE"]),
"{INDIVIDU_PROFESSION}":
FormateStr(self.dictInscription["INDIVIDU_PROFESSION"]),
"{INDIVIDU_EMPLOYEUR}":
FormateStr(self.dictInscription["INDIVIDU_EMPLOYEUR"]),
"{INDIVIDU_TEL_DOMICILE}":
FormateStr(self.dictInscription["INDIVIDU_TEL_DOMICILE"]),
"{INDIVIDU_TEL_MOBILE}":
FormateStr(self.dictInscription["INDIVIDU_TEL_MOBILE"]),
"{INDIVIDU_FAX}":
FormateStr(self.dictInscription["INDIVIDU_FAX"]),
"{INDIVIDU_EMAIL}":
FormateStr(self.dictInscription["INDIVIDU_EMAIL"]),
"{INDIVIDU_TEL_PRO}":
FormateStr(self.dictInscription["INDIVIDU_TEL_PRO"]),
"{INDIVIDU_FAX_PRO}":
FormateStr(self.dictInscription["INDIVIDU_FAX_PRO"]),
"{INDIVIDU_EMAIL_PRO}":
FormateStr(self.dictInscription["INDIVIDU_EMAIL_PRO"]),
"{FAMILLE_NOM}":
FormateStr(self.dictInscription["FAMILLE_NOM"]),
"{FAMILLE_CAISSE}":
FormateStr(self.dictInscription["FAMILLE_CAISSE"]),
"{FAMILLE_REGIME}":
FormateStr(self.dictInscription["FAMILLE_REGIME"]),
"{FAMILLE_NUMALLOC}":
FormateStr(self.dictInscription["FAMILLE_NUMALLOC"]),
}
# Récupération des infos de base individus et familles
self.infosIndividus = UTILS_Infos_individus.Informations()
dictValeurs.update(
self.infosIndividus.GetDictValeurs(mode="famille",
ID=IDfamille,
formatChamp=True))
dictValeurs.update(
self.infosIndividus.GetDictValeurs(
mode="individu",
ID=self.dictInscription["IDINDIVIDU"],
formatChamp=True))
# Récupération des questionnaires
Questionnaires = UTILS_Questionnaires.ChampsEtReponses(type="famille")
for dictReponse in Questionnaires.GetDonnees(IDfamille):
dictValeurs[dictReponse["champ"]] = dictReponse["reponse"]
if dictReponse["controle"] == "codebarres":
dictValeurs["{CODEBARRES_QUESTION_%d}" %
dictReponse["IDquestion"]] = dictReponse["reponse"]
# Récupération du signataire
infosSignataire = self.ctrl_signataire.GetInfos()
if infosSignataire == None:
dlg = wx.MessageDialog(
self, _(u"Vous n'avez sélectionné aucun signataire !"),
_(u"Annulation"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
nomSignataire = infosSignataire["nom"]
fonctionSignataire = infosSignataire["fonction"]
sexeSignataire = infosSignataire["sexe"]
if sexeSignataire == "H":
genreSignataire = u""
else:
genreSignataire = u"e"
# Récupération et transformation du texte d'intro
if self.ctrl_intro.GetValue() == True:
textIntro = self.ctrl_texte_intro.GetValue()
textIntro = textIntro.replace("{SIGNATAIRE_GENRE}",
genreSignataire)
textIntro = textIntro.replace("{SIGNATAIRE_NOM}", nomSignataire)
textIntro = textIntro.replace("{SIGNATAIRE_FONCTION}",
fonctionSignataire)
for key, valeur in dictValeurs.items():
if key.startswith("{"):
if valeur == None: valeur = ""
if type(valeur) == int: valeur = str(valeur)
textIntro = textIntro.replace(key, valeur)
dictValeurs["intro"] = textIntro
else:
dictValeurs["intro"] = None
# Tableau
dictValeurs["tableau"] = self.ctrl_tableau.GetValue()
for key, valeur in dictValeurs.items():
if valeur == None: valeur = ""
dictChampsFusion[key] = valeur
# Préparation des données pour une sauvegarde dans l'historique
self.dictSave = {}
self.dictSave["activite"] = self.dictInscription["ACTIVITE_NOM_LONG"]
self.dictSave["groupe"] = self.dictInscription["GROUPE_NOM_LONG"]
# Récupération du modèle
IDmodele = self.ctrl_modele.GetID()
if IDmodele == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez obligatoirement sélectionner un modèle !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Fabrication du PDF
from Utils import UTILS_Impression_inscription
UTILS_Impression_inscription.Impression(dictValeurs,
IDmodele=IDmodele,
nomDoc=nomDoc,
afficherDoc=afficherDoc)
return dictChampsFusion
def GetTracks(self):
""" Récupération des données """
# Récupération des données dans la base
listeChamps = ("individus.IDindividu", "IDcivilite", "nom", "prenom",
"num_secu", "IDnationalite", "date_naiss",
"IDpays_naiss", "cp_naiss", "ville_naiss",
"adresse_auto", "rue_resid", "cp_resid", "ville_resid",
"IDcategorie_travail", "profession", "employeur",
"travail_tel", "travail_fax", "travail_mail",
"tel_domicile", "tel_mobile", "tel_fax", "mail", "etat")
conditions = "etat IS NULL"
if "archives" in self.dictParametres and self.dictParametres[
"archives"] == True:
conditions += " OR etat='archive'"
if "effaces" in self.dictParametres and self.dictParametres[
"effaces"] == True:
conditions += " OR etat='efface'"
db = GestionDB.DB()
req = """SELECT %s FROM individus WHERE %s;""" % (
",".join(listeChamps), conditions)
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
# Récupération du dictionnaire des civilités
dictCivilites = Civilites.GetDictCivilites()
# Création du dictionnaire des données
dictIndividus = {}
for valeurs in listeDonnees:
IDindividu = valeurs[0]
dictTemp = {}
# Infos de la table Individus
for index in range(0, len(listeChamps)):
nomChamp = listeChamps[index]
dictTemp[nomChamp] = valeurs[index]
# Infos sur la civilité
if dictTemp["IDcivilite"] != None and dictTemp["IDcivilite"] != "":
dictTemp["genre"] = dictCivilites[
dictTemp["IDcivilite"]]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[
dictTemp["IDcivilite"]]["categorie"]
dictTemp["civiliteLong"] = dictCivilites[
dictTemp["IDcivilite"]]["civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[
dictTemp["IDcivilite"]]["civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[
dictTemp["IDcivilite"]]["nomImage"]
else:
dictTemp["genre"] = ""
dictTemp["categorieCivilite"] = ""
dictTemp["civiliteLong"] = ""
dictTemp["civiliteAbrege"] = ""
dictTemp["nomImage"] = None
if dictTemp["date_naiss"] == None:
dictTemp["age"] = None
else:
try:
datenaissDD = UTILS_Dates.DateEngEnDateDD(
dictTemp["date_naiss"])
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
dictTemp["age"] = age
dictTemp["date_naiss"] = datenaissDD
except:
dictTemp["age"] = None
dictIndividus[IDindividu] = dictTemp
# Vérifie si le dictIndividus est différent du précédent pour empêcher l'actualisation de la liste
if dictIndividus == self.dictIndividus and self.forceActualisation == False:
return None
else:
self.dictIndividus = dictIndividus
filtre = None
# Si filtre activités
if len(self.dictParametres["activites"]) > 0:
conditionActivites = GestionDB.ConvertConditionChaine(
self.dictParametres["activites"])
db = GestionDB.DB()
req = """SELECT individus.IDindividu, nom
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
WHERE inscriptions.statut='ok' AND inscriptions.IDactivite IN %s
;""" % conditionActivites
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
filtre = []
for ID, nom in listeDonnees:
filtre.append(ID)
# Si filtre Groupes d'activités
if len(self.dictParametres["groupes_activites"]) > 0:
conditionGroupesActivites = GestionDB.ConvertConditionChaine(
self.dictParametres["groupes_activites"])
db = GestionDB.DB()
req = """SELECT individus.IDindividu, nom
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
LEFT JOIN groupes_activites ON groupes_activites.IDactivite = inscriptions.IDactivite
WHERE inscriptions.statut='ok' AND groupes_activites.IDtype_groupe_activite IN %s
;""" % conditionGroupesActivites
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
filtre = []
for ID, nom in listeDonnees:
filtre.append(ID)
# Création des Tracks
listeListeView = []
self.dictTracks = {}
for IDindividu, dictTemp in dictIndividus.items():
if filtre == None or IDindividu in filtre:
track = Track(dictTemp, dictIndividus)
listeListeView.append(track)
self.dictTracks[IDindividu] = track
return listeListeView
def GetDictIndividus():
""" Récupération des infos sur les individus """
# Récupération des adresses
DB = GestionDB.DB()
req = """SELECT IDindividu, individus.nom, prenom, rue_resid, cp_resid, ville_resid, secteurs.nom
FROM individus
LEFT JOIN secteurs ON secteurs.IDsecteur = individus.IDsecteur
;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictAdresses = {}
for IDindividu, nom, prenom, rue_resid, cp_resid, ville_resid, secteur in listeDonnees :
if secteur == None : secteur = ""
dictAdresses[IDindividu] = { "nom" : nom, "prenom" : prenom, "rue_resid" : rue_resid, "cp_resid" : cp_resid, "ville_resid" : ville_resid, "secteur" : secteur}
# Récupération des individus
listeChamps = (
"IDindividu", "IDcivilite", "nom", "prenom", "num_secu","IDnationalite",
"date_naiss", "IDpays_naiss", "cp_naiss", "ville_naiss",
"adresse_auto", "rue_resid", "cp_resid", "ville_resid",
"IDcategorie_travail", "profession", "employeur", "travail_tel", "travail_fax", "travail_mail",
"tel_domicile", "tel_mobile", "tel_fax", "mail"
)
req = """
SELECT %s FROM individus;""" % ",".join(listeChamps)
DB.ExecuterReq(req)
listeIndividus= DB.ResultatReq()
DB.Close()
# Récupération des civilités
dictCivilites = Civilites.GetDictCivilites()
dictResultats = {}
for valeurs in listeIndividus :
dictTemp = {}
IDindividu = valeurs[0]
dictTemp["IDindividu"] = IDindividu
# Infos de la table Individus
for index in range(0, len(listeChamps)) :
nomChamp = listeChamps[index]
dictTemp[nomChamp] = valeurs[index]
# Infos sur la civilité
dictTemp["genre"] = dictCivilites[dictTemp["IDcivilite"]]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[dictTemp["IDcivilite"]]["categorie"]
dictTemp["civiliteLong"] = dictCivilites[dictTemp["IDcivilite"]]["civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[dictTemp["IDcivilite"]]["civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[dictTemp["IDcivilite"]]["nomImage"]
# Age
if dictTemp["date_naiss"] == None :
dictTemp["age"] = None
else:
datenaissDD = datetime.date(year=int(dictTemp["date_naiss"][:4]), month=int(dictTemp["date_naiss"][5:7]), day=int(dictTemp["date_naiss"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int((datedujour.month, datedujour.day) < (datenaissDD.month, datenaissDD.day))
dictTemp["date_naiss"] = datenaissDD
dictTemp["age"] = age
# Secteur
dictTemp["secteur"] = dictAdresses[IDindividu]["secteur"]
# Adresse auto ou manuelle
if dictTemp["adresse_auto"] != None and dictAdresses.has_key(dictTemp["adresse_auto"]) :
dictTemp["rue_resid"] = dictAdresses[dictTemp["adresse_auto"]]["rue_resid"]
dictTemp["cp_resid"] = dictAdresses[dictTemp["adresse_auto"]]["cp_resid"]
dictTemp["ville_resid"] = dictAdresses[dictTemp["adresse_auto"]]["ville_resid"]
dictTemp["secteur"] = dictAdresses[dictTemp["adresse_auto"]]["secteur"]
dictResultats[dictTemp["IDindividu"]] = dictTemp
return dictResultats
def GetListeIndividus(listview=None,
listeActivites=None,
presents=None,
IDindividu=None,
infosIndividus=None):
# Conditions Activites
if listeActivites == None or listeActivites == []:
conditionActivites = ""
else:
if len(listeActivites) == 1:
conditionActivites = " AND inscriptions.IDactivite=%d" % listeActivites[
0]
else:
conditionActivites = " AND inscriptions.IDactivite IN %s" % str(
tuple(listeActivites))
# Conditions Présents
conditionPresents = ""
jointurePresents = ""
if presents != None:
conditionPresents = " AND (consommations.date>='%s' AND consommations.date<='%s')" % (
str(presents[0]), str(presents[1]))
jointurePresents = "LEFT JOIN consommations ON consommations.IDindividu = individus.IDindividu"
# Condition Individu donné
conditionIndividus = ""
if IDindividu != None:
conditionIndividus = " AND individus.IDindividu=%d" % IDindividu
# Récupération des individus
listeChamps = ("individus.IDindividu", "IDcivilite", "nom", "prenom",
"num_secu", "IDnationalite", "date_naiss", "IDpays_naiss",
"cp_naiss", "ville_naiss", "adresse_auto", "rue_resid",
"cp_resid", "ville_resid", "IDcategorie_travail",
"profession", "employeur", "travail_tel", "travail_fax",
"travail_mail", "tel_domicile", "tel_mobile", "tel_fax",
"mail")
DB = GestionDB.DB()
req = """
SELECT %s
FROM individus
LEFT JOIN inscriptions ON inscriptions.IDindividu = individus.IDindividu
%s
WHERE (inscriptions.parti=0 OR inscriptions.parti IS NULL) %s %s %s
GROUP BY individus.IDindividu
;""" % (",".join(listeChamps), jointurePresents, conditionActivites,
conditionPresents, conditionIndividus)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
# Récupération des civilités
dictCivilites = Civilites.GetDictCivilites()
# Récupération des adresses auto
GetDictInfosIndividus()
listeListeView = []
for valeurs in listeDonnees:
dictTemp = {}
dictTemp["IDindividu"] = valeurs[0]
# Infos de la table Individus
for index in range(0, len(listeChamps)):
nomChamp = listeChamps[index]
dictTemp[nomChamp] = valeurs[index]
# Infos sur la civilité
if dictTemp["IDcivilite"] == None or dictTemp["IDcivilite"] == "":
IDcivilite = 1
else:
IDcivilite = dictTemp["IDcivilite"]
dictTemp["genre"] = dictCivilites[IDcivilite]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[IDcivilite]["categorie"]
dictTemp["civiliteLong"] = dictCivilites[IDcivilite]["civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[IDcivilite][
"civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[IDcivilite]["nomImage"]
if dictTemp["date_naiss"] == None:
dictTemp["age"] = None
else:
datenaissDD = datetime.date(year=int(dictTemp["date_naiss"][:4]),
month=int(dictTemp["date_naiss"][5:7]),
day=int(dictTemp["date_naiss"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
dictTemp["age"] = age
# Formatage sous forme de TRACK
track = TrackIndividu(listview, dictTemp, infosIndividus)
listeListeView.append(track)
return listeListeView
def GetListe(listeActivites=None, presents=None):
if listeActivites == None: return []
# Conditions Activites
if listeActivites == None or listeActivites == []:
conditionActivites = ""
else:
if len(listeActivites) == 1:
conditionActivites = " AND inscriptions.IDactivite=%d" % listeActivites[
0]
else:
conditionActivites = " AND inscriptions.IDactivite IN %s" % str(
tuple(listeActivites))
# Conditions Présents
## if presents == None :
## conditionPresents = ""
## jointurePresents = ""
## else:
## conditionPresents = " AND consommations.date>='%s' AND consommations.date<='%s' AND consommations.etat IN ('reservation', 'present')" % (str(presents[0]), str(presents[1]))
## jointurePresents = "LEFT JOIN consommations ON consommations.IDindividu = individus.IDindividu"
DB = GestionDB.DB()
# Récupération des présents
listePresents = []
if presents != None:
req = """SELECT IDindividu, IDinscription
FROM consommations
WHERE date>='%s' AND date<='%s' %s
GROUP BY IDindividu
;""" % (str(presents[0]), str(presents[1]),
conditionActivites.replace("inscriptions", "consommations"))
DB.ExecuterReq(req)
listeIndividusPresents = DB.ResultatReq()
for IDindividu, IDinscription in listeIndividusPresents:
listePresents.append(IDindividu)
# Récupération des individus
listeChamps = ("individus.IDindividu", "IDcivilite", "nom", "prenom",
"num_secu", "IDnationalite", "date_naiss", "IDpays_naiss",
"cp_naiss", "ville_naiss", "adresse_auto", "rue_resid",
"cp_resid", "ville_resid", "IDcategorie_travail",
"profession", "employeur", "travail_tel", "travail_fax",
"travail_mail", "tel_domicile", "tel_mobile", "tel_fax",
"mail")
req = """
SELECT %s
FROM inscriptions
LEFT JOIN individus ON individus.IDindividu = inscriptions.IDindividu
WHERE inscriptions.parti=0 %s
GROUP BY individus.IDindividu
;""" % (",".join(listeChamps), conditionActivites)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
# Récupération des civilités
dictCivilites = Civilites.GetDictCivilites()
# Récupération des adresses auto
GetDictInfosIndividus()
listeListeView = []
for valeurs in listeDonnees:
IDindividu = valeurs[0]
if presents == None or (presents != None
and IDindividu in listePresents):
dictTemp = {}
dictTemp["IDindividu"] = valeurs[0]
# Infos de la table Individus
for index in range(0, len(listeChamps)):
nomChamp = listeChamps[index]
dictTemp[nomChamp] = valeurs[index]
# Infos sur la civilité
if dictTemp["IDcivilite"] != None and dictTemp["IDcivilite"] != "":
IDcivilite = dictTemp["IDcivilite"]
else:
IDcivilite = 1
dictTemp["genre"] = dictCivilites[IDcivilite]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[IDcivilite][
"categorie"]
dictTemp["civiliteLong"] = dictCivilites[IDcivilite][
"civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[IDcivilite][
"civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[IDcivilite]["nomImage"]
if dictTemp["date_naiss"] == None:
dictTemp["age"] = None
else:
datenaissDD = datetime.date(
year=int(dictTemp["date_naiss"][:4]),
month=int(dictTemp["date_naiss"][5:7]),
day=int(dictTemp["date_naiss"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
dictTemp["age"] = age
# Formatage sous forme de TRACK
track = Track(dictTemp)
listeListeView.append(track)
return listeListeView
def GetListeIndividus(listview=None, infosIndividus=None):
# Récupération des individus
listeChamps = (
"rattachements.IDindividu",
"IDcivilite",
"nom",
"prenom",
"num_secu",
"IDnationalite",
"date_naiss",
"IDpays_naiss",
"cp_naiss",
"ville_naiss",
"adresse_auto",
"rue_resid",
"cp_resid",
"ville_resid",
"rattachements.IDfamille",
"IDcompte_payeur",
)
DB = GestionDB.DB()
req = """SELECT %s
FROM rattachements
LEFT JOIN individus ON individus.IDindividu = rattachements.IDindividu
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = rattachements.IDfamille
WHERE IDcategorie IN (1, 2)
;""" % ",".join(listeChamps)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
filtre_IDindividu = []
if listview.masquer == True and listview.IDunite != None:
req = """SELECT IDindividu, IDcotisation FROM cotisations WHERE IDunite_cotisation=%d;""" % listview.IDunite
DB.ExecuterReq(req)
listeCotisations = DB.ResultatReq()
filtre_IDindividu = [
IDindividu for IDindividu, IDcotisation in listeCotisations
]
DB.Close()
# Récupération des civilités
dictCivilites = Civilites.GetDictCivilites()
# Récupération des adresses auto
GetDictInfosIndividus()
listeListeView = []
titulaires = UTILS_Titulaires.GetTitulaires()
for valeurs in listeDonnees:
dictTemp = {}
dictTemp["IDindividu"] = valeurs[0]
# Infos de la table Individus
for index in range(0, len(listeChamps)):
nomChamp = listeChamps[index]
dictTemp[nomChamp] = valeurs[index]
# Infos sur la civilité
if dictTemp["IDcivilite"] == None or dictTemp["IDcivilite"] == "":
IDcivilite = 1
else:
IDcivilite = dictTemp["IDcivilite"]
dictTemp["genre"] = dictCivilites[IDcivilite]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[IDcivilite]["categorie"]
dictTemp["civiliteLong"] = dictCivilites[IDcivilite]["civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[IDcivilite][
"civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[IDcivilite]["nomImage"]
if dictTemp["date_naiss"] == None:
dictTemp["age"] = None
else:
datenaissDD = datetime.date(year=int(dictTemp["date_naiss"][:4]),
month=int(dictTemp["date_naiss"][5:7]),
day=int(dictTemp["date_naiss"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int(
(datedujour.month, datedujour.day) <
(datenaissDD.month, datenaissDD.day))
dictTemp["age"] = age
IDfamille = dictTemp["rattachements.IDfamille"]
if IDfamille != None and IDfamille in titulaires:
nomTitulaires = titulaires[IDfamille]["titulairesSansCivilite"]
else:
nomTitulaires = _(u"Aucun titulaire")
dictTemp["nomTitulaires"] = nomTitulaires
# Formatage sous forme de TRACK
if dictTemp["IDindividu"] not in filtre_IDindividu:
track = TrackIndividu(listview, dictTemp, infosIndividus)
listeListeView.append(track)
return listeListeView
def GetTracks(self):
""" Récupération des données """
# Conditions
conditions = []
if self.IDecole != None :
conditions.append("scolarite.IDecole=%d " % self.IDecole)
if self.IDclasse != None :
conditions.append("scolarite.IDclasse=%d " % self.IDclasse)
if self.IDniveau != None :
conditions.append("scolarite.IDniveau=%d " % self.IDniveau)
if len(conditions) > 0 :
txtConditions = "WHERE %s" % " AND ".join(conditions)
else :
txtConditions = ""
# Récupération des individus
DB = GestionDB.DB()
req = """
SELECT individus.IDindividu, individus.IDcivilite, individus.nom, individus.prenom, individus.date_naiss,
IDscolarite, MIN(date_debut), MAX(date_fin), scolarite.IDniveau, niveaux_scolaires.abrege
FROM individus
LEFT JOIN scolarite ON scolarite.IDindividu = individus.IDindividu
LEFT JOIN niveaux_scolaires ON niveaux_scolaires.IDniveau = scolarite.IDniveau
%s
GROUP BY individus.IDindividu
ORDER BY individus.nom, individus.prenom, scolarite.IDniveau
;""" % txtConditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
# Récupération des civilités
dictCivilites = Civilites.GetDictCivilites()
listeListeView = []
for valeurs in listeDonnees :
dictTemp = {}
dictTemp["IDindividu"] = valeurs[0]
dictTemp["IDcivilite"] = valeurs[1]
dictTemp["nomIndividu"] = valeurs[2]
dictTemp["prenomIndividu"] = valeurs[3]
dictTemp["date_naiss"] = valeurs[4]
dictTemp["IDscolarite"] = valeurs[5]
dictTemp["date_debut"] = valeurs[6]
dictTemp["date_fin"] = valeurs[7]
dictTemp["IDniveau"] = valeurs[8]
dictTemp["abregeNiveau"] = valeurs[9]
# Infos sur la civilité
dictTemp["genre"] = dictCivilites[dictTemp["IDcivilite"]]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[dictTemp["IDcivilite"]]["categorie"]
dictTemp["civiliteLong"] = dictCivilites[dictTemp["IDcivilite"]]["civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[dictTemp["IDcivilite"]]["civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[dictTemp["IDcivilite"]]["nomImage"]
if dictTemp["date_naiss"] == None :
dictTemp["age"] = None
else:
datenaissDD = datetime.date(year=int(dictTemp["date_naiss"][:4]), month=int(dictTemp["date_naiss"][5:7]), day=int(dictTemp["date_naiss"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int((datedujour.month, datedujour.day) < (datenaissDD.month, datenaissDD.day))
dictTemp["age"] = age
# Spécial
if self.IDclasse == None :
dictTemp["IDniveau"] = None
dictTemp["abregeNiveau"] = u""
# Formatage sous forme de TRACK
track = Track(dictTemp)
listeListeView.append(track)
return listeListeView
def GetListe(IDclasse=None, IDindividu=None):
if IDclasse == None and IDindividu == None:
return []
# Conditions
if IDindividu == None :
condition = "scolarite.IDclasse=%d" % IDclasse
else:
condition = "scolarite.IDindividu=%d" % IDindividu
# Récupération des individus
DB = GestionDB.DB()
req = """
SELECT IDscolarite, scolarite.date_debut, scolarite.date_fin, scolarite.IDindividu, scolarite.IDniveau,
individus.IDcivilite, individus.nom, individus.prenom, individus.date_naiss,
niveaux_scolaires.abrege, scolarite.IDecole, ecoles.nom, scolarite.IDclasse, classes.nom
FROM scolarite
LEFT JOIN individus ON individus.IDindividu = scolarite.IDindividu
LEFT JOIN ecoles ON ecoles.IDecole = scolarite.IDecole
LEFT JOIN classes ON classes.IDclasse = scolarite.IDclasse
LEFT JOIN niveaux_scolaires ON niveaux_scolaires.IDniveau = scolarite.IDniveau
WHERE %s
ORDER BY individus.nom, individus.prenom
;""" % condition
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
# Récupération des civilités
dictCivilites = Civilites.GetDictCivilites()
listeListeView = []
for valeurs in listeDonnees :
dictTemp = {}
dictTemp["IDscolarite"] = valeurs[0]
dictTemp["date_debut"] = valeurs[1]
dictTemp["date_fin"] = valeurs[2]
dictTemp["IDindividu"] = valeurs[3]
dictTemp["IDniveau"] = valeurs[4]
dictTemp["IDcivilite"] = valeurs[5]
dictTemp["nomIndividu"] = valeurs[6]
dictTemp["prenomIndividu"] = valeurs[7]
dictTemp["date_naiss"] = valeurs[8]
dictTemp["abregeNiveau"] = valeurs[9]
dictTemp["IDecole"] = valeurs[10]
dictTemp["nomEcole"] = valeurs[11]
dictTemp["IDclasse"] = valeurs[12]
dictTemp["nomClasse"] = valeurs[13]
# Infos sur la civilité
dictTemp["genre"] = dictCivilites[dictTemp["IDcivilite"]]["sexe"]
dictTemp["categorieCivilite"] = dictCivilites[dictTemp["IDcivilite"]]["categorie"]
dictTemp["civiliteLong"] = dictCivilites[dictTemp["IDcivilite"]]["civiliteLong"]
dictTemp["civiliteAbrege"] = dictCivilites[dictTemp["IDcivilite"]]["civiliteAbrege"]
dictTemp["nomImage"] = dictCivilites[dictTemp["IDcivilite"]]["nomImage"]
if dictTemp["date_naiss"] == None :
dictTemp["age"] = None
else:
datenaissDD = datetime.date(year=int(dictTemp["date_naiss"][:4]), month=int(dictTemp["date_naiss"][5:7]), day=int(dictTemp["date_naiss"][8:10]))
datedujour = datetime.date.today()
age = (datedujour.year - datenaissDD.year) - int((datedujour.month, datedujour.day) < (datenaissDD.month, datenaissDD.day))
dictTemp["age"] = age
# Formatage sous forme de TRACK
track = Track(dictTemp)
listeListeView.append(track)
return listeListeView
