def SuppressionArchives(self):
""" Supprime les archives obsolètes du répertoire Sync """
synchro_archivage_activer = UTILS_Config.GetParametre(
"synchro_archivage_activer", defaut=0)
synchro_archivage_delai = UTILS_Config.GetParametre(
"synchro_archivage_delai", defaut=30)
# Vérifie que la suppression auto de l'archivage est activé
if synchro_archivage_activer == 0:
return False
# Lecture des fichiers du répertoire SYNC
for nomFichier in os.listdir(UTILS_Fichiers.GetRepSync()):
if nomFichier.startswith("actions_") and nomFichier.endswith(
".archive"):
nomFichierCourt = nomFichier.replace(".dat", "").replace(
".archive", "")
# Lecture Horodatage
horodatage = nomFichierCourt.split("_")[2]
horodatage = UTILS_Dates.HorodatageEnDatetime(horodatage)
dateDuJour = datetime.datetime.now()
nbreJours = (dateDuJour - horodatage).days
# Suppression
if nbreJours > synchro_archivage_delai:
os.remove(UTILS_Fichiers.GetRepSync(nomFichier))
def GetTracks(self):
""" Récupération des données """
DB = GestionDB.DB()
# Lecture Individus
req = """SELECT IDindividu, nom, prenom
FROM individus;"""
DB.ExecuterReq(req)
listeIndividus = DB.ResultatReq()
dictIndividus = {}
for IDindividu, nom, prenom in listeIndividus:
if prenom == None: prenom = ""
dictIndividus[IDindividu] = u"%s %s" % (nom, prenom)
# Lecture unités
req = """SELECT IDunite, nom, abrege
FROM unites
ORDER BY ordre;"""
DB.ExecuterReq(req)
listeUnites = DB.ResultatReq()
dictUnites = {}
for IDunite, nom, abrege in listeUnites:
dictUnites[IDunite] = nom
DB.Close()
# Récupération du IDfichier
IDfichier = FonctionsPerso.GetIDfichier()
# Lecture des fichiers du répertoire SYNC
listeFichiers = os.listdir(UTILS_Fichiers.GetRepSync())
listeListeView = []
listeDictTempTraites = []
for nomFichier in listeFichiers:
if nomFichier.startswith("actions_%s" % IDfichier) and (
nomFichier.endswith(".dat") and self.listeFichiers
== None) or (self.listeFichiers != None
and nomFichier in self.listeFichiers):
nomFichierCourt = nomFichier.replace(".dat", "").replace(
".archive", "")
if nomFichier not in self.listeFichiersTrouves:
self.listeFichiersTrouves.append(nomFichier)
# Taille fichier
tailleFichier = os.path.getsize(
UTILS_Fichiers.GetRepSync(nomFichier))
# Horodatage
horodatage = nomFichierCourt.split("_")[2]
horodatage = UTILS_Dates.HorodatageEnDatetime(horodatage)
# Lecture du contenu du fichier
DB = GestionDB.DB(
suffixe=None,
nomFichier=UTILS_Fichiers.GetRepSync(nomFichier),
modeCreation=False)
req = """SELECT IDparametre, nom, valeur
FROM parametres;"""
DB.ExecuterReq(req)
listeParametres = DB.ResultatReq()
dictParametres = {}
for IDparametre, nom, valeur in listeParametres:
dictParametres[nom] = valeur
if ("nom_appareil" in dictParametres) == False:
dictParametres["nom_appareil"] = "Appareil inconnu"
if ("ID_appareil" in dictParametres) == False:
dictParametres["ID_appareil"] = "IDAppareil inconnu"
# Mémorise l'IDappareil
self.dictIDappareil[nomFichierCourt] = dictParametres[
"ID_appareil"]
# Lecture des consommations
req = """SELECT IDconso, horodatage, action, IDindividu, IDactivite, IDinscription, date, IDunite, IDgroupe, heure_debut, heure_fin, consommations.etat, date_saisie, IDutilisateur, IDcategorie_tarif, IDcompte_payeur, quantite, IDfamille
FROM consommations;"""
DB.ExecuterReq(req)
listeConsommations = DB.ResultatReq()
for IDconso, horodatage, action, IDindividu, IDactivite, IDinscription, date, IDunite, IDgroupe, heure_debut, heure_fin, etat, date_saisie, IDutilisateur, IDcategorie_tarif, IDcompte_payeur, quantite, IDfamille in listeConsommations:
horodatage = UTILS_Dates.HorodatageEnDatetime(
horodatage, separation="-")
date = UTILS_Dates.DateEngEnDateDD(date)
date_saisie = UTILS_Dates.DateEngEnDateDD(date_saisie)
dictTemp = {
"categorie": "consommation",
"IDconso": IDconso,
"horodatage": horodatage,
"action": action,
"IDindividu": IDindividu,
"IDactivite": IDactivite,
"IDinscription": IDinscription,
"date": date,
"IDunite": IDunite,
"IDgroupe": IDgroupe,
"heure_debut": heure_debut,
"heure_fin": heure_fin,
"etat": etat,
"quantite": quantite,
"date_saisie": date_saisie,
"IDutilisateur": IDutilisateur,
"IDcategorie_tarif": IDcategorie_tarif,
"IDcompte_payeur": IDcompte_payeur,
"IDfamille": IDfamille,
}
# Vérifie que cette action n'est pas déjà dans la liste
if dictTemp not in listeDictTempTraites:
listeListeView.append(
Track(dictTemp,
dictIndividus=dictIndividus,
dictUnites=dictUnites,
dictParametres=dictParametres,
nomFichier=nomFichier))
if self.cacher_doublons == True:
listeDictTempTraites.append(dictTemp)
# Lecture des mémos journaliers
req = """SELECT IDmemo, horodatage, action, IDindividu, date, texte
FROM memo_journee;"""
DB.ExecuterReq(req)
listeMemosJournees = DB.ResultatReq()
for IDmemo, horodatage, action, IDindividu, date, texte in listeMemosJournees:
horodatage = UTILS_Dates.HorodatageEnDatetime(
horodatage, separation="-")
date = UTILS_Dates.DateEngEnDateDD(date)
dictTemp = {
"categorie": "memo_journee",
"IDmemo": IDmemo,
"horodatage": horodatage,
"action": action,
"IDindividu": IDindividu,
"date": date,
"texte": texte,
}
# Vérifie que cette action n'est pas déjà dans la liste
if dictTemp not in listeDictTempTraites:
listeListeView.append(
Track(dictTemp,
dictIndividus=dictIndividus,
dictParametres=dictParametres,
nomFichier=nomFichier))
if self.cacher_doublons == True:
listeDictTempTraites.append(dictTemp)
DB.Close()
return listeListeView
def GetTracks(self):
""" Récupération des données """
# Récupération du IDfichier
IDfichier = FonctionsPerso.GetIDfichier()
# Lecture des fichiers du répertoire SYNC
listeFichiers = os.listdir(UTILS_Fichiers.GetRepSync())
listeListeView = []
for nomFichier in listeFichiers:
if nomFichier.startswith("actions_%s" % IDfichier) and (
nomFichier.endswith(".dat") or
(nomFichier.endswith(".archive")
and self.inclure_archives == True)):
nomFichierCourt = nomFichier.replace(".dat", "").replace(
".archive", "")
# Taille fichier
tailleFichier = os.path.getsize(
UTILS_Fichiers.GetRepSync(nomFichier))
# Horodatage
horodatage = nomFichierCourt.split("_")[2]
horodatage = UTILS_Dates.HorodatageEnDatetime(horodatage)
# Lecture du contenu du fichier
DB = GestionDB.DB(
suffixe=None,
nomFichier=UTILS_Fichiers.GetRepSync(nomFichier),
modeCreation=False)
req = """SELECT IDparametre, nom, valeur
FROM parametres;"""
DB.ExecuterReq(req)
listeParametres = DB.ResultatReq()
dictParametres = {}
for IDparametre, nom, valeur in listeParametres:
dictParametres[nom] = valeur
if dictParametres.has_key("nom_appareil") == False:
dictParametres["nom_appareil"] = "Appareil inconnu"
if dictParametres.has_key("ID_appareil") == False:
dictParametres["ID_appareil"] = "IDAppareil inconnu"
liste_details_actions = []
req = """SELECT IDconso, horodatage, action
FROM consommations;"""
DB.ExecuterReq(req)
listeConsommations = DB.ResultatReq()
if len(listeConsommations) > 0:
liste_details_actions.append(
_(u"%d actions sur les consommations") %
len(listeConsommations))
req = """SELECT IDmemo, horodatage, action
FROM memo_journee;"""
DB.ExecuterReq(req)
listeMemosJournees = DB.ResultatReq()
if len(listeMemosJournees) > 0:
liste_details_actions.append(
_(u"%d actions sur les mémos journaliers") %
len(listeMemosJournees))
DB.Close()
detail_actions = ", ".join(liste_details_actions)
if detail_actions == "":
detail_actions = _(u"Aucune action")
dictTemp = {
"nom_fichier": nomFichier,
"taille_fichier": tailleFichier,
"nom_appareil": dictParametres["nom_appareil"],
"ID_appareil": dictParametres["ID_appareil"],
"horodatage": horodatage,
"detail_actions": detail_actions
}
listeListeView.append(Track(dictTemp))
return listeListeView
