示例#1
0
    def Importation(self):
        """ Importation des transports depuis la base de données """
        # Récupération des champs de la table
        listeChamps = []
        for nom, type, info in DICT_TABLES["transports"]:
            listeChamps.append(nom)

        # Importation
        DB = GestionDB.DB()
        req = """SELECT %s
        FROM transports 
        WHERE mode="TRANSP" AND IDindividu=%d;""" % (", ".join(listeChamps),
                                                     self.IDindividu)
        DB.ExecuterReq(req)
        listeDonnees = DB.ResultatReq()
        DB.Close()

        # Stockage des données sous forme de dictionnaires dans une liste
        listeTransports = []
        for donnees in listeDonnees:
            dictTemp = {}
            index = 0
            for valeur in donnees:
                dictTemp[listeChamps[index]] = valeur
                index += 1
            listeTransports.append(dictTemp)

        # Récupération des données tierces
        modLocalisation = UTILS_Transports.AnalyseLocalisation()

        # Création des schedules
        for dictTransport in listeTransports:
            dictTransport = self.AnalyseTransport(dictTransport,
                                                  modLocalisation)
            self.CreationSchedule(dictTransport)
    def GetTracks(self):
        """ Récupération des données """
        modLocalisation = UTILS_Transports.AnalyseLocalisation()

        listeListeView = []
        for IDtransport, item in self.dictTransports.iteritems():
            track = Track(item, modLocalisation)
            listeListeView.append(track)
            if self.selectionID == IDtransport:
                self.selectionTrack = track
        return listeListeView
    def Remplissage(self, listeDates=[], dictFiltres={}):        
        # Importation des données
        DB = GestionDB.DB()
        
        # Création de la condition
        if len(listeDates) == 0 : 
            conditionDates = "depart_date='2999-01-01' "
        elif len(listeDates) == 1 : 
            conditionDates = "(depart_date='%s' OR arrivee_date='%s')" % (listeDates[0], listeDates[0])
        else : 
            listeTmp = []
            for dateTmp in listeDates :
                listeTmp.append(str(dateTmp))
            conditionDates = "(depart_date IN %s OR arrivee_date IN %s)" % (str(tuple(listeTmp)), str(tuple(listeTmp)))
        
        # Récupération des lignes
        req = """SELECT IDligne, categorie, nom
        FROM transports_lignes;""" 
        DB.ExecuterReq(req)
        listeValeurs = DB.ResultatReq()
        dictLignes = {}
        for IDligne, categorie, nom in listeValeurs :
            dictLignes[IDligne] = nom
            
        # Récupération des arrêts
        req = """SELECT IDarret, IDligne, nom
        FROM transports_arrets
        ORDER BY ordre;""" 
        DB.ExecuterReq(req)
        listeValeurs = DB.ResultatReq()
        dictArrets = {}
        for IDarret, IDligne, nom in listeValeurs :
            dictArrets[IDarret] = {"IDligne":IDligne, "nom":nom}
            
        # Récupération des lieux
        req = """SELECT IDlieu, categorie, nom
        FROM transports_lieux;""" 
        DB.ExecuterReq(req)
        listeValeurs = DB.ResultatReq()
        dictLieux = {}
        for IDlieu, categorie, nom in listeValeurs :
            dictLieux[IDlieu] = nom

        # Récupération des individus
        req = """SELECT IDindividu, nom, prenom
        FROM individus;""" 
        DB.ExecuterReq(req)
        listeValeurs = DB.ResultatReq()
        dictIndividus = {}
        for IDindividu, nom, prenom in listeValeurs :
            dictIndividus[IDindividu] = u"%s %s" % (nom, prenom)

        # Récupération des transports
        listeChamps = []
        for nom, type, info in DICT_TABLES["transports"] :
            listeChamps.append(nom)
        DB = GestionDB.DB()
        req = """SELECT %s
        FROM transports 
        WHERE %s;""" % (", ".join(listeChamps), conditionDates)
        DB.ExecuterReq(req)
        listeDonnees = DB.ResultatReq()
        DB.Close() 
        
        listeTransports = []
        for ligne in listeDonnees :
            index = 0
            dictTemp = {}
            for valeur in ligne :
                nomChamp = listeChamps[index]
                if "date" in nomChamp : 
                    valeur = DateEngEnDateDD(valeur)
                dictTemp[nomChamp] = valeur
                index += 1
            listeTransports.append(dictTemp)
        
        def VerifieFiltre(rubrique, code):
            if rubrique in dictFiltres :
                if code in dictFiltres[rubrique] or code == None :
                    return True
            return False
            
        # Tri des transports dans des dictionnaires
        dictDonnees = {}
        for dictTransport in listeTransports :
            
            categorie = dictTransport["categorie"]
            if VerifieFiltre("categories", categorie) == True :
            
                # Catégorie
                if (categorie in dictDonnees) == False :
                    dictDonnees[categorie] = {"lignes":{}, "lieux":{}, "localisations":{}}
                
                typeTransports = DICT_CATEGORIES[categorie]["type"]
                
                for prefixe in ("depart", "arrivee") :
                    
                    if dictTransport["%s_date" % prefixe] in listeDates :
                            
                        dictIndividu = {"IDtransport" : dictTransport["IDtransport"], "IDindividu" : dictTransport["IDindividu"], "sens":prefixe}
                        
                        # ------------ Lignes ----------------
                        if typeTransports == "lignes" :

                            # Lignes
                            IDligne = dictTransport["IDligne"]
                            if VerifieFiltre("lignes", IDligne) == True :

                                if IDligne not in dictDonnees[categorie]["lignes"] :
                                    dictDonnees[categorie]["lignes"][IDligne] = {}

                                # Arrets
                                IDarret = dictTransport["%s_IDarret" % prefixe]
                                if VerifieFiltre("arrets", IDarret) == True :
                                    
                                    if IDarret not in dictDonnees[categorie]["lignes"][IDligne] :
                                        dictDonnees[categorie]["lignes"][IDligne][IDarret] = {}
                                    
                                    # Heures
                                    heure = dictTransport["%s_heure" % prefixe]
                                    if heure not in dictDonnees[categorie]["lignes"][IDligne][IDarret] :
                                        dictDonnees[categorie]["lignes"][IDligne][IDarret][heure] = {}
                                    
                                    # Dates
                                    date = dictTransport["%s_date" % prefixe]
                                    if date not in dictDonnees[categorie]["lignes"][IDligne][IDarret][heure] :
                                        dictDonnees[categorie]["lignes"][IDligne][IDarret][heure][date] = []
                                    
                                    # Ajout de l'individu
                                    dictDonnees[categorie]["lignes"][IDligne][IDarret][heure][date].append(dictIndividu)
                        
                        
                        # -------------- Lieux --------------
                        if typeTransports == "lieux" :
                            
                            IDlieu = dictTransport["%s_IDlieu" % prefixe]
                            if VerifieFiltre("lieux", IDlieu) == True :
                                
                                if IDlieu not in dictDonnees[categorie]["lieux"] :
                                    dictDonnees[categorie]["lieux"][IDlieu] = {}
                                    
                                # Heures
                                heure = dictTransport["%s_heure" % prefixe]
                                if heure not in dictDonnees[categorie]["lieux"][IDlieu] :
                                    dictDonnees[categorie]["lieux"][IDlieu][heure] = {}
                                
                                # Dates
                                date = dictTransport["%s_date" % prefixe]
                                if date not in dictDonnees[categorie]["lieux"][IDlieu][heure] :
                                    dictDonnees[categorie]["lieux"][IDlieu][heure][date] = []
                                
                                # Ajout de l'individu
                                dictDonnees[categorie]["lieux"][IDlieu][heure][date].append(dictIndividu)
                        
                        
                        # -------------- Localisation --------------
                        if typeTransports == "localisations" :
                            
                            localisation = dictTransport["%s_localisation" % prefixe]
                            if localisation not in dictDonnees[categorie]["localisations"] :
                                dictDonnees[categorie]["localisations"][localisation] = {}
                                
                            # Heures
                            heure = dictTransport["%s_heure" % prefixe]
                            if heure not in dictDonnees[categorie]["localisations"][localisation] :
                                dictDonnees[categorie]["localisations"][localisation][heure] = {}
                            
                            # Dates
                            date = dictTransport["%s_date" % prefixe]
                            if date not in dictDonnees[categorie]["localisations"][localisation][heure] :
                                dictDonnees[categorie]["localisations"][localisation][heure][date] = []
                            
                            # Ajout de l'individu
                            dictDonnees[categorie]["localisations"][localisation][heure][date].append(dictIndividu)
        
        
        # ------------------ Remplissage ---------------------
        self.listeBranches = []
        modLocalisation = UTILS_Transports.AnalyseLocalisation() 
        
        # -----------------------------------------------------------------------------------------------------
        
        def InsertionBranchesHeures(dictDonnees, niveauParent, marge=0):
            # Heures
            listeheures = []
            for heure, dictHeure in dictDonnees.items() :
                listeheures.append((heure, dictHeure))
            listeheures.sort() 
            
            for heure, dictHeure in listeheures :
                if heure != None :
                    label = heure.replace(":", "h")
                else :
                    label = _(u"Heure inconnue")
                niveauHeure = self.AppendItem(niveauParent, label)
                self.SetPyData(niveauHeure, {"type":"heures", "code":heure})
                
                # Totaux par heure
                dictImpressionColonnes = {}
                for date, listeIndividus in dictHeure.items() :
                    indexColonne = self.dictIndexColonnes[date]
                    labelTotal = str(len(listeIndividus))
                    self.SetItemText(niveauHeure, labelTotal, indexColonne)
                    dictImpressionColonnes[indexColonne] = labelTotal
                    
                dictImpressionTemp["elements"].append({"type":"heures", "texte":label, "marge":marge, "colonnes":dictImpressionColonnes})
                
                # Individus
                dictIndividusTemp = {}
                for date, listeIndividus in dictHeure.items() :
                    for dictIndividu in listeIndividus :
                        IDindividu = dictIndividu["IDindividu"]
                        sens = dictIndividu["sens"]
                        if (IDindividu in dictIndividusTemp) == False :
                            dictIndividusTemp[IDindividu] = {}
                        dictIndividusTemp[IDindividu][date] = sens
                
                listeIndividusTemp = []
                for IDindividu, dictDates in dictIndividusTemp.items() :
                    if IDindividu in dictIndividus :
                        label = dictIndividus[IDindividu]
                    else :
                        label = _(u"Individu inconnu")
                    listeIndividusTemp.append((label, IDindividu, dictDates))
                listeIndividusTemp.sort() 
                
                for label, IDindividu, dictDates in listeIndividusTemp :
                    labelIndividu = label
                    niveauIndividu = self.AppendItem(niveauHeure, labelIndividu)
                    self.SetPyData(niveauIndividu, {"type":"individus", "code":IDindividu})
                    
                    # Dates
                    dictImpressionColonnes = {}
                    for date, sens in dictDates.items() :
                        # Recherche la colonne date
                        if date in self.dictIndexColonnes :
                            indexColonne = self.dictIndexColonnes[date]
                            if sens == "depart" : label = _(u"Départ")
                            elif sens == "arrivee" : label = _(u"Arrivée")
                            else : label = u""
                            self.SetItemText(niveauIndividu, label, indexColonne)
                            dictImpressionColonnes[indexColonne] = label
                    
                    dictImpressionTemp["elements"].append({"type":"individus", "texte":labelIndividu, "marge":marge+1, "colonnes":dictImpressionColonnes})
        
        # -----------------------------------------------------------------------------------------------------
        
        
        listeCategories = []
        if len(dictDonnees) > 0 :
            listeCategories = list(dictDonnees.keys()) 
        listeCategories.sort() 

        # Remplissage
        for categorie in listeCategories :
            
            # Catégories
            label = DICT_CATEGORIES[categorie]["label"]
            brancheCategorie = self.AppendItem(self.root, label)
            self.SetPyData(brancheCategorie, {"type":"categories", "code":categorie})
            self.SetItemBold(brancheCategorie)
            self.SetItemBackgroundColour(brancheCategorie, wx.Colour(*COULEUR_FOND_REGROUPEMENT))
            self.SetItemImage(brancheCategorie, self.dictImages[categorie]["index"])
            
            dictImpressionTemp = {"texte":label, "img":self.dictImages[categorie]["nomFichier"], "elements":[]}
            
            # Lignes
            listeLignes = []
            for IDligne, dictLigne in dictDonnees[categorie]["lignes"].items() :
                if IDligne in dictLignes :
                    label = dictLignes[IDligne]
                else :
                    label = _(u"Ligne inconnue")
                listeLignes.append((label, IDligne))
            listeLignes.sort() 

            for label, IDligne in listeLignes :
                niveauLigne = self.AppendItem(brancheCategorie, label)
                self.SetPyData(niveauLigne, {"type":"lignes", "code":IDligne})
                dictImpressionTemp["elements"].append({"type":"lignes", "texte":label, "marge":1})
                
                # Arrêts
                listeArrets = []
                for IDarret, dictArret in dictDonnees[categorie]["lignes"][IDligne].items() :
                    if IDarret in dictArrets :
                        label = dictArrets[IDarret]["nom"]
                    else :
                        label = _(u"Arrêt inconnu")
                    listeArrets.append((label, IDarret, dictArret))
                listeArrets.sort() 
                
                for label, IDarret, dictArret in listeArrets :
                    niveauArret = self.AppendItem(niveauLigne, label)
                    self.SetPyData(niveauArret, {"type":"arrets", "code":IDarret})
                    dictImpressionTemp["elements"].append({"type":"arrets", "texte":label, "marge":2})
                    
                    # Insertion des branches Heures et Individus
                    InsertionBranchesHeures(dictArret, niveauArret, marge=3)
                       
            
            # Lieux
            listeLieux = []
            for IDlieu, dictLieu in dictDonnees[categorie]["lieux"].items() :
                if IDlieu in dictLieux :
                    label = dictLieux[IDlieu]
                else :
                    label = _(u"Lieu inconnu")
                listeLieux.append((label, IDlieu, dictLieu))
            listeLieux.sort() 
            
            for label, IDlieu, dictLieu in listeLieux :
                niveauLieu = self.AppendItem(brancheCategorie, label)
                self.SetPyData(niveauLieu, {"type":"lieux", "code":IDlieu})
                dictImpressionTemp["elements"].append({"type":"lieux", "texte":label, "marge":1})
                
                # Insertion des branches Heures et Individus
                InsertionBranchesHeures(dictLieu, niveauLieu, marge=2)

            # Localisations
            listeLocalisations = []
            for localisation, dictLocalisation in dictDonnees[categorie]["localisations"].items() :
                label = modLocalisation.Analyse(localisation=localisation)
                listeLocalisations.append((label, localisation, dictLocalisation))
            listeLocalisations.sort() 
            
            for label, localisation, dictLocalisation in listeLocalisations :
                niveauLocalisation = self.AppendItem(brancheCategorie, label)
                self.SetPyData(niveauLocalisation, {"type":"localisations", "code":localisation})
                dictImpressionTemp["elements"].append({"type":"localisations", "texte":label, "marge":1})
                
                # Insertion des branches Heures et Individus
                InsertionBranchesHeures(dictLocalisation, niveauLocalisation, marge=2)

            
            # Mémorisation du bloc catégorie pour impression PDF
            self.dictImpression["donnees"].append(dictImpressionTemp)
            
        self.ExpandAllChildren(self.root)
