def __init__(self, *args, **kwds):
# Initialisation du listCtrl
self.IDactivite = 0
self.action = None
self.categories_tarifs = []
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 SetIDfamille(self, IDfamille=None):
self.IDfamille = IDfamille
# Recherche du nom des titulaires
dictNomsTitulaires = UTILS_Titulaires.GetTitulaires([
self.IDfamille,
])
nomsTitulaires = dictNomsTitulaires[
self.IDfamille]["titulairesSansCivilite"]
self.IDcompte_payeur = dictNomsTitulaires[
self.IDfamille]["IDcompte_payeur"]
self.SetValue(nomsTitulaires)
def __init__(self, *args, **kwds):
# Initialisation du listCtrl
self.dictParametres = {}
self.dictComptes = {}
self.donnees = []
self.nom_fichier_liste = __file__
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 SetIDfamille(self, IDfamille=None):
self.IDfamille = IDfamille
# Recherche du nom des titulaires
if self.IDfamille != None:
dictNomsTitulaires = UTILS_Titulaires.GetTitulaires([
self.IDfamille,
])
nomsTitulaires = dictNomsTitulaires[
self.IDfamille]["titulairesSansCivilite"]
self.SetValue(nomsTitulaires)
else:
self.SetValue("")
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 MAJ(self):
if self.IDindividu != None :
dictFamillesRattachees = UTILS_Titulaires.GetFamillesRattachees(self.IDindividu)
self.listeNoms = []
self.listeDonnees = []
for IDfamille, dictFamille in dictFamillesRattachees.iteritems() :
nom = _(u"Famille de %s") % dictFamille["nomsTitulaires"]
self.listeNoms.append(nom)
self.listeDonnees.append({"IDfamille" : IDfamille, "nom" : nom})
self.SetItems(self.listeNoms)
if len(self.listeDonnees) < 2 or self.verrouillage == True :
self.Enable(False)
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 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 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 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 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()
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 __init__(self, *args, **kwds):
# Récupération des paramètres perso
self.selectionID = None
self.selectionTrack = None
self.criteres = ""
self.itemSelected = False
self.popupIndex = -1
self.listeFiltres = []
# 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 GetTracks(self):
""" Récupération des données """
self.InitBanques()
dictTitulaires = UTILS_Titulaires.GetTitulaires()
criteres = ""
if self.IDfamille != None :
criteres = "WHERE prelevements.IDfamille=%d" % self.IDfamille
if self.IDmandat != None :
criteres = "WHERE prelevements.IDmandat=%d" % self.IDmandat
DB = GestionDB.DB()
req = """SELECT
prelevements.IDprelevement, prelevements.IDlot, prelevements.IDfamille,
prelevement_banque, prelevement_iban, prelevement_bic,
prelevements.IDmandat, prelevement_reference_mandat, prelevement_date_mandat,
prelevements.sequence,
titulaire, prelevements.type, IDfacture, libelle, prelevements.montant, statut,
banques.nom,
reglements.IDreglement, reglements.date, reglements.IDdepot,
comptes_payeurs.IDcompte_payeur,
lots_prelevements.date, lots_prelevements.nom
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
LEFT JOIN lots_prelevements ON lots_prelevements.IDlot = prelevements.IDlot
%s
;""" % criteres
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeListeView = []
for IDprelevement, IDlot, IDfamille, prelevement_banque, prelevement_iban, prelevement_bic, IDmandat, prelevement_reference_mandat, prelevement_date_mandat, sequence, titulaire, type_prelevement, IDfacture, libelle, montant, statut, nomBanque, IDreglement, dateReglement, IDdepot, IDcompte_payeur, dateLot, nomLot in listeDonnees :
prelevement_date_mandat = UTILS_Dates.DateEngEnDateDD(prelevement_date_mandat)
dateLot = UTILS_Dates.DateEngEnDateDD(dateLot)
dictTemp = {
"IDprelevement" : IDprelevement, "IDlot" : IDlot, "IDfamille" : IDfamille,
"prelevement_banque" : prelevement_banque, "prelevement_iban" : prelevement_iban, "prelevement_bic" : prelevement_bic,
"IDmandat" : IDmandat, "prelevement_reference_mandat" : prelevement_reference_mandat, "prelevement_date_mandat" : prelevement_date_mandat,
"sequence" : sequence, "titulaire" : titulaire, "type" : type_prelevement, "IDfacture" : IDfacture,
"libelle" : libelle, "montant" : montant, "statut" : statut, "IDlot" : IDlot, "IDmandat" : IDmandat, "nomBanque" : nomBanque,
"IDreglement" : IDreglement, "dateReglement" : dateReglement, "IDdepot" : IDdepot, "IDcompte_payeur" : IDcompte_payeur,
"dateLot" : dateLot, "nomLot" : nomLot,
}
track = Track(dictTemp, dictTitulaires)
listeListeView.append(track)
return listeListeView
def __init__(self, parent):
HTL.HyperTreeList.__init__(self, parent, -1)
self.parent = parent
self.dictImpression = {}
# Paramètres
self.mode_regroupement = "activites" # "activite", "famille"
self.mode_periode = "mois" # "mois", "annee"
self.date_debut = None
self.date_fin = None
self.afficher_consommations = True
self.afficher_cotisations = True
self.afficher_locations = True
self.afficher_autres = True
self.listeActivites = []
self.affichage_details = True
self.filtreCotisations = False
self.filtreCotisations_dateDebut = None
self.filtreCotisations_dateFin = None
self.filtreReglements = False
self.filtreReglements_dateDebut = None
self.filtreReglements_dateFin = None
self.filtreDepots = False
self.filtreDepots_dateDebut = None
self.filtreDepots_dateFin = None
self.labelParametres = ""
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
# wx.TR_COLUMN_LINES | | wx.TR_HAS_BUTTONS
self.SetBackgroundColour(wx.WHITE)
if 'phoenix' in wx.PlatformInfo:
TR_COLUMN_LINES = HTL.TR_COLUMN_LINES
else:
TR_COLUMN_LINES = wx.TR_COLUMN_LINES
self.SetAGWWindowStyleFlag(
wx.TR_HIDE_ROOT | wx.TR_ROW_LINES | TR_COLUMN_LINES
| wx.TR_HAS_BUTTONS | 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 Saisie_manuelle(self, event=None):
""" Saisie manuelle """
dictTitulaires = UTILS_Titulaires.GetTitulaires()
dictTemp = {
"IDprelevement" : None, "IDfamille" : None, "prelevement_etab" : "", "prelevement_guichet" : "", "prelevement_numero" : "",
"prelevement_banque" : "", "prelevement_cle" : "", "prelevement_iban" : "", "prelevement_bic" : "",
"prelevement_reference_mandat" : "", "prelevement_date_mandat" : None,
"titulaire" : "", "type" : "manuel", "IDfacture" : None,
"libelle" : "", "montant" : 0.00, "statut" : "attente", "IDlot" : self.IDlot, "nomBanque" : "", "etat" : "ajout",
"IDreglement" : None, "dateReglement" : None, "IDdepot" : None, "IDcompte_payeur" : None,
}
track = Track(dictTemp, dictTitulaires)
dlg = DLG_Saisie_prelevement.Dialog(self, track=track)
if dlg.ShowModal() == wx.ID_OK:
track = dlg.GetTrack()
self.AddObject(track)
self.MAJtotaux()
dlg.Destroy()
def MAJ(self):
import GestionDB
from Utils import UTILS_Questionnaires
from Utils import UTILS_Locations
from Utils import UTILS_Titulaires
# Importation des titulaires
self.dict_titulaires = UTILS_Titulaires.GetTitulaires()
# Initialisation des questionnaires
self.UtilsQuestionnaires = UTILS_Questionnaires.Questionnaires()
self.liste_questions = self.UtilsQuestionnaires.GetQuestions(
type="produit")
self.dict_questionnaires = self.UtilsQuestionnaires.GetReponses(
type="produit")
DB = GestionDB.DB()
# Importation des locations en cours
self.dictLocations = UTILS_Locations.GetProduitsLoues(DB=DB)
# Importation des caractéristiques du modèle
req = """SELECT categorie, IDdonnee
FROM documents_modeles
WHERE IDmodele=%d;""" % self.IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
self.categorie, self.IDdonnee = listeDonnees[0]
# Importation des produits
req = """SELECT IDproduit, produits.nom, produits.observations, produits_categories.nom, produits.quantite
FROM produits
LEFT JOIN produits_categories ON produits_categories.IDcategorie = produits.IDcategorie
WHERE produits.IDcategorie=%d;""" % self.IDdonnee
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
self.dictTracks = {}
for item in listeDonnees:
track = Track(parent=self, donnees=item)
self.dictTracks[track.IDproduit] = track
return self.dictTracks
def AjoutFactures(self, tracks=[]):
# Vérifie que cette facture n'est pas déjà présente dans le lot
listeFacturesPresentes = []
for track in self.GetObjects():
if track.IDfacture != None:
listeFacturesPresentes.append(track.IDfacture)
# MAJ de la liste affichée
dictTitulaires = UTILS_Titulaires.GetTitulaires()
listeNewTracks = []
for track in tracks:
dictTemp = {
"IDprelevement": None,
"IDfamille": track.IDfamille,
"prelevement_etab": track.prelevement_etab,
"prelevement_guichet": track.prelevement_guichet,
"prelevement_numero": track.prelevement_numero,
"prelevement_banque": track.prelevement_banque,
"prelevement_cle": track.prelevement_cle,
"prelevement_iban": track.prelevement_iban,
"prelevement_bic": track.prelevement_bic,
"prelevement_reference_mandat":
track.prelevement_reference_mandat,
"prelevement_date_mandat": track.prelevement_date_mandat,
"titulaire": track.prelevement_payeur,
"type": "facture",
"IDfacture": track.IDfacture,
"libelle": _(u"FACT%06d") % track.numero,
"montant": -track.solde,
"statut": "attente",
"IDlot": self.IDlot,
"nomBanque": "",
"etat": "ajout",
"IDreglement": None,
"dateReglement": None,
"IDdepot": None,
"IDcompte_payeur": track.IDcompte_payeur,
}
if track.IDfacture not in listeFacturesPresentes:
listeNewTracks.append(Track(dictTemp, dictTitulaires))
self.AddObjects(listeNewTracks)
self.MAJtotaux()
def GetTracks(self):
""" Récupération des données """
dictTitulaires = UTILS_Titulaires.GetTitulaires()
criteres = ""
if self.IDfamille != None :
criteres = "WHERE pes_pieces.IDfamille=%d" % self.IDfamille
if self.IDmandat != None :
criteres = "WHERE pes_pieces.prelevement_IDmandat=%d" % self.IDmandat
DB = GestionDB.DB()
req = """SELECT
pes_pieces.IDpiece, pes_pieces.IDlot, pes_pieces.IDfamille,
prelevement, prelevement_iban, prelevement_bic,
prelevement_IDmandat, prelevement_rum, prelevement_date_mandat,
prelevement_sequence, prelevement_titulaire, prelevement_statut,
type, IDfacture, libelle, pes_pieces.montant,
reglements.IDreglement, reglements.date, reglements.IDdepot,
comptes_payeurs.IDcompte_payeur,
pes_pieces.titulaire_helios,
pes_lots.nom, pes_lots.date_prelevement
FROM pes_pieces
LEFT JOIN reglements ON reglements.IDpiece = pes_pieces.IDpiece
LEFT JOIN comptes_payeurs ON comptes_payeurs.IDfamille = pes_pieces.IDfamille
LEFT JOIN pes_lots ON pes_lots.IDlot = pes_pieces.IDlot
%s
;""" % criteres
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
DB.Close()
listeListeView = []
for IDpiece, IDlot, IDfamille, prelevement, prelevement_iban, prelevement_bic, prelevement_IDmandat, prelevement_rum, prelevement_date_mandat, prelevement_sequence, prelevement_titulaire, prelevement_statut, type_piece, IDfacture, libelle, montant, IDreglement, dateReglement, IDdepot, IDcompte_payeur, titulaire_helios, nomLot, datePrelevement in listeDonnees :
dictTemp = {
"IDpiece" : IDpiece, "IDlot" : IDlot, "IDfamille" : IDfamille,
"prelevement" : prelevement, "prelevement_iban" : prelevement_iban, "prelevement_bic" : prelevement_bic,
"prelevement_IDmandat" : prelevement_IDmandat, "prelevement_rum" : prelevement_rum, "prelevement_date_mandat" : prelevement_date_mandat,
"prelevement_sequence" : prelevement_sequence, "prelevement_titulaire" : prelevement_titulaire, "prelevement_statut" : prelevement_statut,
"IDfacture" : IDfacture, "libelle" : libelle, "montant" : montant, "statut" : prelevement_statut, "IDlot" : IDlot, "etat" : None, "type" : type_piece,
"IDreglement" : IDreglement, "dateReglement" : dateReglement, "IDdepot" : IDdepot, "IDcompte_payeur" : IDcompte_payeur,
"titulaire_helios" : titulaire_helios, "nomLot" : nomLot, "datePrelevement" : datePrelevement,
}
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;"""
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 Envoyer_email(self, event):
# Envoyer un email à la famille
from Utils import UTILS_Envoi_email
listeAdresses = UTILS_Envoi_email.GetAdresseFamille(self.IDfamille)
if listeAdresses == False or len(listeAdresses) == 0:
dlg = wx.MessageDialog(self, _(u"Il n'y a aucune adresse email !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return False
from Utils import UTILS_Titulaires
listefamilles = []
listefamilles.append(self.IDfamille)
titulaires = UTILS_Titulaires.GetTitulaires(listefamilles)
nom_famille = None
for id in titulaires:
if "titulairesAvecCivilite" in titulaires[id]:
nom_famille = titulaires[id]["titulairesAvecCivilite"]
break
if nom_famille == None:
raise
from Dlg import DLG_Mailer
dlg = DLG_Mailer.Dialog(self, categorie="portail")
listeDonnees = []
champs = {
"{IDENTIFIANT_INTERNET}":
self.ctrl_compte_internet.GetIdentifiant(),
"{MOTDEPASSE_INTERNET}": self.ctrl_compte_internet.GetMdp(),
"{NOM_FAMILLE}": nom_famille,
}
for adresse in listeAdresses:
listeDonnees.append({
"adresse": adresse,
"pieces": [],
"champs": champs
})
dlg.SetDonnees(listeDonnees, modificationAutorisee=False)
dlg.ChargerModeleDefaut()
dlg.ShowModal()
dlg.Destroy()
def __init__(self, *args, **kwds):
# Récupération des paramètres perso
self.selectionID = None
self.selectionTrack = None
self.criteres = ""
self.itemSelected = False
self.popupIndex = -1
self.dictTitulaires = UTILS_Titulaires.GetTitulaires()
self.date_debut = None
self.date_fin = None
self.listeActivites = "toutes"
self.filtres = []
self.labelParametres = ""
# 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 GetTracks(self):
""" Récupération des données """
if self.IDtype_piece == None:
return []
if self.date_reference != None:
conditionDate = "AND pieces.date_debut <= '%s' AND pieces.date_fin >= '%s'" % (
self.date_reference, self.date_reference)
else:
conditionDate = ""
listeID = None
db = GestionDB.DB()
req = """SELECT pieces.IDpiece, pieces.date_debut, pieces.date_fin,
types_pieces.public, types_pieces.nom,
individus.IDindividu, pieces.IDfamille, individus.nom, individus.prenom
FROM pieces
LEFT JOIN types_pieces ON types_pieces.IDtype_piece = pieces.IDtype_piece
LEFT JOIN individus ON individus.IDindividu = pieces.IDindividu
WHERE pieces.IDtype_piece = %d %s
ORDER BY individus.nom; """ % (self.IDtype_piece, conditionDate)
db.ExecuterReq(req)
listeDonnees = db.ResultatReq()
db.Close()
dictTitulaires = UTILS_Titulaires.GetTitulaires()
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, 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(
inclure_archives=True)
# 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)
if 'phoenix' in wx.PlatformInfo:
TR_COLUMN_LINES = HTL.TR_COLUMN_LINES
else:
TR_COLUMN_LINES = wx.TR_COLUMN_LINES
self.SetAGWWindowStyleFlag(
wx.TR_HIDE_ROOT | 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 GetTracks(self):
""" Récupération des données """
dictTitulaires = UTILS_Titulaires.GetTitulaires()
DB = GestionDB.DB()
# Lecture Actions
conditions = ""
if self.cacher_traitees == True:
conditions = "WHERE etat <> 'validation'"
req = """SELECT IDaction, horodatage, IDfamille, IDindividu, categorie, action, description, commentaire, parametres, etat, traitement_date, IDperiode
FROM portail_actions %s;""" % conditions
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeActions = []
for IDaction, horodatage, IDfamille, IDindividu, categorie, action, description, commentaire, parametres, etat, traitement_date, IDperiode in listeDonnees:
traitement_date = UTILS_Dates.DateEngEnDateDD(traitement_date)
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,
})
DB.Close()
listeListeView = []
for action in listeActions:
listeListeView.append(Track(self, action, dictTitulaires))
return listeListeView
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 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
