def GetNomFamille(self):
try :
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille=[self.IDfamille,])
nomTitulaires = dictTitulaires[self.IDfamille]["titulairesSansCivilite"]
except :
nomTitulaires = u""
return nomTitulaires
def MAJ(self,
IDindividu=None,
IDactivite=None,
partis=True,
listeGroupes=[],
listeCategories=[],
regroupement=None,
listeColonnes=[],
labelParametres="",
date_reference=datetime.date.today()):
self.IDactivite = IDactivite
self.partis = partis
self.listeGroupes = listeGroupes
self.listeCategories = listeCategories
self.regroupement = regroupement
self.labelParametres = labelParametres
if IDindividu is not None:
self.selectionID = IDindividu
self.selectionTrack = None
else:
self.selectionID = None
self.selectionTrack = None
attente = wx.BusyInfo(_(u"Recherche des données..."), self)
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
self.InitModel(date_reference=date_reference)
self.InitObjectListView()
del attente
# Sélection d'un item
if self.selectionTrack is not None:
self.SelectObject(self.selectionTrack,
deselectOthers=True,
ensureVisible=True)
self.selectionID = None
self.selectionTrack = None
def GetTracks(self):
""" Récupération des données """
dictTitulaires = UTILS_Titulaires.GetTitulaires()
DB = GestionDB.DB()
# Lecture Actions
liste_conditions = []
if self.cacher_traitees == True:
liste_conditions.append("etat <> 'validation'")
if self.IDfamille != None:
liste_conditions.append("IDfamille=%d" % self.IDfamille)
if len(liste_conditions) > 0:
conditions = "WHERE %s" % " AND ".join(liste_conditions)
else:
conditions = ""
req = """SELECT IDaction, horodatage, IDfamille, IDindividu, categorie, action, description, commentaire, parametres, etat, traitement_date, portail_actions.IDperiode, reponse, email_date,
portail_periodes.nom, portail_periodes.date_debut, portail_periodes.date_fin, portail_periodes.IDmodele
FROM portail_actions
LEFT JOIN portail_periodes ON portail_periodes.IDperiode = portail_actions.IDperiode
%s;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeActions = []
for IDaction, horodatage, IDfamille, IDindividu, categorie, action, description, commentaire, parametres, etat, traitement_date, IDperiode, reponse, email_date, periode_nom, periode_date_debut, periode_date_fin, periode_IDmodele in listeDonnees:
traitement_date = UTILS_Dates.DateEngEnDateDD(traitement_date)
email_date = UTILS_Dates.DateEngEnDateDD(email_date)
horodatage = UTILS_Dates.DateEngEnDateDDT(horodatage)
periode_date_debut = UTILS_Dates.DateEngEnDateDD(
periode_date_debut)
periode_date_fin = UTILS_Dates.DateEngEnDateDD(periode_date_fin)
listeActions.append({
"IDaction": IDaction,
"horodatage": horodatage,
"IDfamille": IDfamille,
"IDindividu": IDindividu,
"categorie": categorie,
"action": action,
"description": description,
"commentaire": commentaire,
"parametres": parametres,
"etat": etat,
"traitement_date": traitement_date,
"IDperiode": IDperiode,
"reponse": reponse,
"email_date": email_date,
"periode_nom": periode_nom,
"periode_date_debut": periode_date_debut,
"periode_date_fin": periode_date_fin,
"periode_IDmodele": periode_IDmodele,
})
listeListeView = []
for action in listeActions:
listeListeView.append(Track(self, action, dictTitulaires))
return listeListeView
def GetNomsTitulaires(self, IDfamille=None):
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille=[IDfamille,])
if dictTitulaires.has_key(IDfamille) :
noms = dictTitulaires[IDfamille]["titulairesSansCivilite"]
else :
noms = "?"
return noms
def SetIDfamille(self, IDfamille=None):
self.IDfamille = IDfamille
# Recherche du nom des titulaires
dictNomsTitulaires = UTILS_Titulaires.GetTitulaires([self.IDfamille, ])
nomsTitulaires = dictNomsTitulaires[self.IDfamille]["titulairesSansCivilite"]
self.SetValue(nomsTitulaires)
def GetTracks(self):
""" Récupération des données """
self.titulaires = UTILS_Titulaires.GetTitulaires()
if self.IDdepot_cotisation == None:
IDdepot_cotisation = 0
else:
IDdepot_cotisation = self.IDdepot_cotisation
db = GestionDB.DB()
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, cotisations.observations, cotisations.activites,
individus.nom, individus.prenom
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 individus ON individus.IDindividu = cotisations.IDindividu
WHERE cotisations.IDdepot_cotisation IS NULL OR cotisations.IDdepot_cotisation=%d;
""" % IDdepot_cotisation
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
listeListeView = []
for item in listeDonnees:
track = Track(self, item)
listeListeView.append(track)
return listeListeView
def GetListeDonnees(self):
titulaires = UTILS_Titulaires.GetTitulaires()
listeFamilles = []
for IDfamille, dictTemp in titulaires.iteritems():
listeFamilles.append((dictTemp["titulairesSansCivilite"],
IDfamille, dictTemp["IDcompte_payeur"]))
listeFamilles.sort()
listeItems = [
u"",
]
self.dictDonnees = {}
self.dictDonnees[0] = {
"IDfamille": 0,
"nom": _(u"Inconnue"),
"IDcompte_payeur": 0
}
index = 1
for nom, IDfamille, IDcompte_payeur in listeFamilles:
self.dictDonnees[index] = {
"IDfamille": IDfamille,
"nom ": nom,
"IDcompte_payeur": IDcompte_payeur
}
listeItems.append(nom)
index += 1
return listeItems
def GetTracks(self):
""" Récupération des données """
dictTitulaires = UTILS_Titulaires.GetTitulaires()
listeID = None
# Récupération des RIB
DB = GestionDB.DB()
req = """SELECT familles.IDfamille, prelevement_iban, prelevement_bic, prelevement_banque,
prelevement_individu, prelevement_nom, prelevement_rue, prelevement_cp, prelevement_ville,
prelevement_reference_mandat, prelevement_date_mandat, prelevement_memo,
mandats.IDmandat, individus.nom, individus.prenom,
banques.nom
FROM familles
LEFT JOIN mandats ON mandats.rum = familles.prelevement_reference_mandat
LEFT JOIN individus ON individus.IDindividu = familles.prelevement_individu
LEFT JOIN banques ON banques.IDbanque = familles.prelevement_banque
GROUP BY familles.IDfamille
;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeListeView = []
for item in listeDonnees:
valide = True
if listeID != None:
if item[0] not in listeID:
valide = False
if valide == True:
track = Track(item, dictTitulaires)
listeListeView.append(track)
if self.selectionID == item[0]:
self.selectionTrack = track
return listeListeView
def __init__(self, *args, **kwds):
# Récupération des paramètres perso
self.inclus = kwds.pop("inclus", True)
self.selectionPossible = kwds.pop("selectionPossible", True)
self.selectionID = None
self.selectionTrack = None
self.criteres = ""
self.itemSelected = False
self.popupIndex = -1
self.listeFiltres = []
self.tracks = []
self.numColonneTri = 1
self.ordreAscendant = True
self.tailleImagesMaxi = (132 / 4.0, 72 / 4.0) #(132/2.0, 72/2.0)
self.tailleImagesMini = (16, 16)
self.afficheImages = True
self.imageDefaut = Chemins.GetStaticPath(
"Images/Special/Image_non_disponible.png")
# Importation des titulaires
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# Initialisation du listCtrl
self.nom_fichier_liste = __file__
FastObjectListView.__init__(self, *args, **kwds)
# Binds perso
self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnItemActivated)
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
def OnDoubleClick(self, event):
item = self.GetSelection()
dictItem = self.GetMainWindow().GetItemPyData(item)
if dictItem == None :
dlg = wx.MessageDialog(self, _(u"Double-cliquez sur le nom de l'individu pour accéder à sa fiche famille !"), _(u"Astuce"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
listeFamilles = dictItem["listeFamilles"]
if len(listeFamilles) == 1 :
# Si individu rattaché à une seule famille
self.OuvrirFicheFamille(listeFamilles[0])
else:
# Si individu rattaché à plusieurs familles
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeFamilles)
listeNoms = []
for IDfamille in listeFamilles :
nomsTitulaires = dictTitulaires[IDfamille]["titulairesSansCivilite"]
listeNoms.append(nomsTitulaires)
dlg = wx.SingleChoiceDialog(self, _(u"Cet individu est rattaché à %d familles.\nLa fiche de quelle famille souhaitez-vous ouvrir ?") % len(listeFamilles), _(u"Rattachements multiples"), listeNoms, wx.CHOICEDLG_STYLE)
IDfamilleSelection = None
if dlg.ShowModal() == wx.ID_OK:
indexSelection = dlg.GetSelection()
IDfamille = listeFamilles[indexSelection]
dlg.Destroy()
else:
dlg.Destroy()
return
self.OuvrirFicheFamille(IDfamille)
def __init__(self, parent):
HTL.HyperTreeList.__init__(self, parent, -1)
self.parent = parent
self.listeImpression = []
# Récupère les noms et adresses de tous les titulaires
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# Adapte taille Police pour Linux
from Utils import UTILS_Linux
UTILS_Linux.AdaptePolice(self)
# Création des colonnes
listeColonnes = [
(_(u"Famille/Individu/Prestations"), 250, wx.ALIGN_LEFT),
(_(u"Détail"), 250, wx.ALIGN_LEFT),
(_(u"Montant"), 70, wx.ALIGN_RIGHT),
(_(u"Qté"), 60, wx.ALIGN_CENTER),
]
numColonne = 0
for label, largeur, alignement in listeColonnes:
self.AddColumn(label)
self.SetColumnWidth(numColonne, largeur)
self.SetColumnAlignment(numColonne, alignement)
numColonne += 1
self.SetBackgroundColour(wx.WHITE)
self.SetAGWWindowStyleFlag(
wx.TR_HIDE_ROOT | wx.TR_COLUMN_LINES
| wx.TR_HAS_VARIABLE_ROW_HEIGHT
| wx.TR_FULL_ROW_HIGHLIGHT) # HTL.TR_NO_HEADER
self.EnableSelectionVista(True)
# Binds
self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnContextMenu)
def __init__(self, parent, listeFamilles=[]):
wx.Choice.__init__(self, parent, -1)
self.parent = parent
self.listeFamilles = listeFamilles
self.dictTitulaires = UTILS_Titulaires.GetTitulaires(
self.listeFamilles)
self.MAJ()
def MAJ_CTRL_Donnees(self):
""" Importe les valeurs de base dans le GRID Données """
DB = GestionDB.DB()
# Récupération des infos sur l'attestation
dateDuJour = str(datetime.date.today())
self.SetValeur("date", DateEngFr(dateDuJour))
req = """SELECT MAX(numero)
FROM recus
;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
if len(listeDonnees) > 0 :
numero = listeDonnees[0][0]
if numero == None :
numero = 1
else:
numero += 1
else:
numero = 0
self.SetValeur("numero", u"%06d" % numero)
# Récupération des infos sur l'organisme
req = """SELECT nom, num_siret, code_ape, ville
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
for nom, num_siret, code_ape, ville in listeDonnees :
if num_siret != None :
self.SetValeur("siret", num_siret)
else :
self.SetValeur("siret", "")
if code_ape != None :
self.SetValeur("ape", code_ape)
else :
self.SetValeur("ape", "")
if ville != None :
self.SetValeur("lieu", ville.capitalize() )
else :
self.SetValeur("lieu", "")
# Récupération des données sur le destinataire
dictNomsTitulaires = UTILS_Titulaires.GetTitulaires([self.parent.IDfamille,])
dictInfosTitulaires = dictNomsTitulaires[self.parent.IDfamille]
nomsTitulairesAvecCivilite = dictInfosTitulaires["titulairesAvecCivilite"]
rue_resid = dictInfosTitulaires["adresse"]["rue"]
cp_resid = dictInfosTitulaires["adresse"]["cp"]
ville_resid = dictInfosTitulaires["adresse"]["ville"]
if rue_resid == None : rue_resid = u""
if cp_resid == None : cp_resid = u""
if ville_resid == None : ville_resid = u""
self.SetValeur("nom", nomsTitulairesAvecCivilite)
self.SetValeur("rue", rue_resid)
self.SetValeur("ville", cp_resid + " " + ville_resid)
def __init__(self, *args, **kwds):
self.listePrestations = []
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# Initialisation du listCtrl
FastObjectListView.__init__(self, *args, **kwds)
# Binds perso
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
def __init__(self, *args, **kwds):
# Initialisation du listCtrl
self.IDactivite = 0
self.categories_tarifs = []
FastObjectListView.__init__(self, *args, **kwds)
# DictTitulaires
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# Binds perso
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
def Initialisation(self):
self.dictBranches = {}
# Création des colonnes
self.AddColumn(_(u"Individu/Forfait"))
self.SetMainColumn(0)
self.SetColumnWidth(0, 230)
self.AddColumn(_(u"Activité"))
self.SetColumnWidth(1, 60)
self.AddColumn(_(u"Tarif"))
self.SetColumnWidth(2, 60)
self.SetColumnAlignment(2, wx.ALIGN_RIGHT)
# Création de la racine
self.root = self.AddRoot(_(u"Racine"))
if self.IDfamille == None or self.date == None:
return
# Recherche des données
self.dictDonnees = self.grille.GetTarifsForfaitsCreditDisponibles(self.date)
# Recherche du nom des titulaires
dictTitulaires = UTILS_Titulaires.GetTitulaires([self.IDfamille,])
# Création des branches
for IDfamille, dictFamille in self.dictDonnees.iteritems() :
if IDfamille == self.IDfamille :
# Forfait familial
listeTemp = []
for dictTarif in dictFamille["forfaits"] :
listeTemp.append((dictTarif["resultat"]["nomActivite"], dictTarif["resultat"]["nom_tarif"], dictTarif))
listeTemp.sort()
for nomActivite, label, dictTarif in listeTemp :
item = self.CreationBrancheTarif(self.root, dictTarif)
self.dictBranches[(None, dictTarif["IDtarif"])] = item
# Forfaits individuels
for IDindividu, dictIndividu in dictFamille["individus"].iteritems() :
if len(dictIndividu["forfaits"]) > 0 :
label = u"%s %s" % (dictIndividu["nom"], dictIndividu["prenom"])
brancheIndividu = self.AppendItem(self.root, label)
self.SetPyData(brancheIndividu, {"type":"individu", "donnees":IDindividu})
self.SetItemBold(brancheIndividu, True)
listeTemp = []
for dictTarif in dictIndividu["forfaits"] :
listeTemp.append((dictTarif["resultat"]["nomActivite"], dictTarif["resultat"]["nom_tarif"], dictTarif))
listeTemp.sort()
for nomActivite, label, dictTarif in listeTemp :
item = self.CreationBrancheTarif(brancheIndividu, dictTarif)
self.dictBranches[(IDindividu, dictTarif["IDtarif"])] = item
self.ExpandAllChildren(self.root)
def GetNomsTitulaires(IDfamille=None):
dictTitulaires = UTILS_Titulaires.GetTitulaires(listeIDfamille=[
IDfamille,
])
if IDfamille in dictTitulaires:
noms = dictTitulaires[IDfamille]["titulairesSansCivilite"]
else:
noms = "?"
return noms
def GetTracks(IDlot=None):
""" Récupération des données """
dictTitulaires = UTILS_Titulaires.GetTitulaires()
if IDlot == None:
return []
DB = GestionDB.DB()
req = """SELECT
prelevements.IDprelevement, prelevements.IDfamille,
prelevements.prelevement_etab, prelevements.prelevement_guichet, prelevements.prelevement_numero,
prelevements.prelevement_banque, prelevements.prelevement_cle,
prelevements.prelevement_iban, prelevements.prelevement_bic,
prelevements.prelevement_reference_mandat, prelevements.prelevement_date_mandat,
prelevements.titulaire, prelevements.type, prelevements.IDfacture, prelevements.libelle,
prelevements.montant, prelevements.statut, prelevements.IDlot,
banques.nom,
reglements.IDreglement, reglements.date, reglements.IDdepot,
comptes_payeurs.IDcompte_payeur
FROM prelevements
LEFT JOIN banques ON banques.IDbanque = prelevements.prelevement_banque
LEFT JOIN reglements ON reglements.IDprelevement = prelevements.IDprelevement
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = prelevements.IDfamille
WHERE IDlot=%d
;""" % IDlot
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeListeView = []
for IDprelevement, IDfamille, prelevement_etab, prelevement_guichet, prelevement_numero, prelevement_banque, prelevement_cle, prelevement_iban, prelevement_bic, prelevement_reference_mandat, prelevement_date_mandat, titulaire, type_prelevement, IDfacture, libelle, montant, statut, IDlot, nomBanque, IDreglement, dateReglement, IDdepot, IDcompte_payeur in listeDonnees:
dictTemp = {
"IDprelevement": IDprelevement,
"IDfamille": IDfamille,
"prelevement_etab": prelevement_etab,
"prelevement_guichet": prelevement_guichet,
"prelevement_numero": prelevement_numero,
"prelevement_banque": prelevement_banque,
"prelevement_cle": prelevement_cle,
"prelevement_iban": prelevement_iban,
"prelevement_bic": prelevement_bic,
"prelevement_reference_mandat": prelevement_reference_mandat,
"prelevement_date_mandat": prelevement_date_mandat,
"titulaire": titulaire,
"type": type_prelevement,
"IDfacture": IDfacture,
"libelle": libelle,
"montant": montant,
"statut": statut,
"IDlot": IDlot,
"nomBanque": nomBanque,
"etat": None,
"IDreglement": IDreglement,
"dateReglement": dateReglement,
"IDdepot": IDdepot,
"IDcompte_payeur": IDcompte_payeur,
}
track = Track(dictTemp, dictTitulaires)
listeListeView.append(track)
return listeListeView
def GetTracks(self):
""" Récupération des données """
dictTitulaires = UTILS_Titulaires.GetTitulaires()
DB = GestionDB.DB()
# Récupération des inscriptions existantes
req = """SELECT IDinscription, IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti
FROM inscriptions
WHERE inscriptions.statut='ok';"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictInscriptions = {}
for IDinscription, IDindividu, IDfamille, IDactivite, IDgroupe, IDcategorie_tarif, IDcompte_payeur, date_inscription, parti in listeDonnees:
self.dictInscriptions[(IDindividu, IDfamille, IDactivite)] = {
"IDinscription": IDinscription,
"IDgroupe": IDgroupe,
"IDcategorie_tarif": IDcategorie_tarif
}
# Récupération des individus
req = """SELECT individus.IDindividu, nom, prenom, date_naiss, rattachements.IDfamille, comptes_payeurs.IDcompte_payeur
FROM individus
LEFT JOIN rattachements ON rattachements.IDindividu = individus.IDindividu
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = rattachements.IDfamille
WHERE IDcategorie IN (1, 2) AND rattachements.IDfamille IS NOT NULL
GROUP BY individus.IDindividu, rattachements.IDfamille, comptes_payeurs.IDcompte_payeur;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeListeView = []
for IDindividu, nom, prenom, date_naiss, IDfamille, IDcompte_payeur in listeDonnees:
date_naiss = UTILS_Dates.DateEngEnDateDD(date_naiss)
age = UTILS_Dates.CalculeAge(date_naiss=date_naiss)
nomTitulaires = dictTitulaires[IDfamille]["titulairesSansCivilite"]
rue = dictTitulaires[IDfamille]["adresse"]["rue"]
cp = dictTitulaires[IDfamille]["adresse"]["cp"]
ville = dictTitulaires[IDfamille]["adresse"]["ville"]
nomSecteur = dictTitulaires[IDfamille]["adresse"]["nomSecteur"]
dictTemp = {
"IDindividu": IDindividu,
"nom": nom,
"prenom": prenom,
"date_naiss": date_naiss,
"age": age,
"nomTitulaires": nomTitulaires,
"IDfamille": IDfamille,
"IDcompte_payeur": IDcompte_payeur,
"rue": rue,
"cp": cp,
"ville": ville,
"nomSecteur": nomSecteur,
}
listeListeView.append(Track(dictTemp))
return listeListeView
def GetTracks(self):
""" Récupération des données """
listeID = None
# Importation des titulaires
if self.afficher_locations == True :
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# Initialisation des questionnaires
categorie = "produit"
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(type=categorie)
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(type=categorie)
DB = GestionDB.DB()
# Importation des locations en cours
self.dictLocations = UTILS_Locations.GetProduitsLoues(DB=DB)
# Importation des produits
if self.filtreListeID == None :
condition = ""
else :
if len(self.filtreListeID) == 0: condition = "WHERE produits.IDproduit IN ()"
elif len(self.filtreListeID) == 1: condition = "WHERE produits.IDproduit IN (%d)" % self.filtreListeID[0]
else: condition = "WHERE produits.IDproduit IN %s" % str(tuple(self.filtreListeID))
req = """SELECT IDproduit, produits.nom, produits.observations, produits_categories.nom, quantite
FROM produits
LEFT JOIN produits_categories ON produits_categories.IDcategorie = produits.IDcategorie
%s;""" % condition
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeListeView = []
for item in listeDonnees :
track = Track(parent=self, donnees=item)
valide = True
if listeID != None :
if item[0] not in listeID :
valide = False
# Mémorisation position
if self.dictPositions != None and track.IDproduit in self.dictPositions:
track.position = self.dictPositions[track.IDproduit]
# Coche afficher uniquement les disponibles
if self.coche_uniquement_disponibles == True and track.disponible == 0 :
valide = False
if valide == True :
listeListeView.append(track)
if self.selectionID == item[0] :
self.selectionTrack = track
return listeListeView
def __init__(self, *args, **kwds):
# Initialisation du listCtrl
self.dictParametres = {}
self.dictComptes = {}
FastObjectListView.__init__(self, *args, **kwds)
# DictTitulaires
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# Binds perso
self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnActivated)
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
def __init__(self, *args, **kwds):
# Initialisation du listCtrl
self.IDactivite = 0
self.date_debut = None
self.date_fin = None
self.nom_fichier_liste = __file__
FastObjectListView.__init__(self, *args, **kwds)
# DictTitulaires
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# Binds perso
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
def __init__(self, *args, **kwds):
# Initialisation du listCtrl
self.date_debut = None
self.date_fin = None
self.selectionID = None
self.selectionTrack = None
FastObjectListView.__init__(self, *args, **kwds)
# DictTitulaires
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# Binds perso
self.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.OnActivated)
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
def GetListeFamilles(listview=None,
listeActivites=None,
presents=None,
IDfamille=None,
infosIndividus=None):
""" Récupération des infos familles """
listeListeView = []
titulaires = UTILS_Titulaires.GetTitulaires(inclure_telephones=True)
for IDfamille, dictTemp in titulaires.iteritems():
nomTitulaires = dictTemp["titulairesSansCivilite"]
for dictTitulaire in dictTemp["listeTitulaires"]:
dictTemp = {
"IDfamille": IDfamille,
"nomTitulaires": nomTitulaires,
"IDindividu": dictTitulaire["IDindividu"],
"nom": dictTitulaire["nom"],
"prenom": dictTitulaire["prenom"]
}
dictTelephones = dictTitulaire["telephones"]
if dictTelephones["travail_tel"] != None:
dictTemp2 = copy.deepcopy(dictTemp)
dictTemp2["tel"] = dictTelephones["travail_tel"]
dictTemp2["sms"] = bool(dictTelephones["travail_tel_sms"])
dictTemp2["categorie"] = _(u"Professionnel")
if listview.afficher_uniquement_sms == False or (
listview.afficher_uniquement_sms == True
and dictTemp2["sms"] == True):
listeListeView.append(TrackFamille(dictTemp2))
if dictTelephones["tel_domicile"] != None:
dictTemp2 = copy.deepcopy(dictTemp)
dictTemp2["tel"] = dictTelephones["tel_domicile"]
dictTemp2["sms"] = bool(dictTelephones["tel_domicile_sms"])
dictTemp2["categorie"] = _(u"Domicile")
if listview.afficher_uniquement_sms == False or (
listview.afficher_uniquement_sms == True
and dictTemp2["sms"] == True):
listeListeView.append(TrackFamille(dictTemp2))
if dictTelephones["tel_mobile"] != None:
dictTemp2 = copy.deepcopy(dictTemp)
dictTemp2["tel"] = dictTelephones["tel_mobile"]
dictTemp2["sms"] = bool(dictTelephones["tel_mobile_sms"])
dictTemp2["categorie"] = _(u"Mobile")
if listview.afficher_uniquement_sms == False or (
listview.afficher_uniquement_sms == True
and dictTemp2["sms"] == True):
listeListeView.append(TrackFamille(dictTemp2))
return listeListeView
def GetListeFamilles(listview=None, infosIndividus=None):
""" Récupération des infos familles """
# Récupération des régimes et num d'alloc pour chaque famille
DB = GestionDB.DB()
req = """
SELECT
familles.IDfamille, regimes.nom, caisses.nom, num_allocataire, comptes_payeurs.IDcompte_payeur
FROM familles
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = familles.IDfamille
LEFT JOIN caisses ON caisses.IDcaisse = familles.IDcaisse
LEFT JOIN regimes ON regimes.IDregime = caisses.IDregime
;"""
DB.ExecuterReq(req)
listeFamilles = DB.ResultatReq()
DB.Close()
# Formatage des données
listeListeView = []
titulaires = UTILS_Titulaires.GetTitulaires()
for IDfamille, nomRegime, nomCaisse, numAlloc, IDcompte_payeur in listeFamilles:
dictTemp = {}
if IDfamille != None and titulaires.has_key(IDfamille):
nomTitulaires = titulaires[IDfamille]["titulairesSansCivilite"]
rue = titulaires[IDfamille]["adresse"]["rue"]
cp = titulaires[IDfamille]["adresse"]["cp"]
ville = titulaires[IDfamille]["adresse"]["ville"]
listeMails = titulaires[IDfamille]["listeMails"]
else:
nomTitulaires = _(u"Aucun titulaire")
rue = u""
cp = u""
ville = u""
listeMails = []
dictTemp = {
"IDfamille": IDfamille,
"titulaires": nomTitulaires,
"nomRegime": nomRegime,
"nomCaisse": nomCaisse,
"numAlloc": numAlloc,
"rue": rue,
"cp": cp,
"ville": ville,
"listeMails": listeMails,
"IDcompte_payeur": IDcompte_payeur,
}
# Formatage sous forme de TRACK
track = TrackFamille(listview, dictTemp, infosIndividus)
listeListeView.append(track)
return listeListeView
def __init__(self, *args, **kwds):
self.criteres = ""
self.listeFiltres = []
self.numColonneTri = 1
self.ordreAscendant = True
# Importation des titulaires
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# Initialisation du listCtrl
self.nom_fichier_liste = __file__
FastObjectListView.__init__(self, *args, **kwds)
# Binds perso
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
def __init__(self):
""" Récupération de toutes les données de base """
DB = GestionDB.DB()
# Récupération des infos sur l'organisme
req = """SELECT nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape
FROM organisateur
WHERE IDorganisateur=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictOrganisme = {}
for nom, rue, cp, ville, tel, fax, mail, site, num_agrement, num_siret, code_ape in listeDonnees:
self.dictOrganisme["nom"] = nom
self.dictOrganisme["rue"] = rue
self.dictOrganisme["cp"] = cp
if ville != None: ville = ville.capitalize()
self.dictOrganisme["ville"] = ville
self.dictOrganisme["tel"] = tel
self.dictOrganisme["fax"] = fax
self.dictOrganisme["mail"] = mail
self.dictOrganisme["site"] = site
self.dictOrganisme["num_agrement"] = num_agrement
self.dictOrganisme["num_siret"] = num_siret
self.dictOrganisme["code_ape"] = code_ape
# Récupération des textes de rappels
req = """SELECT IDtexte, titre, texte_pdf
FROM textes_rappels;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.dictTextesRappels = {}
for IDtexte, titre, texte_pdf in listeDonnees:
self.dictTextesRappels[IDtexte] = {
"titre": titre,
"texte_pdf": texte_pdf
}
DB.Close()
# Get noms Titulaires
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# Récupération des questionnaires
self.Questionnaires = UTILS_Questionnaires.ChampsEtReponses(
type="famille")
# Récupération des infos de base familles
self.infosIndividus = UTILS_Infos_individus.Informations()
def MAJ(self):
dictTitulaires = UTILS_Titulaires.GetTitulaires([self.dictParametres["IDfamille"],])
dictInfos = dictTitulaires[self.dictParametres["IDfamille"]]
try :
nom = dictInfos["listeTitulaires"][0]["nom"]
prenom = dictInfos["listeTitulaires"][0]["prenom"]
rue = dictInfos["adresse"]["rue"]
self.ctrl_nom.SetValue(nom)
self.ctrl_prenom.SetValue(prenom)
self.ctrl_adresse.SetValue(rue)
except :
pass
def MAJ(self, ID=None):
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
if ID != None :
self.selectionID = ID
self.selectionTrack = None
else:
self.selectionID = None
self.selectionTrack = None
self.InitModel()
self.InitObjectListView()
# Sélection d'un item
if self.selectionTrack != None :
self.SelectObject(self.selectionTrack, deselectOthers=True, ensureVisible=True)
self.selectionID = None
self.selectionTrack = None
def InitModel(self):
# Initialisation des questionnaires
categorie = "location_demande"
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(type=categorie)
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(type=categorie)
# Importation des titulaires de dossier
if self.IDfamille == None:
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# Importation des propositions de locations
self.dictPropositions = UTILS_Locations.GetPropositionsLocations()
# MAJ du listview
self.donnees = self.GetTracks()