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