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