def On_outils_purger_ftp(self, event):
""" Supprime tous les fichiers du répertoire FTP """
hote = UTILS_Config.GetParametre("synchro_ftp_hote", defaut="")
identifiant = UTILS_Config.GetParametre("synchro_ftp_identifiant",
defaut="")
mdp = base64.b64decode(
UTILS_Config.GetParametre("synchro_ftp_mdp", defaut=""))
repertoire = UTILS_Config.GetParametre("synchro_ftp_repertoire",
defaut="")
IDfichier = FonctionsPerso.GetIDfichier()
nbreFichiersSupprimes = 0
try:
ftp = ftplib.FTP(hote, identifiant, mdp)
ftp.cwd(repertoire)
# Récupère la liste des fichiers de synchronisation présents sur le répertoire FTP
for nomFichier in ftp.nlst():
if IDfichier in nomFichier and (
nomFichier.endswith(
UTILS_Export_nomade.EXTENSION_CRYPTE)
or nomFichier.endswith(
UTILS_Export_nomade.EXTENSION_DECRYPTE)):
ftp.delete(nomFichier)
nbreFichiersSupprimes += 1
ftp.quit()
except Exception, err:
print err
dlg = wx.MessageDialog(
self,
_(u"La connexion FTP n'a pas pu être établie !\n\nVérifiez les paramètres de connexion FTP dans les paramètres de synchronisation."
), "Erreur ", wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
def MAJ(self):
""" MAJ du bouton Analyser """
# Lecture des fichiers du répertoire SYNC
IDfichier = FonctionsPerso.GetIDfichier()
listeFichiers = os.listdir(UTILS_Fichiers.GetRepSync())
nbreFichiers = 0
for nomFichier in listeFichiers:
if nomFichier.startswith(
"actions_%s" % IDfichier) and nomFichier.endswith(".dat"):
nbreFichiers += 1
# MAJ du bouton Analyser
if nbreFichiers == 0:
self.bouton_analyse.SetToolTipString(
_(u"Aucun fichier à importer"))
self.bouton_analyse.SetBackgroundColour(self.couleur_defaut)
self.bouton_analyse.Enable(False)
elif nbreFichiers == 1:
self.bouton_analyse.SetToolTipString(_(u"1 fichier à importer"))
self.bouton_analyse.SetBackgroundColour((150, 255, 150))
self.bouton_analyse.Enable(True)
else:
self.bouton_analyse.SetToolTipString(
_(u"%d fichiers à importer") % nbreFichiers)
self.bouton_analyse.SetBackgroundColour((150, 255, 150))
self.bouton_analyse.Enable(True)
def RecevoirFTP(self):
""" Réception des fichiers FTP """
# Récupération des paramètres
hote = UTILS_Config.GetParametre("synchro_ftp_hote", defaut="")
identifiant = UTILS_Config.GetParametre("synchro_ftp_identifiant", defaut="")
mdp = base64.b64decode(UTILS_Config.GetParametre("synchro_ftp_mdp", defaut=""))
repertoire = UTILS_Config.GetParametre("synchro_ftp_repertoire", defaut="")
IDfichier = FonctionsPerso.GetIDfichier()
# Récupération des fichiers
listeFichiersRecus = []
dlgAttente = wx.BusyInfo(_(u"Récupération des fichiers de synchronisation depuis un répertoire FTP..."), self)
try :
ftp = ftplib.FTP(hote, identifiant, mdp)
ftp.cwd(repertoire)
# Récupère la liste des fichiers de synchronisation présents sur le répertoire FTP
for nomFichier in ftp.nlst() :
if nomFichier.startswith("actions_%s" % IDfichier) and (nomFichier.endswith(UTILS_Export_nomade.EXTENSION_CRYPTE) or nomFichier.endswith(UTILS_Export_nomade.EXTENSION_DECRYPTE)) :
try :
tailleFichier = ftp.size(nomFichier)
except :
ftp.voidcmd('TYPE I')
tailleFichier = ftp.size(nomFichier)
ftp.retrbinary("RETR %s" % nomFichier, open(UTILS_Fichiers.GetRepSync(nomFichier), "wb").write)
listeFichiersRecus.append((nomFichier, tailleFichier))
ftp.quit()
except Exception, err :
print err
dlgAttente.Destroy()
del dlgAttente
dlg = wx.MessageDialog(self, _(u"La connexion FTP n'a pas pu être établie !\n\nVérifiez les paramètres de connexion FTP dans les paramètres de synchronisation."), "Erreur ", wx.OK | wx.ICON_ERROR)
dlg.ShowModal()
dlg.Destroy()
return False
def MAJ(self):
""" MAJ du bouton Analyser """
# Paramètres liste blanche et liste noire d'IP
global IP_AUTORISEES, IP_INTERDITES
IP_AUTORISEES = UTILS_Config.GetParametre(
"synchro_serveur_ip_autorisees", defaut=None)
IP_INTERDITES = UTILS_Config.GetParametre(
"synchro_serveur_ip_interdites", defaut=None)
# Lecture des fichiers du répertoire SYNC
IDfichier = FonctionsPerso.GetIDfichier()
listeFichiers = os.listdir(UTILS_Fichiers.GetRepSync())
nbreFichiers = 0
for nomFichier in listeFichiers:
if nomFichier.startswith(
"actions_%s" % IDfichier) and nomFichier.endswith(".dat"):
nbreFichiers += 1
# MAJ du bouton Analyser
if nbreFichiers == 0:
self.bouton_analyse.SetToolTip(
wx.ToolTip(_(u"Aucun fichier à importer")))
self.bouton_analyse.SetBackgroundColour(self.couleur_defaut)
self.bouton_analyse.Enable(False)
elif nbreFichiers == 1:
self.bouton_analyse.SetToolTip(
wx.ToolTip(_(u"1 fichier à importer")))
self.bouton_analyse.SetBackgroundColour((150, 255, 150))
self.bouton_analyse.Enable(True)
else:
self.bouton_analyse.SetToolTip(
wx.ToolTip(_(u"%d fichiers à importer") % nbreFichiers))
self.bouton_analyse.SetBackgroundColour((150, 255, 150))
self.bouton_analyse.Enable(True)
def DecrypteMDP(mdp="", IDfichier=None):
if mdp.startswith("#@#"):
if not IDfichier:
IDfichier = FonctionsPerso.GetIDfichier()
cryptage = UTILS_Cryptage_fichier.AESCipher(IDfichier[-10:],
bs=16,
prefixe=u"#@#")
mdp = cryptage.decrypt(mdp)
return mdp
def CrypteMDP(mdp="", IDfichier=None):
""" Crypte un mot de passe donné """
if not mdp.startswith("#@#"):
if not IDfichier:
IDfichier = FonctionsPerso.GetIDfichier()
cryptage = UTILS_Cryptage_fichier.AESCipher(IDfichier[-10:],
bs=16,
prefixe=u"#@#")
mdp = cryptage.encrypt(mdp)
return mdp
def GenerationPiecesJointes(self):
""" Génération des pièces jointes """
IDfichier = FonctionsPerso.GetIDfichier()
listeIDfacture = []
dictTracks = {}
for track in self.ctrl_pieces.GetObjects():
listeIDfacture.append(track.IDfacture)
dictTracks[track.IDfacture] = track
# Génération des factures au format PDF
nomFichierUnique = self.ctrl_parametres.GetPropertyValue(
"format_nom_fichier")
facturation = UTILS_Facturation.Facturation()
resultat = facturation.Impression(listeFactures=listeIDfacture,
nomFichierUnique=nomFichierUnique,
afficherDoc=False,
repertoireTemp=True)
if resultat == False:
return False
dictChampsFusion, dictPieces = resultat
# Conversion des fichiers en GZIP/base64
dict_pieces_jointes = {}
for IDfacture, cheminFichier in dictPieces.items():
# Compression GZIP
cheminFichierGzip = cheminFichier + ".zip"
with open(cheminFichier,
'rb') as f_in, gzip.open(cheminFichierGzip,
'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
# Encodage en base64
with open(cheminFichierGzip, "rb") as fichier:
contenu = base64.b64encode(fichier.read())
# Suppression des fichiers temporaires
os.remove(cheminFichier)
os.remove(cheminFichierGzip)
# Mémorisation des pièces jointes
NomPJ = os.path.basename(cheminFichier)
numero_facture = dictTracks[IDfacture].numero
IdUnique = IDfichier + str(numero_facture)
dict_pieces_jointes[IDfacture] = {
"NomPJ": NomPJ,
"IdUnique": IdUnique,
"contenu": contenu,
"numero_facture": numero_facture
}
return dict_pieces_jointes
def CreationMDP(nbreCaract=8, IDfichier=None, cryptage=True):
""" Création d'un mot de passe aléatoire """
# Génération du mot de passe
mdp = ""
for x in range(0, nbreCaract):
mdp += random.choice("bcdfghjkmnprstvwxzBCDFGHJKLMNPRSTVWXZ123456789")
# Cryptage du mot de passe
if cryptage:
if not IDfichier:
IDfichier = FonctionsPerso.GetIDfichier()
cryptage = UTILS_Cryptage_fichier.AESCipher(IDfichier[-10:],
bs=16,
prefixe=u"#@#")
mdp = cryptage.encrypt(mdp)
return mdp
def __init__(self, *args, **kwds):
# Récupération des paramètres perso
self.selectionID = None
self.selectionTrack = None
self.criteres = ""
self.donnees = []
self.itemSelected = False
self.popupIndex = -1
self.listeFiltres = []
self.filtre_familles = None
self.IDfichier = FonctionsPerso.GetIDfichier()
# Initialisation du listCtrl
self.nom_fichier_liste = __file__
FastObjectListView.__init__(self, *args, **kwds)
# Binds perso
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
def Suite(self, succes):
""" Après le téléchargement passe à la suite """
# Vérifie que le fichier est bien entier :
tailleFichierDest = os.path.getsize(self.parent.fichierDest + "/" +
self.parent.nomFichier)
tailleFichierOrigin = self.parent.tailleFichier
if tailleFichierDest != tailleFichierOrigin:
succes = False
# Téléchargement terminé
if succes == True:
# On attribue un ID unique qui permet de compter les téléchargements
IDfichier = FonctionsPerso.GetIDfichier()
if len(IDfichier) > 7:
id = IDfichier[-7:]
else:
id = ""
# On envoie le signal pour le compteur de téléchargement
if "linux" in sys.platform:
typeFichier = "linux"
else:
typeFichier = "windows"
try:
versionFichier = self.parent.versionFichier
fichier = "%s-%s-%s" % (typeFichier, versionFichier, id)
req = Request(
"http://www.teamworks.ovh/fichiers/telechargement.cgi?fichier=%s"
% fichier)
handle = urlopen(req)
except:
pass
# Si téléchargement complet, on passe à la page de fin de téléchargement
sleep(1) # Attend 2 secondes avant de continuer
self.parent.Active_page("page_fin_telechargement")
else:
# Vidage du rep Updates
FonctionsPerso.VideRepertoireUpdates(forcer=True)
# Le téléchargement n'est pas complet, demande à l'utilisateur de recommencer
self.label_introduction.SetLabel(
_(u"Le téléchargement n'est pas complet. Voulez-vous recommencer ?"
))
self.bouton_ok.Show(True)
self.Layout()
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 Upload_config(self, ftp=None):
""" Met en ligne le fichier de config """
liste_lignes = [
u"#!/usr/bin/env python\n", u"# -*- coding: utf-8 -*-\n", u"\n",
u"import os\n",
u"basedir = os.path.abspath(os.path.dirname(__file__))\n", u"\n",
u"class Config_application(object):\n"
]
def Ecrit_ligne(key="", valeur="", type_valeur=None):
if type_valeur == unicode:
valeur = u'u"%s"' % valeur
elif type_valeur == str:
valeur = u'"%s"' % valeur
elif type_valeur == None:
valeur = valeur
else:
valeur = str(valeur)
return u" %s = %s\n" % (key, valeur)
# Valeurs Application
if self.dict_parametres["db_type"] == 0:
# Base Sqlite
liste_lignes.append(
Ecrit_ligne("SQLALCHEMY_DATABASE_URI",
"'sqlite:///' + os.path.join(basedir, 'data.db')",
type_valeur=None))
else:
# Base MySQL
db_serveur = self.dict_parametres["db_serveur"]
db_utilisateur = self.dict_parametres["db_utilisateur"]
db_mdp = self.dict_parametres["db_mdp"]
db_nom = self.dict_parametres["db_nom"]
liste_lignes.append(
Ecrit_ligne("SQLALCHEMY_DATABASE_URI",
"mysql://%s:%s@%s/%s" %
(db_utilisateur, db_mdp, db_serveur, db_nom),
type_valeur=str))
liste_lignes.append(
Ecrit_ligne("SQLALCHEMY_TRACK_MODIFICATIONS",
True,
type_valeur=bool))
liste_lignes.append(
Ecrit_ligne("SQLALCHEMY_ECHO", False, type_valeur=bool))
liste_lignes.append(
Ecrit_ligne("SECRET_KEY",
self.dict_parametres["secret_key"],
type_valeur=str))
liste_lignes.append(
Ecrit_ligne("WTF_CSRF_ENABLED", True, type_valeur=bool))
liste_lignes.append(
Ecrit_ligne("DEBUG",
self.dict_parametres["mode_debug"],
type_valeur=bool))
# Valeurs Utilisateur
liste_lignes.append("\nclass Config_utilisateur(object):\n")
# IDfichier
IDfichier = FonctionsPerso.GetIDfichier()
liste_lignes.append(
Ecrit_ligne("IDfichier", IDfichier, type_valeur=str))
# Thème
index = 0
for code, label in LISTE_THEMES:
if index == self.dict_parametres["theme"]:
theme = "skin-%s" % code
index += 1
liste_lignes.append(Ecrit_ligne("SKIN", theme, type_valeur=str))
# Image de fond identification
if self.dict_parametres["image_identification"] != "":
image = os.path.basename(
self.dict_parametres["image_identification"])
else:
image = ""
liste_lignes.append(
Ecrit_ligne("IMAGE_FOND", image, type_valeur=unicode))
# Cadre logo organisateur
if self.dict_parametres["cadre_logo"] == 0:
rond = False
else:
rond = True
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_IMAGE_ROND", rond, type_valeur=bool))
# Données organisateur
dict_organisateur = UTILS_Organisateur.GetDonnees(tailleLogo=(200,
200))
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_NOM",
dict_organisateur["nom"],
type_valeur=unicode))
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_RUE",
dict_organisateur["rue"],
type_valeur=unicode))
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_CP",
dict_organisateur["cp"],
type_valeur=unicode))
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_VILLE",
dict_organisateur["ville"],
type_valeur=unicode))
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_TEL",
dict_organisateur["tel"],
type_valeur=unicode))
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_FAX",
dict_organisateur["fax"],
type_valeur=unicode))
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_EMAIL",
dict_organisateur["mail"],
type_valeur=unicode))
# Logo organisateur
logo = dict_organisateur["logo"]
if logo != None:
nomFichier = "logo.png"
cheminLogo = UTILS_Fichiers.GetRepTemp(fichier=nomFichier)
logo.SaveFile(cheminLogo, type=wx.BITMAP_TYPE_PNG)
liste_lignes.append(
Ecrit_ligne("ORGANISATEUR_IMAGE",
nomFichier,
type_valeur=unicode))
# Envoi local
if self.dict_parametres["hebergement_type"] == 0:
if self.dict_parametres["hebergement_local_repertoire"] != None:
try:
destfilepath = os.path.join(
self.
dict_parametres["hebergement_local_repertoire"],
"application/static")
shutil.copy2(cheminLogo, destfilepath)
except Exception, err:
print str(err)
return False
# Envoi du logo par FTP
if self.dict_parametres["hebergement_type"] == 1:
if ftp != None:
try:
ftp.cwd("/" + self.dict_parametres["ftp_repertoire"] +
"/application/static")
fichier = open(cheminLogo, "rb")
ftp.storbinary('STOR ' + nomFichier, fichier)
except Exception, err:
print str(err)
return False
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
