def GetListeUsers():
""" Récupère la liste des utilisateurs et de leurs droits """
DB = xdb.DB()
if DB.echec:
return False
# Droits
req = """SELECT IDdroit, IDutilisateur, IDmodele, categorie, action, etat
FROM droits;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
dictDroitsUtilisateurs = {}
dictDroitsModeles = {}
for IDdroit, IDutilisateur, IDmodele, categorie, action, etat in listeDonnees:
key = (categorie, action)
if IDutilisateur != None:
if not IDutilisateur in dictDroitsUtilisateurs:
dictDroitsUtilisateurs[IDutilisateur] = {}
dictDroitsUtilisateurs[IDutilisateur][key] = etat
if IDmodele != None:
if not IDmodele in dictDroitsModeles:
dictDroitsModeles[IDmodele] = {}
dictDroitsModeles[IDmodele][key] = etat
# Utilisateurs
req = """SELECT IDutilisateur, sexe, nom, prenom, mdp, profil, actif
FROM utilisateurs
WHERE actif=1;"""
DB.ExecuterReq(req)
listeDonnees = DB.ResultatReq()
listeUtilisateurs = []
for IDutilisateur, sexe, nom, prenom, mdp, profil, actif in listeDonnees:
droits = None
if profil.startswith("administrateur"):
droits = None
if profil.startswith("modele"):
IDmodele = int(profil.split(":")[1])
if IDmodele in dictDroitsModeles:
droits = dictDroitsModeles[IDmodele]
if profil.startswith("perso"):
if IDutilisateur in dictDroitsUtilisateurs:
droits = dictDroitsUtilisateurs[IDutilisateur]
dictTemp = {
"IDutilisateur": IDutilisateur,
"nom": nom,
"prenom": prenom,
"sexe": sexe,
"mdp": mdp,
"profil": profil,
"actif": actif,
"droits": droits
}
listeUtilisateurs.append(dictTemp)
DB.Close()
return listeUtilisateurs
def GetGI(self):
# pointer la gestion interne
DBgi = None
if self.config['compta'] == 'quadratus':
configGI = {}
configGI['typeDB'] = 'access'
configGI['serveur'] = self.config['serveur']
configGI['nameDB'] = 'qgi.mdb'
configGI['serveur'].replace('datadouble', 'database')
DBgi = xdb.DB(config=configGI)
if DBgi.echec == 1: DBgi = None
return DBgi
def __init__(self, parent, dicOlv={}, **kwds):
self.parent = parent
largeur = dicOlv.pop("largeur", 800)
hauteur = dicOlv.pop("hauteur", 700)
self.db = kwds.pop("db", xdb.DB())
pnlTableau = dicOlv.pop("pnlTableau", PNL_tableau)
listArbo = os.path.abspath(__file__).split("\\")
titre = listArbo[-1:][0] + "/" + self.__class__.__name__
wx.Dialog.__init__(self,
None,
title=titre,
size=(largeur, hauteur),
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
self.SetBackgroundColour(wx.WHITE)
self.marge = 10
self.pnl = pnlTableau(self, dicOlv, **kwds)
self.ctrlOlv = self.pnl.ctrlOlv
self.CenterOnScreen()
def __init__(self, parent, title='', bases=('gi', 'sql')):
self.parent = parent
self.title = title + '[UTIL_import].ImportComptas'
self.mono, self.topwin = False, False
self.filieres = ''
try:
self.topWindow = wx.GetApp().GetTopWindow()
if self.topWindow:
self.topwin = True
self.topWindow.Size = (1300, 300)
self.topWindow.pos = (200, 500)
except Exception as err:
pass
#récup des arguments stockés dans le shelve
cfg = xucfg.ParamUser()
implantation = cfg.GetDict(dictDemande=None,
groupe='IMPLANTATION',
close=False)
choiximport = cfg.GetDict(dictDemande=None,
groupe='IMPORT',
close=False)
user = cfg.GetDict(dictDemande=None, groupe='USER')
ident = cfg.GetDict(dictDemande=None, groupe='IDENT')
self.config = {}
for groupe in [implantation, choiximport, user, ident]:
for key, value in groupe.items():
self.config[key] = value
#ouverture des bases communes GI et OpenRef en s'appuyant sur le self.config(dict)
if 'gi' in bases:
self.DBgi = self.GetGI()
# ouverture base principale ( ouverture par défaut de db_prim via xGestionDB)
self.DBsql = xdb.DB()
self.lstMotsProd = self.GetMotsCle('mProduits')
self.lstMotsCout = self.GetMotsCle('mCoûts')
self.dicPlanComp = orut.PrechargePlanCompte(self.DBsql)
def HorsPeriode(self, configCPTA, annee, nbAnter, lstNafs):
nomBase = None
# vérif du connecteur par recherche du nom de la base
try:
DBq = xdb.DB(config=configCPTA)
nomBase = DBq.nomBase
if DBq.echec != 0:
mess = self.title + ": " + DBq.echec
nomBase = None
wx.MessageBox(mess)
except Exception as err:
DBq.Close()
return True
retour = True
if nomBase:
# import des infos de l'exercice et naf dans la compta
if self.config['compta'] == 'quadratus':
req = """SELECT Dossier1.FinExercice, Dossier1.CodeNAF
FROM Dossier1;"""
retour = DBq.ExecuterReq(req,
mess='accès Qcompta.dossier quadra')
if retour == "ok":
recordset = DBq.ResultatReq()
exercice, naf = recordset[0]
#controle du naf si filtre posé
if lstNafs:
if not naf.upper().strip() in lstNafs:
DBq.Close()
return True
anex = int(str(exercice)[:4])
anchoix = int(annee)
for i in range(0, int(nbAnter) + 1):
if anex == anchoix - i:
retour = False
DBq.Close()
return retour
def __init__(self,
analyse=None,
annee=None,
nbanter=0,
client=None,
groupe=None,
filiere=None,
gestable=None,
agc=None):
# recherche pour affichage bas d'écran
self.topwin = False
self.topWindow = wx.GetApp().GetTopWindow()
if self.topWindow:
self.topwin = True
# pointeur de la base principale ( ouverture par défaut de db_prim via xGestionDB)
self.DBsql = xdb.DB()
self.dicExport = {}
self.mess = ''
#préchargement des variables contenues dans l'analyse
dicAnalyse = PrechargeAnalyse(analyse, self.DBsql)
def LstChampsExp(dicAnalyse):
lst = []
for key in sorted(dicAnalyse.keys()):
code = dicAnalyse[key]['code']
type = dicAnalyse[key]['type']
label = dicAnalyse[key]['libelle']
lst.append((code, type, label))
colonne = dicAnalyse[key]['colonne']
if colonne > 0:
self.dicExport[colonne] = code
return lst
self.lstChampsExp = LstChampsExp(dicAnalyse)
# vérifie ou crée la table xAnalyse_agc_nomAnalyse
ok = self.GestionTable(agc, analyse, gestable)
if not ok:
if self.topwin:
self.topWindow.SetStatusText('Echec Gestion Table')
return
# détermination des clients à traiter
if client:
lstDossiers = GetExercicesClient(agc, client, annee, nbanter,
self.DBsql)
elif groupe:
lstDossiers = GetClientsGroupes(agc, groupe, annee, nbanter,
self.DBsql)
elif filiere:
lstDossiers = GetClientsFilieres(agc, filiere, annee, nbanter,
self.DBsql)
else:
wx.MessageBox(
"Analyse : Aucun paramètre de lancement ne concerne un dossier"
)
return
# déroulé du traitement
messBasEcran = ''
nbreOK = 0
for tplIdent in lstDossiers:
messBasEcran += "%s " % tplIdent[1]
retour = 'ko'
fn = Fonctions(self, tplIdent, dicAnalyse, agcuser=agc)
dicLigne, mess = fn.ComposeLigne()
if len(dicLigne) > 0:
retour = self.ExporteLigne(tplIdent, dicLigne)
if retour == 'ok':
nbreOK += 1
if len(mess) > 0:
self.mess += mess + '\n'
fn.DBsql.Close()
del fn
if self.topwin:
messBasEcran += retour + ', '
messBasEcran = messBasEcran[-230:]
self.topWindow.SetStatusText(messBasEcran)
wx.MessageBox("%d dossiers traités" % nbreOK)
def __init__(self, parent, tplIdent, dicAnalyse=None, agcuser=None):
self.parent = parent
self.dicAnalyse = dicAnalyse
self.agcuser = agcuser
self.title = '[UTIL_analyses].Fonctions'
def Topwin():
topwin = False
try:
# enrichissement du titre pour débug
nameclass = self.parent.__class__.__name__
self.title = nameclass + ': ' + self.title
self.topWindow = wx.GetApp().GetTopWindow()
if self.topWindow:
topwin = True
except:
pass
return topwin
self.topwin = Topwin()
self.errorResume = False
self.messBasEcran = ''
self.tplIdent = tplIdent
(self.IDagc, self.IDexploitation, self.Cloture) = self.tplIdent
# pointeur de la base principale ( ouverture par défaut de db_prim via xGestionDB)
self.DBsql = xdb.DB()
#préchargement des infos du dossier
def PrechargeIdent():
lstChamps = CHAMPS_TABLES['_Ident']
req = """SELECT * FROM _Ident
WHERE (IDagc = '%s' AND IDexploitation = '%s' AND Clôture = '%s')
;""" % self.tplIdent
retour = self.DBsql.ExecuterReq(
req, mess='accès OpenRef précharge _Ident')
dic = {}
if retour == "ok":
recordset = self.DBsql.ResultatReq()
dic = ListsToDic(lstChamps, recordset[0])
return dic
def PrechargeInfos():
req = """SELECT * FROM _Infos
WHERE (IDdossier = '%s')
;""" % self.dicIdent['iddossier']
retour = self.DBsql.ExecuterReq(
req, mess='accès OpenRef précharge _Infos')
dic = {}
if retour == "ok":
recordset = self.DBsql.ResultatReq()
for ligne in recordset:
dic[ligne[0]] = (ligne[1], ligne[2], ligne[3])
return dic
self.dicIdent = PrechargeIdent()
if len(self.dicIdent) > 1:
self.dicInfos = PrechargeInfos()
#dicVariables contient le résultat des variables du client, dicAnalyse la liste des expressions de calculs
self.dicVariables = {}
self.lstfonctions = [
'Ident', 'Infosident', 'Communeinsee', 'Balancemvt',
'Balance_N1', 'Balance', 'Produits', 'Calcul', 'Div', 'Nz'
]
def GetCompta(self, configCPTA, dicCompta):
nomBase = None
# vérif du connecteur par recherche du nom de la base
try:
DBq = xdb.DB(config=configCPTA)
nomBase = DBq.nomBase
if DBq.echec != 0:
mess = self.title + ": " + DBq.echec
nomBase = None
wx.MessageBox(mess)
except Exception as err:
mess = self.title + '.GetCompta:\n%s' % err
wx.MessageBox(mess, style=wx.ICON_INFORMATION)
if nomBase:
# import des infos d'identification et params généraux dans la compta
if self.config['compta'] == 'quadratus':
lstCle = [
'cloture', 'civilite', 'nomexploitation', 'codepostal',
'siret', 'naf', 'duree'
]
req = """SELECT Dossier1.FinExercice, Dossier1.Civilite, Dossier1.RaisonSociale, Dossier1.CodePostal, Dossier1.Siret, Dossier1.CodeNAF, Dossier1.DureeExercice
FROM Dossier1;"""
retour = DBq.ExecuterReq(req,
mess='accès Qcompta.dossier quadra')
if retour == "ok":
recordset = DBq.ResultatReq()
dicDoss = ListesToDict(lstCle, recordset[0])
dicCompta['ident']['Clôture'] = str(
dicDoss['cloture'])[:10]
civil = ''
if len(dicDoss['civilite']) > 1:
civil = dicDoss['civilite'] + ' '
dicCompta['ident'][
'NomExploitation'] = civil + dicDoss['nomexploitation']
dicCompta['ident']['IDCodePostal'] = dicDoss['codepostal']
dicCompta['ident']['Siren'] = dicDoss['siret'][:9]
dicCompta['ident']['IDnaf'] = dicDoss['naf']
dicCompta['ident']['NbreMois'] = int(dicDoss['duree'])
# import de la balance de la compta
lstBalance = []
if self.config['compta'] == 'quadratus':
def ChercheMotsCle(compte, lib, uneecr):
#découpe le libellé et l'écriture exemple pour trouver les mots clés mis en minuscule qui matchent
lstMots = []
lstplus = []
if compte[:1] in ('7', '6', '3'):
lstRef = self.lstMotsCout
if compte[:1] in ('7', '3'): lstRef = self.lstMotsProd
if compte[:2] == '30': lstRef = self.lstMotsCout
if compte[:3] == '604': lstRef = self.lstMotsProd
lstlib = orut.Decoupe(lib)
lstecr = orut.Decoupe(uneecr)
if len(lstlib + lstecr) == 0:
req = """
SELECT Ecritures.Libelle
FROM Ecritures
WHERE Ecritures.Compte = %s;
LIMIT 10
""" % compte
retour = DBq.ExecuterReq(
req,
mess='accès Qcompta.ecritures TOP 10',
affichError=False)
if retour == "ok":
recordset = DBq.ResultatReq()
for record in recordset:
lstplus = orut.Decoupe(str(record))
lstMotsDossier = str(lstlib + lstecr + lstplus)
for mot in lstRef:
if mot in lstMotsDossier:
if not mot in lstMots:
lstMots.append(mot)
return lstMots
# appel de la balance clients et fournisseurs
# lstCle = ['compte', 'libcompte', 'libecriture', 'anouv', 'qte', 'qtenature','qte2','qte2nature','debits','credits']
req = """
SELECT Comptes.Collectif, Comptes.Type, "collectif" AS ecrLibelle,
IIf(Ecritures.CodeJournal = "AN",1,0) AS AN, Sum([Quantite]) AS qte,
Comptes.QuantiteLibelle, Sum([Quantite2]) AS qte2, Comptes.QuantiteLibelle2,
Sum(Ecritures.MontantTenuDebit) AS Debits, Sum(Ecritures.MontantTenuCredit) AS Credits
FROM Dossier1, (Ecritures
INNER JOIN Comptes ON Ecritures.NumeroCompte = Comptes.Numero)
WHERE (((Ecritures.PeriodeEcriture)<=[dossier1].[finexercice]) AND ((Left([NumeroCompte],1))='0'))
GROUP BY Comptes.Collectif, Comptes.Type, IIf(Ecritures.CodeJournal = "AN",1,0),
Comptes.QuantiteLibelle, Comptes.QuantiteLibelle2;
"""
retour = DBq.ExecuterReq(
req,
mess='accès Qcompta.ecritures auxiliaires quadra',
affichError=False)
recordsetAux, recordset = [], []
if retour == "ok":
recordsetAux = DBq.ResultatReq()
#appel de la balance hors clients et fournisseurs
#lstCle = ['compte', 'libcompte', 'libecriture', 'anouv', 'qte', 'qtenature','qte2','qte2nature','debits','credits']
req = """
SELECT Ecritures.NumeroCompte, Comptes.Intitule, Max(Ecritures.Libelle) AS ecrLibelle,
IIf(Ecritures.CodeJournal = "AN",1,0) AS AN,
Sum([Quantite]) AS qte, Comptes.QuantiteLibelle, Sum([Quantite2]) AS qte2, Comptes.QuantiteLibelle2,
Sum(Ecritures.MontantTenuDebit) AS Debits, Sum(Ecritures.MontantTenuCredit) AS Credits
FROM Dossier1, (Ecritures
INNER JOIN Comptes ON Ecritures.NumeroCompte = Comptes.Numero)
WHERE (((Ecritures.PeriodeEcriture)<=[dossier1].[finexercice]) AND ((Left([NumeroCompte],1))<>'0'))
GROUP BY Ecritures.NumeroCompte, Comptes.Intitule, IIf(Ecritures.CodeJournal = "AN",1,0),
Comptes.QuantiteLibelle, Comptes.QuantiteLibelle2
ORDER BY Ecritures.NumeroCompte;
"""
retour = DBq.ExecuterReq(req,
mess='accès Qcompta.ecritures quadra')
if retour == "ok":
recordset = DBq.ResultatReq()
# constitution des lignes a importer sur concaténation des deux recordset
for compte, libcompte, libmaxecriture, anouv, qte, qtenature, qte2, qte2nature, debits, credits in recordset + recordsetAux:
if anouv == 1:
#cumul d'écritures a nouveaux
soldedeb = soldefin = round(debits - credits, 2)
mvtdeb = mvtcre = 0.0
else:
soldedeb = 0.0
mvtdeb = round(debits, 2)
mvtcre = round(credits, 2)
soldefin = round(debits - credits, 2)
if libcompte == None: libcompte = ''
#if compte[-3:]=='836':
# print(compte, libcompte)
if libmaxecriture == None: libmaxecriture = ''
if abs(mvtcre) + abs(mvtdeb) + abs(soldedeb) > 0:
motsclepres = ChercheMotsCle(compte, libcompte,
libmaxecriture)
IDplanCompte = orut.ChercheIDplanCompte(
compte, self.dicPlanComp)
lstBalance.append([
compte,
libcompte.strip(),
str(motsclepres)[1:-1], qte, qtenature, qte2,
qte2nature, soldedeb, mvtdeb, mvtcre, soldefin,
IDplanCompte
])
dicCompta['balance'] = lstBalance
dicIdent = {}
# import des infos dossier de gestion et liasse pour compléter ident
if self.config['compta'] == 'quadratus':
dicProd = {}
def SetDicProd(record):
grp = record[0][2:5]
elem = record[0][5]
ligne = record[0][6:]
prod = grp + ligne
if ligne in ['A']: prod += 'b'
if int(ligne) > 0:
if not ((prod) in dicProd.keys()): dicProd[(prod)] = {}
if elem in ['L']: dicProd[(prod)]['lib'] = record[8]
if elem in ['H', 'M']:
dicProd[(prod)]['surf'] = record[3]
if elem in ['Q', 'A', 'F']:
dicProd[(prod)]['qte'] = record[3]
if elem in ['A']: dicProd[(prod)]['lib'] = "\ten chais"
if elem in ['F']:
dicProd[(prod)]['lib'] = "Effectif fin"
# infos liasse agri (AG pour agri)
req = """SELECT * FROM HISTORIQUE WHERE RUB LIKE 'AGH%' OR RUB LIKE 'AGU%' OR RUB LIKE 'AYP%';"""
retour = DBq.ExecuterReq(
req, mess='accès Qcompta.historique quadra')
# récup surfaces et main d'oeuvre de la liasse
if retour == "ok":
recordset = DBq.ResultatReq()
for record in recordset:
if record[0] in ["AGHD", "AGUU"]:
dicIdent["SAUfvd"] = record[3]
if record[0] in ["AGHE", "AGUW"]:
dicIdent["SAUfermage"] = record[3]
if record[0] in ["AGHF", "AGUX"]:
dicIdent["SAUmétayage"] = record[3]
if record[0] in ["AGHB", "AGUV"]:
dicIdent["SAUmad"] = record[3]
if record[0] in ["AGHC", "AGUT"]:
dicIdent["SAU"] = record[3]
if record[0] in ["AYP"]:
dicIdent["MOpermanents"] = record[3]
# infos dossier de gestion agri productions pour constituer un memo préparé dans dicProd
req = """SELECT * FROM HISTORIQUE
WHERE (((HISTORIQUE.RUB) Like 'AGSAU%' Or (HISTORIQUE.RUB) Like 'AGVIT%'
Or (HISTORIQUE.RUB) Like 'AGPRS%' Or (HISTORIQUE.RUB) Like 'AGPAN%')
AND ((HISTORIQUE.Regle) In ('0',''))
AND ((HISTORIQUE.AnN)<>0));
"""
retour = DBq.ExecuterReq(
req,
mess='accès Qcompta.historique quadra productions nombre')
# récup des libellés
if retour == "ok":
recordset = DBq.ResultatReq()
for record in recordset:
SetDicProd(record)
req = """SELECT * FROM HISTORIQUE
WHERE (((HISTORIQUE.RUB) Like 'AGSAU%' Or (HISTORIQUE.RUB) Like 'AGVIT%'
Or (HISTORIQUE.RUB) Like 'AGPRS%' Or (HISTORIQUE.RUB) Like 'AGPAN%')
AND ((HISTORIQUE.Regle) In ('0',''))
AND ((HISTORIQUE.Alpha)<> ''));
"""
retour = DBq.ExecuterReq(
req,
mess='accès Qcompta.historique quadra productions nombre')
# récup des quantités
if retour == "ok":
recordset = DBq.ResultatReq()
for record in recordset:
SetDicProd(record)
# intégration des productions dans le memo
dicIdent['Productions'] = "Production__surface__quantite\n"
dicElem = {}
for key in sorted(dicProd.keys()):
grp = key[:3]
if not grp in dicElem:
dicElem[grp] = {
'surf': 0.0,
'qte': 0.0,
'nature': 'ha'
}
for champ in ['lib', 'surf', 'qte']:
if not champ in dicProd[key].keys():
dicProd[key][champ] = 0
texte = str(dicProd[key]['lib']) + '__' + str(
dicProd[key]['surf']) + '__' + str(dicProd[key]['qte'])
try:
dicIdent['Productions'] += '\n%s' % texte
dicElem[grp]['surf'] += float(dicProd[key]['surf'])
dicElem[grp]['qte'] += float(dicProd[key]['qte'])
except:
pass
#determination du meilleur élément caractéristique
qte = 0.0
surf = 0.0
grpQte = ''
for key, value in dicElem.items():
if value['qte'] > qte:
grpQte = key
qte = value['qte']
if qte == 0.0:
# aucune saisie de quantités dans dossier de gestion, on prend les surfaces du groupe activité maxi
for key, value in dicElem.items():
if value['surf'] > surf:
surf = value['surf']
dicIdent['NbElemCar'] = surf
dicIdent['ElemCar'] = 'ha'
else:
#on priviligie les quantités du groupe d'activité maxi
dicIdent['NbElemCar'] = qte
if grpQte == 'VIT': dicIdent['ElemCar'] = 'hl'
elif grpQte == 'PAN': dicIdent['ElemCar'] = 'tête'
elif grpQte == 'SAU': dicIdent['ElemCar'] = 'qx'
else: dicIdent['ElemCar'] = 'qte'
# récup surfaces, main d'oeuvre, activité et tableau de financement, dans le dossier de gestion AGRI
req = """SELECT * FROM HISTORIQUE
WHERE (RUB LIKE 'AGPF%' OR RUB LIKE 'AGPM%')
AND AnN<>0;"""
retour = DBq.ExecuterReq(
req, mess='accès Qcompta.historique quadra surfaces MO')
if retour == "ok":
recordset = DBq.ResultatReq()
dicSAU = {}
dicMO = {}
lstSAU = [("AGPF201", "SAUfvd"), ("AGPF202", "SAUfermage"),
("AGPF203", "SAUmétayage"),
("AGPF204", "SAUmad"), ("AGPF205", "SAU")]
lstMO = [("AGPMO14", "MOexploitants"),
("AGPMO15", "MOpermanents"),
("AGPMO16", "MOsaisonniers")]
for record in recordset:
for (champQ, champOR) in lstSAU:
if record[0] == champQ:
dicSAU[champOR] = record[3]
for (champQ, champOR) in lstMO:
if record[0] == champQ:
dicMO[champOR] = record[3]
if len(dicSAU) > 0:
#la liasse à pu préalimenter différemment, on remet à zéro si dossier de gestion
for (champQ, champOR) in lstSAU:
if champOR in dicIdent: dicIdent[champOR] = 0.0
if champOR in dicSAU:
dicIdent[champOR] = dicSAU[champOR]
if len(dicMO) > 0:
for (champQ, champOR) in lstMO:
if champOR in dicIdent: dicIdent[champOR] = 0.0
if champOR in dicMO:
dicIdent[champOR] = dicMO[champOR]
# récup du tableau de financement dans le dossier de gestion
req = """SELECT * FROM HISTORIQUE
WHERE (RUB LIKE 'AGTR%' OR RUB LIKE 'AGTE%')
AND AnN<>0;"""
retour = DBq.ExecuterReq(
req, mess='accès Qcompta.historique quadra TBF')
if retour == "ok":
recordset = DBq.ResultatReq()
lstTBF = [("AGTR1", "Caf"),
(["AGTR2", "AGTR3", "AGTR4",
"AGTR5"], "Cessions"), ("AGTRA", "SubvReçues"),
(["AGTRB", "AGTRC"], "NvxEmprunts"),
(["AGTR9", "AGTR8"], "Apports"),
(["AGTE1", "AGTE9", "AGTEA"], "Prélèvements"),
(["AGTE2", "AGTE3", "AGTE4",
"AGTE5"], "Investissements"),
(["AGTEB", "AGTEC"], "RbtEmprunts")]
for record in recordset:
for (champQ, champOR) in lstTBF:
if record[0] in champQ:
dicIdent[champOR] = record[3]
# récup de l'activité dans le dossier de gestion
req = """SELECT * FROM HISTORIQUE
WHERE (RUB = 'ACTIVITE');"""
retour = DBq.ExecuterReq(
req, mess='accès Qcompta.historique quadra TBF')
if retour == "ok":
recordset = DBq.ResultatReq()
dicIdent['Remarques'] = ""
for record in recordset:
if record[0] == 'ACTIVITE':
dicCompta['ident']['Filières'] = self.filieres
try:
for mot in record[8].split(' '):
if not mot in self.filieres:
dicCompta['ident'][
'Filières'] += mot + ' '
except:
pass
for key, value in dicIdent.items():
dicCompta['ident'][key] = dicIdent[key]
DBq.Close()
def __init__(self, parent, id=-1, title="xUTILS_Identification"):
wx.Dialog.__init__(self,
parent,
id,
title,
name="DLG_mdp",
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
self.parent = parent
self.echec = False
self.dictUtilisateur = None
self.listeUtilisateurs = []
DB = xdb.DB()
self.dictAppli = DB.dictAppli
self.grpConfigs = DB.grpConfigs
if DB.echec:
dlg = xGestionConfig.DLG_implantation(self)
ret = dlg.ShowModal()
if ret == wx.ID_OK:
DB = xdb.DB()
self.dictAppli = DB.dictAppli
self.grpConfigs = DB.grpConfigs
if DB.echec:
self.echec = True
else:
self.echec = True
# l'identification n'a de sens qu'en réseau
if not DB.isNetwork:
self.echec = True
DB.Close()
if not self.echec:
self.listeUtilisateurs = GetListeUsers()
self.dictUtilisateur = None
lstIDconfigs, lstConfigs, lstConfigsKO = xGestionConfig.GetLstConfigs(
self.grpConfigs)
# composition de l'écran
self.staticbox = wx.StaticBox(self, -1, "Authentification")
self.txtIntro = wx.StaticText(
self, -1, "Vous serez identifié par votre seul mot de passe.\n" +
"Choisissez une base de donnée du réseau !")
self.txtConfigs = wx.StaticText(self, -1, "Base d'authentification:")
self.comboConfigs = xusp.PNL_ctrl(
self, **{
'genre': 'combo',
'name': "configs",
'values': lstIDconfigs,
'help':
"Choisissez la base de donnée qui servira à vous authentifier",
'size': (250, 60)
})
self.txtMdp = wx.StaticText(self, -1, "Utilisateur:")
self.ctrlMdp = CTRL_mdp(self, listeUtilisateurs=self.listeUtilisateurs)
self.bouton_annuler = CTRL_Bouton_image(
self,
id=wx.ID_CANCEL,
texte="Annuler",
cheminImage="xpy/Images/32x32/Annuler.png")
self.__set_properties()
self.__do_layout()
self.ctrlMdp.SetFocus()
def OnTest(self, event):
dicParam = event.EventObject.Parent.pnl.lstBoxes[0].GetValues()
DB = xdb.DB(config=dicParam, typeConfig=self.parent.typeConfig)
DB.AfficheTestOuverture()
def OnTest(self, event):
self.OnCtrlConfig(None)
DB = xdb.DB(typeConfig=self.typeConfig)
DB.AfficheTestOuverture()
