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()