def MakeStatusText(self):
cfgU = xucfg.ParamUser()
self.config = cfgU.SetDict(self.dictAppli, groupe='APPLI')
# appel de la configuration base de données dans paramFile
cfgF = xucfg.ParamFile()
grpCONFIGS = cfgF.GetDict(dictDemande=None, groupe='CONFIGS')
nomAppli = self.dictAppli['NOM_APPLICATION']
nomConfig = ''
if 'choixConfigs' in grpCONFIGS:
if nomAppli and nomAppli in grpCONFIGS['choixConfigs'].keys():
if 'lastConfig' in grpCONFIGS['choixConfigs'][nomAppli].keys():
nomConfig = grpCONFIGS['choixConfigs'][nomAppli][
'lastConfig']
messBD = "données: '%s'" % (nomConfig)
self.nomVersion = "%s %s" % (self.dictAppli['NOM_APPLICATION'],
xaccueil.GetVersion(self))
self.messageStatus = "%s | %s" % (self.nomVersion, messBD)
if hasattr(self, 'dictUser') and self.dictUser:
self.messageStatus += ", Utilisateur: %s" % (
self.dictUser['utilisateur'])
else:
self.messageStatus += ", Utilisateur non identifié"
if hasattr(self, 'infoStatus'):
self.messageStatus += " | %s" % (self.infoStatus)
self.SetStatusText(self.messageStatus)
def GetOneConfig(self, nomConfig='lastConfig', mute=False):
# appel d'une configuration nommée, retourne le dict des params
cfg = xucfg.ParamFile()
grpCONFIGS = cfg.GetDict(groupe='CONFIGS')
cfg = xucfg.ParamUser()
grpAPPLI = cfg.GetDict(groupe='APPLI')
nomAppli = ''
if 'NOM_APPLICATION' in grpAPPLI.keys():
nomAppli = grpAPPLI['NOM_APPLICATION']
if nomConfig == 'lastConfig':
# recherche du nom de configuration par défaut, cad la dernière des choix
if 'choixConfigs' in grpCONFIGS:
if nomAppli in grpCONFIGS['choixConfigs'].keys():
if 'lastConfig' in grpCONFIGS['choixConfigs'][nomAppli].keys():
nomConfig = grpCONFIGS['choixConfigs'][nomAppli][
'lastConfig']
typeConfig = 'db_reseau'
if 'TYPE_CONFIG' in grpAPPLI:
typeConfig = grpAPPLI['TYPE_CONFIG']
if 'lstConfigs' in grpCONFIGS:
lstNomsConfigs = [
x[typeConfig]['ID'] for x in grpCONFIGS['lstConfigs']
]
if not (nomConfig in lstNomsConfigs):
mess = "xDB: Le nom de config '%s' n'est pas dans la liste des accès base de donnée" % (
nomConfig)
self.erreur = mess
if not mute:
wx.MessageBox(mess)
return mess
ix = lstNomsConfigs.index(nomConfig)
# on récupére les paramétres de la config par le pointeur ix dans les clés
return grpCONFIGS['lstConfigs'][ix][typeConfig]
def OnFermer(self, event):
cfgF = xshelve.ParamFile()
cfgF.SetDict({'lstConfigs': self.lstConfigsKO + self.lddDonnees},
'CONFIGS')
if self.IsModal():
self.EndModal(wx.OK)
else:
self.Close()
def GetConfigs():
# appel des params de connexion stockés dans UserProfile et data
cfg = xucfg.ParamUser()
grpUSER = cfg.GetDict(groupe='USER', close=False)
grpAPPLI = cfg.GetDict(groupe='APPLI')
# appel des params de connexion stockés dans Data
cfg = xucfg.ParamFile()
grpCONFIGS = cfg.GetDict(groupe='CONFIGS')
return grpAPPLI, grpUSER, grpCONFIGS
def Init(self):
# choix de la configuration prise dans paramUser
self.paramsFile = xshelve.ParamFile(nomFichier=self.nomFichier,
path=self.pathData)
self.dicParams = self.paramsFile.GetDict(dictDemande=None,
groupe=self.nomGroupe,
close=False)
if self.dicParams:
# pose dans la grille la valeur de les dernières valeurs utilisées
self.SetValues(self.dicParams)
def GetIDcomptaDefaut():
# recherche le nom de la compta pointée par la gestion des bases et proposée par défaut
paramFile = xshelve.ParamFile(nomFichier="Config")
IDcompta = None
dicConfig = paramFile.GetDict(None, 'CONFIGS')
if 'choixConfigs' in dicConfig:
if 'Noelite' in dicConfig['choixConfig']:
if 'compta.config' in dicConfig['choixConfig']['compta.config']:
IDcompta = dicConfig['choixConfig']['compta.config'][
'compta.config']
return IDcompta
def SauveConfig(self):
# sauve les configs sur appli/data local
dicconfigs = {}
value = "Non défini"
for ctrl in self.lstChoixConfigs:
value = ctrl.GetOneValue(ctrl.Name)
dicconfigs[ctrl.Name] = value
dicconfigs['lastConfig'] = value
self.lastConfig = value
#récupère l'ensemble des choix existants antérieurement
cfgF = xshelve.ParamFile()
grpConfigs = cfgF.GetDict(groupe='CONFIGS', close=False)
dicchoix = grpConfigs.pop('choixConfigs', {})
# actualise seulement ceux de l'application
dicchoix[self.nomAppli] = dicconfigs
grpConfigs['choixConfigs'] = dicchoix
cfgF.SetDict(grpConfigs, groupe='CONFIGS')
def __init__(self, parent, typeConfig=None, **kwds):
select = kwds.pop('select', None)
kwds['lblList'] = "Configurations actuelles"
super().__init__(parent, **kwds)
if not typeConfig: typeConfig = parent.dictAppli['TYPE_CONFIG']
self.parent = parent
self.dlColonnes = {}
self.lddDonnees = []
self.lstIDconfigsOK = []
self.lstConfigsKO = []
self.dldMatrice = {}
self.typeConfig = typeConfig
# composition des paramètres
self.gestionProperty = False
self.ok = False
self.DB = None
cle = GetCleMatrice(typeConfig, MATRICE_CONFIGS)
self.dldMatrice[cle] = MATRICE_CONFIGS[cle]
self.dlColonnes[typeConfig] = [x['name'] for x in MATRICE_CONFIGS[cle]]
cfgF = xshelve.ParamFile()
grpConfigs = cfgF.GetDict(None, 'CONFIGS')
if 'lstConfigs' in grpConfigs:
self.lstIDconfigsOK, lstConfigsOK, lstConfigsKO = GetLstConfigs(
grpConfigs, typeConfig)
self.lddDonnees = lstConfigsOK
# paramètres pour self.pnl contenu principal de l'écran
self.kwds['lblTopBox'] = ''
self.Size = (400, 300)
if self.dldMatrice != {}:
self.InitDlgGestion()
self.dlgGest.SetSize(350, 400)
self.dlgGest.btn = self.Boutons(self.dlgGest)
self.SizerDlgGestion()
self.Init()
self.ok = True
if 'lstConfigs' in grpConfigs:
if select in self.lstIDconfigsOK:
ix = self.lstIDconfigsOK.index(select)
self.pnl.ctrl.Select(ix)
self.pnl.ctrl.SetItemState(ix, wx.LIST_STATE_SELECTED,
wx.LIST_STATE_SELECTED)
self.InitDlGest()
def GetConfig(self, nomCompta):
# recherche des configuration d'accès aux base de données clé 'db_reseau'
paramFile = xshelve.ParamFile(nomFichier="Config")
self.IDconfigCpta = None
dicConfig = paramFile.GetDict(None, 'CONFIGS')
IDconfig = None
cfgCompta = None
if 'choixConfigs' in dicConfig:
if 'Noelite' in dicConfig['choixConfigs']:
if 'Compta.config' in dicConfig['choixConfigs']['Noelite']:
IDconfig = dicConfig['choixConfigs']['Noelite'][
'Compta.config']
if not IDconfig:
mess = "Aucune base de compta n'est définie par la gestion du menu_fichier!"
wx.MessageBox(mess, style=wx.ID_ABORT)
return
# transposition entre les noms de configs et les possibilités de la matrice
if nomCompta == 'quadra' and 'quad' in IDconfig.lower():
# quadratus était par défaut
cfgCompta = xgc.GetDdConfig(dicConfig, IDconfig)['db_reseau']
elif nomCompta == 'noegest' and not 'quad' in IDconfig.lower():
# on prend la compta par défaut
cfgCompta = xgc.GetDdConfig(dicConfig, IDconfig)['db_reseau']
else:
# on tente une recherche directe dans la liste de configs présentes
lstConfigs = xgc.GetLstConfigs(dicConfig)
lstConfigsOK = lstConfigs[1]
lstNoms = [x['db_reseau']['ID'] for x in lstConfigsOK]
if nomCompta in lstNoms:
ix = lstNoms.index(nomCompta)
IDconfig = lstConfigsOK[ix]['db_reseau']['ID']
cfgCompta = xgc.GetDdConfig(dicConfig, IDconfig)['db_reseau']
if not cfgCompta:
wx.MessageBox(
"Impossible de trouver la configuration correspondant à %s" %
nomCompta)
return cfgCompta
def __init__(self, parent, **kwds):
typeConfig = kwds.pop('typeConfig', None)
nomConfig = kwds.pop('nomConfig', None)
lblBox = kwds.pop('lblBox', "Paramètres de la base de donnée")
modeBase = kwds.pop('modeBase', 'pointeur')
kwds['size'] = (350, 430)
super().__init__(parent, **kwds)
self.modeBase = modeBase
self.DB = None
# récup info de l'utilisateur de la session
cfg = xshelve.ParamUser()
dicUser = cfg.GetDict(dictDemande=None, groupe='USER')
mess = "Accès aux ParamUser"
try:
# vérif des droits
if modeBase == 'creation':
mess = "Echec de la vérification des droits de création"
if dicUser['profil'] != 'administrateur':
mess += "\n\n%s de profil %s n'est pas administrateur!" % (
dicUser['utilisateur'], dicUser['profil'])
raise (mess)
mess = None
except:
wx.MessageBox(mess, "xGestionConfig.DLG_saisieUneConfig")
if mess:
self.Destroy()
# choix de la configuration prise dans paramFile
cfgF = xshelve.ParamFile()
grpConfigs = cfgF.GetDict(dictDemande=None, groupe='CONFIGS')
# les choix de config sont stockés par application car Data peut être commun à plusieurs
if parent and hasattr(parent, 'dictAppli'):
dictAppli = self.parent.dictAppli
else:
cfg = xshelve.ParamUser()
dictAppli = cfg.GetDict(dictDemande=None, groupe='APPLI')
nomAppli = dictAppli['NOM_APPLICATION']
# récup des données à afficher après construction
choixConfigs = grpConfigs['choixConfigs'][nomAppli]
if 'lastConfig' in choixConfigs:
lastConfig = choixConfigs['lastConfig']
else:
lastConfig = None
ddConfig = GetDdConfig(grpConfigs, lastConfig)
# récup de la matrice ayant servi à la gestion des données
if not typeConfig:
lstcode = GetLstCodesMatrice(MATRICE_CONFIGS)
typeConfig = lstcode[0]
key = (typeConfig, lblBox)
matrice = {
key: MATRICE_CONFIGS[GetCleMatrice(typeConfig, MATRICE_CONFIGS)]
}
self.typeConfig = typeConfig
# ajustement de la matrice selon les modeBase
ixID = GetIxLigneMatrice('nameDB', matrice[key])
if self.modeBase == 'pointeur':
matrice[key][ixID] = {
'name': 'nameDB',
'genre': 'combo',
'label': 'Nom de la Base',
'help':
"Le nom de la base est le fichier en local, ou son nom sur le serveur",
'ctrlAction': 'OnNameDB',
}
elif self.modeBase == 'creation':
matrice[key][ixID] = {
'name': 'nameDB',
'genre': 'texte',
'label': 'Nom de la Base',
'help':
"Choisir un base de donnée non présente sur le serveur ou fichier non existant",
'ctrlAction': 'OnNameDB',
}
# place la valeur du champ ID
exist = False
if nomConfig:
ixID = GetIxLigneMatrice('ID', matrice[key])
matrice[key][ixID]['value'] = nomConfig
# construction de l'écran de saisie
self.pnl = xusp.TopBoxPanel(self, matrice=matrice, lblTopBox=None)
if self.typeConfig in ddConfig.keys() and nomConfig == ddConfig[
self.typeConfig]['ID']:
self.pnl.SetValues(ddConfig)
# grise le champ ID
ctrlID = self.pnl.GetPnlCtrl('ID')
ctrlID.Enable(False)
if self.modeBase in ('creation', 'pointeur'):
titre = "Création d'une nouvelle base de données"
texte = "Définissez les pointeurs d'accès et le nom de la base à y créer\n"
texte += "le mot de passe présenté sera celui des 'Accès aux bases de données'"
else:
titre = "Définition de la base de données"
texte = "Définissez les pointeurs d'accès et le nom de la base souhaitée\n"
texte += "l'éventuel mot de passe présenté sera celui des 'Accès aux bases de données'"
# personnalisation des éléments de l'écran
self.bandeau = xbandeau.Bandeau(
self,
titre=titre,
texte=texte,
nomImage='xpy/images/32x32/Configuration.png')
self.btn = self.Boutons(self)
# layout
self.Sizer(self.pnl)
def __init__(self, parent, **kwds):
style = kwds.pop('style', wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
size = kwds.pop('size', (400, 430))
self.typeConfig = kwds.pop('typeConfig', None)
listArbo = os.path.abspath(__file__).split("\\")
titre = listArbo[-1:][0] + "/" + self.__class__.__name__
wx.Dialog.__init__(self,
parent,
-1,
title=titre,
style=style,
size=size)
self.parent = parent
# Récup du code de la description des champs pour une configuration
lstcode = GetLstCodesMatrice(MATRICE_CONFIGS)
if not self.typeConfig:
self.typeConfig = lstcode[0]
if self.parent and 'TYPE_CONFIG' in self.parent.dictAppli:
self.typeConfig = self.parent.dictAppli['TYPE_CONFIG']
if not (self.typeConfig in lstcode):
wx.MessageBox("L'option '%s' n'est pas dans MATRICECONFIGS " %
(self.typeConfig))
ddDonnees = {}
valeurs = {}
ident = None
# Bouton sortie de pied d'écran
self.btnTest = xboutons.BTN_tester(self)
self.btn = xboutons.BTN_fermer(self)
# IDENT : appel de l'identification IDENT partie grisée -----------------------------------------------------
try:
utilisateur = self.parent.dictUser['utilisateur']
except:
utilisateur = None
for (code, label), lignes in MATRICE_IDENT.items():
for ligne in lignes:
if ligne['name'].lower() in ('username', 'user'):
valeurs[ligne['name']] = os.environ['USERNAME']
ident = code
if ligne['name'].lower() in ('userdomain', 'domaine',
'workgroup'):
try:
valeurs[ligne['name']] = os.environ['USERDOMAIN']
except:
import platform
valeurs[ligne['name']] = platform.node()
if ligne['name'].lower() in ('utilisateur', ):
valeurs[ligne['name']] = utilisateur
ident = code
self.ctrlID = xusp.CTRL_property(self,
matrice=MATRICE_IDENT,
enable=False)
if ident:
ddDonnees[ident] = valeurs
self.ctrlID.SetValues(ddDonnees=ddDonnees)
# recherche dans profilUser ----------------------------------------------------------------------------------
cfg = xshelve.ParamUser()
# lecture des valeurs préalablement utilisées
choixUser = cfg.GetDict(dictDemande=None, groupe='USER', close=True)
dictAppli = cfg.GetDict(dictDemande=None, groupe='APPLI')
if dictAppli == {}:
dictAppli = self.parent.dictAppli
self.nomAppli = dictAppli['NOM_APPLICATION']
# CONFIGS : appel du modèle des configurations ----------------------------------------------------------------
codeBox, labelBox, lignes = xformat.AppelLignesMatrice(
None, MATRICE_CHOIX_CONFIG)
# Composition des choix de configurations selon l'implantation
self.lstChoixConfigs = []
if self.parent and 'CHOIX_CONFIGS' in self.parent.dictAppli:
lstchoix = self.parent.dictAppli['CHOIX_CONFIGS']
for codeBox, labelBox in lstchoix:
self.lstChoixConfigs.append(
ChoixConfig(self, labelBox, codeBox, lignes, {}))
else:
# le nom de la configuration c'est le premier champ décrit dans la matrice
self.lstChoixConfigs.append(
ChoixConfig(self, labelBox, codeBox, lignes, {}))
# choix de la configuration prise dans paramFile
cfgF = xshelve.ParamFile()
grpConfigs = cfgF.GetDict(dictDemande=None, groupe='CONFIGS')
# filtrage des des configs selon type retenu
self.lstIDconfigsOK, self.lstConfigsOK, self.lstConfigsKO = GetLstConfigs(
grpConfigs, self.typeConfig)
ddchoixConfigs = grpConfigs.pop('choixConfigs', {})
# les choix de config sont stockés par application car Data peut être commun à plusieurs
if not (self.nomAppli in ddchoixConfigs):
ddchoixConfigs[self.nomAppli] = {}
choixConfigs = ddchoixConfigs[self.nomAppli]
# alimente la liste des choix possibles
for ctrlConfig in self.lstChoixConfigs:
ctrlConfig.SetOneSet(ctrlConfig.Name, self.lstIDconfigsOK)
if ctrlConfig.Name in choixConfigs:
ctrlConfig.SetOneValue(ctrlConfig.Name,
choixConfigs[ctrlConfig.Name])
# last config sera affichée en 'Fermer' si pas modifiée
if 'lastConfig' in choixConfigs:
self.lastConfig = choixConfigs['lastConfig']
else:
self.lastConfig = ''
# SEPARATEUR : simple texte
self.titre = wx.StaticText(self, -1, "Eléments de connexion")
self.Sizer()
