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