示例#4
0
    def GetTracks(self):
        """ Récupération des données """
        modLocalisation = UTILS_Transports.AnalyseLocalisation()

        if self.IDindividu != None:
            conditionIndividu = "AND transports.IDindividu=%d" % self.IDindividu
        else:
            conditionIndividu = ""

        listeID = None
        DB = GestionDB.DB()
        req = """SELECT IDtransport, transports.IDindividu, categorie, 
        depart_date, depart_heure, depart_IDarret, depart_IDlieu, depart_localisation,
        arrivee_date, arrivee_heure, arrivee_IDarret, arrivee_IDlieu, arrivee_localisation,
        individus.nom, individus.prenom
        FROM transports
        LEFT JOIN individus ON individus.IDindividu = transports.IDindividu
        WHERE mode='TRANSP' %s
        ORDER BY depart_date;
        """ % conditionIndividu
        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, modLocalisation)

                # Filtres
                valide = True
                if self.dictFiltres.has_key(
                        "individu"
                ) and track.IDindividu != self.dictFiltres["individu"]:
                    valide = False
                if self.dictFiltres.has_key(
                        "transport"
                ) and track.categorie != self.dictFiltres["transport"]:
                    valide = False
                if self.dictFiltres.has_key(
                        "depart_date"
                ) and track.depart_dateDD != self.dictFiltres["depart_date"]:
                    valide = False
                if self.dictFiltres.has_key(
                        "depart_heure"
                ) and track.depart_heure != self.dictFiltres["depart_heure"]:
                    valide = False
                if self.dictFiltres.has_key(
                        "depart_lieu"
                ) and track.depart_nom != self.dictFiltres["depart_lieu"]:
                    valide = False
                if self.dictFiltres.has_key(
                        "arrivee_date"
                ) and track.arrivee_dateDD != self.dictFiltres["arrivee_date"]:
                    valide = False
                if self.dictFiltres.has_key(
                        "arrivee_heure"
                ) and track.arrivee_heure != self.dictFiltres["arrivee_heure"]:
                    valide = False
                if self.dictFiltres.has_key(
                        "arrivee_lieu"
                ) and track.arrivee_nom != self.dictFiltres["arrivee_lieu"]:
                    valide = False

                if valide == True:
                    listeListeView.append(track)
                    if self.selectionID == item[0]:
                        self.selectionTrack = track

        return listeListeView