def GetDictConfig(self):
""" Recupere une copie du dictionnaire du fichier de config """
data = {}
try :
data = UTILS_Json.Lire(self.nomFichier)
except:
nom_fichier_bak = self.nomFichier + ".bak"
if os.path.isfile(nom_fichier_bak):
print("Recuperation de config.json.bak")
data = UTILS_Json.Lire(nom_fichier_bak)
return data
def OnBoutonExporterCodes(self, event):
wildcard = _(u"Paramétrage fichier réseau Noethys (*.nnc)|*.nnc|Tous les fichiers (*.*)|*.*")
sp = wx.StandardPaths.Get()
dlg = wx.FileDialog(
self, message=_(u"Choisissez un fichier à importer"),
defaultDir=sp.GetDocumentsDir(),
defaultFile="",
wildcard=wildcard,
style=wx.FD_SAVE
)
if dlg.ShowModal() == wx.ID_OK:
nomFichierCourt = dlg.GetFilename()
nomFichierLong = dlg.GetPath()
dlg.Destroy()
data = {
"host": self.ctrl_hote.GetValue(),
"user": self.ctrl_utilisateur.GetValue(),
"pwd": self.ctrl_motdepasse.GetValue(),
"port": self.ctrl_port.GetValue(),
}
UTILS_Json.Ecrire(nomFichierLong, data=data)
else:
dlg.Destroy()
return
return
def GetTracks(self):
""" Récupération des données """
# Récupération des textes originaux
dictTextes = {}
data = UTILS_Json.Lire(Chemins.GetStaticPath("Databases/Textes.dat"),
conversion_auto=True)
for texte, listeFichiers in data.items():
dictTextes[texte] = listeFichiers
# Récupération des traductions existantes
dictTraductionsInitiales, dictTraductionsPerso = self.GetTraductionsExistantes(
)
# Regroupement des prestations par label
listeListeView = []
for texte, listeFichiers in dictTextes.items():
traduction_initiale = ""
traduction_perso = ""
if texte in dictTraductionsInitiales:
traduction_initiale = dictTraductionsInitiales[texte]
if texte in dictTraductionsPerso:
traduction_perso = dictTraductionsPerso[texte]
dictDonnees = {
"texte": texte,
"traduction_initiale": traduction_initiale,
"traduction_perso": traduction_perso,
"listeFichiers": listeFichiers
}
track = Track(dictDonnees)
track.MAJ()
listeListeView.append(track)
return listeListeView
def SetDictConfig(self, dictConfig={}):
""" Remplace le fichier de config présent sur le disque dur par le dict donné """
UTILS_Json.Ecrire(nom_fichier=self.nomFichier, data=dictConfig)
# Création d'une copie de sauvegarde du config
nom_fichier_bak = self.nomFichier + ".bak"
if not os.path.isfile(nom_fichier_bak) or random.randint(0, 5) == 0:
shutil.copyfile(self.nomFichier, nom_fichier_bak)
def Enregistrer(self, fichier=""):
data = {
"categorie": self.categorie,
"contenu": self.contenu,
}
if six.PY2:
fichier = fichier.encode("iso-8859-15")
UTILS_Json.Ecrire(nom_fichier=fichier, data=data)
def InfosFichier(fichier=""):
""" Récupère les infos principales sur un fichier """
if os.path.isfile(fichier) == False:
print("Pas de fichier a cet emplacement !")
return None
if six.PY2:
fichier = fichier.encode("iso-8859-15")
data = UTILS_Json.Lire(fichier)
return data
def Importer(fichier="", dictDonnees={}, IDfond=None, defaut=0):
""" Importation d'un modèle de document depuis un fichier JSON ou un DICTIONNAIRE """
DB = GestionDB.DB()
if fichier != "":
if six.PY2:
fichier = fichier.encode("iso-8859-15")
data = UTILS_Json.Lire(fichier)
else:
data = dictDonnees
# Saisie dans la table documents_modeles
listeDonnees = [
("nom", data["nom"]),
("categorie", data["categorie"]),
("supprimable", 1),
("largeur", data["largeur"]),
("hauteur", data["hauteur"]),
("observations", ""),
("IDfond", IDfond),
("defaut", defaut),
]
IDmodele = DB.ReqInsert("documents_modeles", listeDonnees)
# Saisie dans la table documents_objets
listeObjets = data["objets"]
for dictObjet in listeObjets:
dictObjet["IDmodele"] = IDmodele
listeDonnees = []
for champ, donnee in dictObjet.items():
if champ == "image":
try:
donnee = base64.b64decode(donnee)
except:
pass
blob = donnee
donnee = None
listeDonnees.append((champ, donnee))
IDobjet = DB.ReqInsert("documents_objets", listeDonnees)
if blob != None:
DB.MAJimage(table="documents_objets",
key="IDobjet",
IDkey=IDobjet,
blobImage=blob,
nomChampBlob="image")
DB.Close()
return IDmodele
def GetTraductionsExistantes(self):
""" Recherche le fichier de langage par défaut ".lang" puis un éventuel fichier perso ".xlang" """
if self.code == None: return {}, {}
dictTraductionsInitiales = {}
dictTraductionsPerso = {}
for extension, rep, dictTemp in [
("lang", Chemins.GetStaticPath("Lang"), dictTraductionsInitiales),
("xlang", UTILS_Fichiers.GetRepLang(), dictTraductionsPerso)
]:
nomFichier = os.path.join(rep, u"%s.%s" % (self.code, extension))
if os.path.isfile(nomFichier):
data = UTILS_Json.Lire(nomFichier, conversion_auto=True)
for key, valeur in data.items():
dictTemp[key] = valeur
return dictTraductionsInitiales, dictTraductionsPerso
def __init__(self, parent):
wx.Panel.__init__(self, parent, id=-1, style=wx.TAB_TRAVERSAL)
self.staticbox_staticbox = wx.StaticBox(self, -1, _(u"Interface*"))
# Thème
self.liste_labels_theme = []
self.liste_codes_theme = []
for code, label in UTILS_Interface.THEMES :
self.liste_labels_theme.append(label)
self.liste_codes_theme.append(code)
self.label_theme = wx.StaticText(self, -1, _(u"Thème :"))
self.ctrl_theme = wx.Choice(self, -1, choices=self.liste_labels_theme)
self.ctrl_theme.SetSelection(0)
# Langue
self.liste_labels_langue = [u"Français (par défaut)",]
self.liste_codes_langue = [None,]
for rep in (Chemins.GetStaticPath("Lang"), UTILS_Fichiers.GetRepLang()) :
for nomFichier in os.listdir(rep) :
if nomFichier.endswith("lang") :
code, extension = nomFichier.split(".")
data = UTILS_Json.Lire(os.path.join(rep, nomFichier), conversion_auto=True)
dictInfos = data["###INFOS###"]
nom = dictInfos["nom_langue"]
code = dictInfos["code_langue"]
if code not in self.liste_codes_langue :
self.liste_codes_langue.append(code)
self.liste_labels_langue.append(nom)
self.label_langue = wx.StaticText(self, -1, _(u"Langue :"))
self.ctrl_langue = wx.Choice(self, -1, choices=self.liste_labels_langue)
self.ctrl_langue.SetSelection(0)
self.__set_properties()
self.__do_layout()
# Init
self.Importation()
def OnBoutonOk(self, event):
# Récupération des paramètres
nom_langue = self.ctrl_nom_langue.GetValue()
code_langue = self.ctrl_code_langue.GetValue()
# Récupération des traductions perso
dictTraductions = self.ctrl_traductions.GetDictTraductionsPerso()
# Création du fichier de traduction perso
nomFichier = UTILS_Fichiers.GetRepLang(u"%s.xlang" % code_langue)
data = {}
data["###INFOS###"] = {
"nom_langue": nom_langue,
"code_langue": code_langue
}
for texte, traduction in dictTraductions.items():
data[texte] = traduction
UTILS_Json.Ecrire(nomFichier, data=data)
# Fermeture
self.EndModal(wx.ID_OK)
def MAJ(self):
self.listeLabels = []
self.listeDonnees = []
# Recherche les fichiers de langues existants
listeCodes = []
for rep in (Chemins.GetStaticPath("Lang"),
UTILS_Fichiers.GetRepLang()):
for nomFichier in os.listdir(rep):
if nomFichier.endswith("lang"):
code, extension = nomFichier.split(".")
data = UTILS_Json.Lire(os.path.join(rep, nomFichier),
conversion_auto=True)
# Lecture des caractéristiques
dictInfos = data["###INFOS###"]
nom = dictInfos["nom_langue"]
code = dictInfos["code_langue"]
# Lecture des textes
listeTextes = []
for texte, traduction in data.items():
if texte != "###INFOS###":
listeTextes.append(texte)
label = u"%s (%s)" % (nom, code)
if code not in listeCodes:
listeCodes.append(code)
self.listeLabels.append(label)
self.listeDonnees.append({
"nom": nom,
"code": code,
"textes": listeTextes
})
# Remplissage du contrôle
if len(self.listeLabels) == 0:
self.Enable(False)
self.SetItems(self.listeLabels)
def InfosFichier(fichier=""):
""" Récupère les infos principales sur un fichier """
if six.PY2:
fichier = fichier.encode("iso-8859-15")
data = UTILS_Json.Lire(fichier)
return data
def Exporter(IDmodele=None, fichier="", depuisFichierDefaut=False):
""" Exportation d'un modèle de document """
# Ouverture Base
if depuisFichierDefaut == False:
DB = GestionDB.DB()
else:
DB = GestionDB.DB(
nomFichier=Chemins.GetStaticPath("Databases/Defaut.dat"),
suffixe=None)
# Récupération des infos sur le modèle
req = """SELECT nom, categorie, largeur, hauteur, IDfond, defaut
FROM documents_modeles
WHERE IDmodele=%d
;""" % IDmodele
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
nom, categorie, largeur, hauteur, IDfond, defaut = listeDonnees[0]
# Récupération des champs de la table des objets
listeColonnes = DB.GetListeChamps2("documents_objets")
listeChamps = []
for nomChamp, typeChamp in listeColonnes:
listeChamps.append(nomChamp)
# Récupération des données à exporter
req = """SELECT %s
FROM documents_objets
WHERE IDmodele=%d
;""" % (", ".join(listeChamps), IDmodele)
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
# Fermeture Base
DB.Close()
# Mémorisation des objets
listeObjets = []
for donnees in listeDonnees:
dictObjet = {}
index = 0
for donnee in donnees:
nomChamp = listeColonnes[index][0]
typeChamp = listeColonnes[index][1]
# Pour les champs BLOB
if "BLOB" in typeChamp.upper() and donnee != None:
buffer = six.BytesIO(donnee)
donnee = buffer.read()
if nomChamp == "image" and donnee != None:
donnee = base64.b64encode(donnee)
# Mémorisation
if nomChamp not in ("IDmodele", "IDobjet"):
dictObjet[nomChamp] = donnee
index += 1
listeObjets.append(dictObjet)
# Mémorisation dans un dict
data = {
"nom": nom,
"categorie": categorie,
"largeur": largeur,
"hauteur": hauteur,
"IDfond": IDfond,
"defaut": defaut,
"objets": listeObjets,
}
# Enregistrement dans un fichier Json
if fichier != "":
if six.PY2:
fichier = fichier.encode("iso-8859-15")
UTILS_Json.Ecrire(nom_fichier=fichier, data=data)
return data
def SetDictConfig(self, dictConfig={}):
""" Remplace le fichier de config présent sur le disque dur par le dict donné """
UTILS_Json.Ecrire(nom_fichier=self.nomFichier, data=dictConfig)
# Création d'une copie de sauvegarde du config
shutil.copyfile(self.nomFichier, self.nomFichier + ".bak")
def OnBoutonImporter(self, event):
# Récupération de la langue
dictLangue = self.ctrl_langues.GetCode()
if dictLangue == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez sélectionner une langue dans la liste !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
nom_langue = dictLangue["nom"]
code_langue = dictLangue["code"]
textes_langue = dictLangue["textes"]
# Récupération des fichiers
fichier_original = self.ctrl_fichier_importer_original.GetValue()
if fichier_original == "":
dlg = wx.MessageDialog(
self,
_(u"Vous devez sélectionner un fichier de textes originaux !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
fichier_traduction = self.ctrl_fichier_importer_traduction.GetValue()
if fichier_traduction == "":
dlg = wx.MessageDialog(
self,
_(u"Vous devez sélectionner un fichier de textes traduits !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Lecture des textes
fichier = open(fichier_original, "r")
lignesOriginal = fichier.readlines()
fichier.close()
fichier = open(fichier_traduction, "r")
lignesTraduction = fichier.readlines()
fichier.close()
if len(lignesOriginal) != len(lignesTraduction):
dlg = wx.MessageDialog(
self,
_(u"Le nombre de lignes des deux fichiers doit être identique !"
), _(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
# Demande de confirmation
dlg = wx.MessageDialog(
None,
_(u"Confirmez-vous l'insertion de %d textes traduits dans le fichier '%s' ?"
) % (len(lignesOriginal), nom_langue), "Confirmation",
wx.YES_NO | wx.YES_DEFAULT | wx.ICON_EXCLAMATION)
if dlg.ShowModal() == wx.ID_NO:
return False
dlg.Destroy()
else:
dlg.Destroy()
# Fusion des traductions
dictTraductions = {}
indexLigne = 0
for texte in lignesOriginal:
if len(texte) > 0:
dictTraductions[texte[:-1]] = lignesTraduction[indexLigne][:-1]
indexLigne += 1
# Création du fichier de traduction perso
nomFichier = UTILS_Fichiers.GetRepLang(u"%s.xlang" % code_langue)
data = {}
data["###INFOS###"] = {
"nom_langue": nom_langue,
"code_langue": code_langue
}
for texte, traduction in dictTraductions.items():
data[texte] = traduction
UTILS_Json.Ecrire(nomFichier, data=data)
# Confirmation
dlg = wx.MessageDialog(
self,
_(u"L'importation des traductions s'est déroulée avec succès !"
), _(u"Succès"), wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()
def OnBoutonExporter(self, event):
# Récupération de la langue
dictLangue = self.ctrl_langues.GetCode()
if dictLangue == None:
dlg = wx.MessageDialog(
self,
_(u"Vous devez sélectionner une langue dans la liste !"),
_(u"Erreur"), wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
dlg.Destroy()
return
nom = dictLangue["nom"]
textesLangue = dictLangue["textes"]
# Demande à l'utilisateur le nom de fichier et le répertoire de destination
nom_fichier = u"Textes_originaux.txt"
wildcard = u"Fichier Texte (*.txt)|*.xml| Tous les fichiers (*.*)|*.*"
sp = wx.StandardPaths.Get()
cheminDefaut = sp.GetDocumentsDir()
dlg = wx.FileDialog(
None,
message=
_(u"Veuillez sélectionner le répertoire de destination et le nom du fichier"
),
defaultDir=cheminDefaut,
defaultFile=nom_fichier,
wildcard=wildcard,
style=wx.FD_SAVE)
dlg.SetFilterIndex(0)
if dlg.ShowModal() == wx.ID_OK:
cheminFichier = dlg.GetPath()
dlg.Destroy()
else:
dlg.Destroy()
return
# Le fichier de destination existe déjà :
if os.path.isfile(cheminFichier) == True:
dlg = wx.MessageDialog(
None,
_(u"Un fichier portant ce nom existe déjà. \n\nVoulez-vous le remplacer ?"
), "Attention !",
wx.YES_NO | wx.NO_DEFAULT | wx.ICON_EXCLAMATION)
if dlg.ShowModal() == wx.ID_NO:
return False
dlg.Destroy()
else:
dlg.Destroy()
# Lecture du fichier dat
data = UTILS_Json.Lire(Chemins.GetStaticPath("Databases/Textes.dat"),
conversion_auto=True)
listeTextes = []
for texte, listeFichiers in data.items():
listeTextes.append(texte)
listeTextes.sort()
# Enregistrement du fichier texte
fichier = open(cheminFichier, "w")
nbreTextes = 0
for texte in listeTextes:
if self.check_nontraduits.GetValue() == False or (
self.check_nontraduits.GetValue() == True
and texte not in textesLangue):
fichier.write(texte + "\n")
nbreTextes += 1
fichier.close()
# Confirmation fin
dlg = wx.MessageDialog(
self,
_(u"Le fichier a été généré avec succès (%d textes) !") %
nbreTextes, _(u"Génération"), wx.OK | wx.ICON_INFORMATION)
dlg.ShowModal()
dlg.Destroy()