def __init__(self, **kwds):
db = kwds.pop('db', None)
if db == None:
import xpy.xUTILS_DB as xdb
db = xdb.DB()
value = kwds.pop('value', None)
dicOlv = kwds.pop('dicOlv', None)
if not dicOlv:
dicOlv = GetDicOlv(db, cutend=2)
dicOlv['dicBandeau']['titre'] = TITRE
dicOlv['dicBandeau']['texte'] = INTRO
kwds['dicOlv'] = dicOlv
kwds['db'] = db
super().__init__(None, **kwds)
self.pnlOlv.estAdmin = True # force la gestion possible
self.db = db
self.ordi = xuid.GetNomOrdi()
self.today = datetime.date.today()
# personnalisation du bouton dupliquer
if hasattr(self.pnlOlv, 'lstBtnCtrl'):
self.pnlOlv.lstBtnCtrl[2][0].SetToolTip(
"Changer le nom de l'article sélectionné ")
if isinstance(value, str):
self.pnlOlv.ctrlOutils.barreRecherche.SetValue(value)
# enlève le filtre si pas de réponse
if len(self.ctrlOlv.innerList) == 0:
self.pnlOlv.ctrlOutils.barreRecherche.SetValue('')
self.pnlOlv.ctrlOutils.barreRecherche.OnSearch(None)
self.ctrlOlv.SetFocus()
if len(self.ctrlOlv.innerList) > 0:
self.ctrlOlv.SelectObject(0)
self.ctrlOlv.Refresh()
def __init__(self, sens='sorties', date=None, **kwd):
# gestion des deux sens possibles 'entrees' et 'sorties'
self.sens = sens
self.sensNum = 1
if self.sens == "sorties":
self.sensNum = -1
kwds = GetDlgOptions(self)
listArbo = os.path.abspath(__file__).split("\\")
kwds['title'] = listArbo[-1] + "/" + self.__class__.__name__
super().__init__(None, **kwds)
# l'appel des colonnes se fera dans OnOrigine
self.dicOlv = {'lstCodesSup': GetOlvCodesSup()}
self.dicOlv.update(GetOlvOptions(self))
self.dicOlv['db'] = xdb.DB()
self.origines = self.dicOlv.pop("codesOrigines", [])
self.ordi = xuid.GetNomOrdi()
self.today = datetime.date.today()
if not date:
date = self.today
self.date = date
self.analytique = '00'
self.fournisseur = ''
self.ht_ttc = 'TTC'
if sens == "entrees": self.htTTC = 'HT'
self.oldParams = {}
ret = self.Init()
if ret == wx.ID_ABORT: self.Destroy()
self.ht_ttc = self.pnlParams.GetOneValue('ht_ttc', codeBox='param3')
self.origine = self.GetOrigine()
self.OnOrigine(None)
self.OnBtnAnterieur(None) # appel de la saisie du jour encours
self.GetDonnees()
self.Sizer()
def __init__(self):
# boutons de bas d'écran - infos: texte ou objet window. Les infos sont placées en bas à gauche
self.txtInfo = "Pour gérer les lignes, utilisez les boutons à droite, \n...ou Double Clic pour modifier une ligne"
lstInfos = [ wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_OTHER, (16, 16)),self.txtInfo]
dicPied = {'lstBtns': GetBoutons(self), "lstInfos": lstInfos}
# Propriétés du corps de l'écran
self.dicOlv = {'lstColonnes': GetOlvColonnes(self)}
self.dicOlv.update({'lstCodesSup': GetOlvCodesSup()})
self.dicOlv.update(GetOlvOptions(self))
self.dicOlv.update(GetMatriceSaisie(self))
# variables gérées par l'écran paramètres
self.ordi = xuid.GetNomOrdi()
self.today = datetime.date.today()
self.cuisine = True
self.analytique = '00'
# Propriétés de l'écran global type Dialog
kwds = GetDlgOptions(self)
kwds['autoSizer'] = False
kwds['dicParams'] = GetDicParams()
kwds['dicOlv'] = self.dicOlv
kwds['dicPied'] = dicPied
kwds['db'] = xdb.DB()
super().__init__(None, **kwds)
ret = self.Init()
if ret == wx.ID_ABORT: self.Destroy()
self.Sizer()
self.ctrlOlv.MAJ()
def Requete(condition):
db = xdb.DB()
req = """SELECT secteurs.nom
FROM secteurs
%s ;""" % condition
db.ExecuterReq(req, mess="UTILS_Adresses_saisie.GetOnePays")
return db.ResultatReq()
def GetDBadresse(IDindividu=None, retNom=False):
# lit dans la base une adresse et retourne une liste de 7 lignes dont certaines à blanc
adresse = [''] * 7
nom = None
prenom = None
if IDindividu and IDindividu > 0:
# Importation de l'adresse de l'individu
DB = xdb.DB()
req = """SELECT individus.adresse_auto, individus.rue_resid, individus.cp_resid, individus.ville_resid,
secteurs.nom, individus.adresse_normee,individus.nom,individus.prenom
FROM individus
LEFT JOIN secteurs ON individus.IDsecteur = secteurs.IDsecteur
WHERE individus.IDindividu = %d
;""" % IDindividu
ret = DB.ExecuterReq(req, mess="aUTILS_Adresses_saisie.GetDBadresse")
if ret == "ok":
recordset = DB.ResultatReq()
# un seul record possible au plus
for auto, rue, cp, ville, secteur, normee, nom, prenom in recordset:
# rue et ville peuvent contenir plusieurs lignes à séparer
if auto and auto > 0 and auto != IDindividu:
# appel de l'adresse indirecte sur un autre individu
adresse, IDindividu, (nom,
prenom) = GetDBadresse(auto,
retNom=True)
else:
# adresse découpée et complétée.
adresse = ChampsToLstAdresse(rue, cp, ville)
DB.Close()
if retNom:
return adresse, IDindividu, (nom, prenom)
else:
return adresse, IDindividu
def SqlLastInventaire(cloture=None):
# retourne l'inventaire précédent la date de cloture
if cloture == None:
cloture = datetime.date.today()
db = xdb.DB()
# Appelle l'inventaire précédent
lstChamps = ['IDdate','IDarticle','qteStock','prixMoyen',]
finIso = xformat.DatetimeToStr(cloture,iso=True)
req = """ SELECT %s
FROM stInventaires
WHERE (stInventaires.IDdate =
(SELECT MAX(stInv.IDdate)
FROM stInventaires as stInv
WHERE stInv.IDdate < '%s')
)
;""" % (",".join(lstChamps),finIso)
retour = db.ExecuterReq(req, mess='UTILS_Stocks.SqlLastInventaire')
llInventaire = []
if retour == "ok":
recordset = db.ResultatReq()
for record in recordset:
mouvement = []
for ix in range(len(lstChamps)):
mouvement.append(record[ix])
llInventaire.append(mouvement)
db.Close()
return llInventaire
def SqlMouvementsPeriode(debut=None,fin=None):
# retourne une liste de mouvements en forme de liste
lstChamps = ['date','origine','stMouvements.IDarticle','qte','prixUnit','IDmouvement']
if fin == None: fin = datetime.date.today()
if debut == None: debut = fin - datetime.timedelta(days=180)
finIso = xformat.DatetimeToStr(fin,iso=True)
debutIso = xformat.DatetimeToStr(debut,iso=True)
db = xdb.DB()
# Appelle les mouvements de la période
req = """ SELECT %s
FROM stMouvements
WHERE ( (date > '%s' )
AND (date <= '%s' ))
;""" % (",".join(lstChamps),debutIso,finIso)
retour = db.ExecuterReq(req, mess='UTILS_Stocks.SqlMouvementsPeriode')
llMouvements = []
if retour == "ok":
recordset = db.ResultatReq()
for record in recordset:
mouvement = []
for ix in range(len(lstChamps)):
mouvement.append(record[ix])
llMouvements.append(mouvement)
db.Close()
return llMouvements
def GetDBfamille(IDfamille=None):
# lit dans la base les données de la table famille
dicCorrespondant = {
'IDindividu': None,
'designation': None,
'IDfamille': IDfamille,
'designIndiv': ""
}
if IDfamille and IDfamille > 0:
# Importation de l'adresse de l'individu
DB = xdb.DB()
req = """SELECT familles.adresse_individu, familles.adresse_intitule, individus.prenom, individus.nom
FROM familles
LEFT JOIN individus ON familles.adresse_individu = individus.IDindividu
WHERE (familles.IDfamille = %d)
;""" % IDfamille
ret = DB.ExecuterReq(req, mess="aUTILS_Adresses_saisie.GetDBfamille")
if ret == "ok":
recordset = DB.ResultatReq()
# un seul record possible au plus
for IDindividu, designation, prenom, nom in recordset:
designIndiv = "%d - %s %s" % (IDindividu, prenom, nom)
dicCorrespondant['IDindividu'] = IDindividu
dicCorrespondant['designIndiv'] = designIndiv
dicCorrespondant['designation'] = designation
DB.Close()
return dicCorrespondant
def DB(self, cfgCompta):
if self.db and self.db.echec:
self.db = None
if cfgCompta:
# test de l'accès
db = xdb.DB(config=cfgCompta)
db.Close()
if self.exercice:
if 'quadra' in cfgCompta['serveur'].lower():
annee = self.exercice
cfgCompta['serveur'] = cfgCompta['serveur'].replace(
"\\DC\\", "\\DA%s\\" % annee)
if cfgCompta:
return xdb.DB(config=cfgCompta, mute=True)
def Sauvegarde(self, IDreglement=None):
""" Sauvegarde des données """
DB = xdb.DB()
for ligne in self.listeLignesPrestations :
IDprestation = ligne.IDprestation
montant = float(ligne.ventilationActuelle)
if IDprestation in self.dictVentilationInitiale.keys() :
IDventilation = self.dictVentilationInitiale[IDprestation]
else:
IDventilation = None
if ligne.GetEtat() == True :
# Ajout ou modification
lstDonnees = [
("IDreglement", IDreglement),
("IDcompte_payeur", self.IDcompte_payeur),
("IDprestation", IDprestation),
("montant", montant),
]
if IDventilation == None :
DB.ReqInsert("ventilation", lstDonnees=lstDonnees,mess="DLG_Reglements_ventilation.Sauvegarde Insert")
else:
DB.ReqMAJ("ventilation",lstDonnees,"IDventilation", IDventilation,
mess="DLG_Reglements_ventilation.Sauvegarde Maj")
else :
# Suppression
if IDventilation != None :
DB.ReqDEL("ventilation", "IDventilation", IDventilation,mess="DLG_Reglements_ventilation.Sauvegarde Del")
DB.Close()
return
def VerifieVille(codepost="", ville="", pays=""):
# vérifie la présence des éléments dans les possibles retourne ok ou message
if len(pays) > 0: return "ok"
# Seulement les adresses en france if not ville or len(ville.strip()) == 0: return "Ville à blanc."
if "'" in ville:
lst = ville.split("'")
ville = "_".join(lst)
conditioncp = ""
filtre = codepost.upper()
tronque = 0
# filtrage des zéro non significatifs pour le premier accès
if len(filtre) > 0:
while filtre[0] == "0" and len(filtre) > 1:
tronque += 1
filtre = filtre[1:]
if filtre == '0':
filtre = ""
tronque += 1
conditioncp = "AND cp LIKE '%s%%'" % (filtre)
for chaine in (ville, conditioncp):
chaine = chaine.replace("'", "''")
condition = "WHERE nom LIKE '%s' %s " % (ville, conditioncp)
DB = xdb.DB(nomFichier="srcNoelite/Data/Geographie.dat")
req = """ SELECT IDville, nom, cp
FROM villes
%s;""" % condition
DB.ExecuterReq(req, mess="aUTILS_Adresses_saisie.VerifieVille")
ret = DB.ResultatReq()
DB.Close()
if len(ret) == 1:
if len(pays.strip()) == 0: return "ok"
# la ville n'est pas en france avec le code postal
# Importation des corrections de villes et codes postaux
DB = xdb.DB()
ville = ville.replace("'", "?")
condition = "WHERE nom LIKE '%s'" % (ville)
if len(codepost) > 1:
condition += " AND cp = '%s'" % codepost
req = """SELECT IDcorrection, mode, IDville, nom, cp, pays
FROM corrections_villes %s; """ % condition
DB.ExecuterReq(req, mess="aUTILS_Adresses_saisie.VerifieVille2")
ret = DB.ResultatReq()
DB.Close()
if len(ret) == 1: return "ok"
return "Ville non trouvée avec ce code postal"
def Init(self):
self.db = xdb.DB()
# définition de l'OLV
self.ctrlOlv = None
# boutons de bas d'écran - infos: texte ou objet window. Les infos sont placées en bas à gauche
self.txtInfo = "Ici de l'info apparaîtra selon le contexte de la grille de saisie"
lstInfos = [
wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_OTHER,
(16, 16)), self.txtInfo
]
dicPied = {'lstBtns': GetBoutons(self), "lstInfos": lstInfos}
# lancement de l'écran en blocs principaux
if self.sens == 'entrees':
self.pnlBandeau = xbandeau.Bandeau(
self,
TITRE[self.sens],
INTRO[self.sens],
hauteur=20,
nomImage="xpy/Images/80x80/Entree.png",
sizeImage=(60, 40))
self.pnlBandeau.SetBackgroundColour(wx.Colour(220, 250, 220))
else:
self.pnlBandeau = xbandeau.Bandeau(
self,
TITRE[self.sens],
INTRO[self.sens],
hauteur=20,
nomImage="xpy/Images/80x80/Sortie.png",
sizeImage=(60, 40))
self.pnlBandeau.SetBackgroundColour(wx.Colour(250, 220, 220))
self.pnlParams = PNL_params(self)
self.pnlOlv = PNL_corps(self, self.dicOlv)
self.pnlPied = PNL_pied(self, dicPied)
self.ctrlOlv = self.pnlOlv.ctrlOlv
# charger les valeurs de pnl_params
self.pnlParams.SetOneSet('fournisseur',
values=nust.SqlFournisseurs(self.db),
codeBox='param2')
self.lstAnalytiques = nust.SqlAnalytiques(self.db, 'ACTIVITES')
self.valuesAnalytiques = [
'',
] + [nust.MakeChoiceActivite(x) for x in self.lstAnalytiques]
self.codesAnalytiques = [x[:2] for x in self.valuesAnalytiques]
self.codesAnalytiques[0] = '00'
if len(self.codesAnalytiques) == 1:
wx.MessageBox(
"Aucune activité définie!\n\nLes affectations analytiques ne seront pas possibles par camp"
)
self.pnlParams.SetOneSet('analytique',
values=self.valuesAnalytiques,
codeBox='param2')
self.SetAnalytique('00')
self.pnlParams.SetOneValue('origine',
valeur=DICORIGINES[self.sens]['values'][0],
codeBox='param1')
self.Bind(wx.EVT_CLOSE, self.OnClose)
def OnTester(self, event, mute=False):
# appelé par le bouton tester tente toutes les connexions de l'appli.
self.OnCtrlConfig(None)
for ctrlConfig in self.lstChoixConfigs:
nomConfig = ctrlConfig.dictDonnees['config']
config = xdb.GetOneConfig(self, nomConfig)
DB = xdb.DB(config=config, mute=True)
self.echec = DB.echec
if not mute:
DB.AfficheTestOuverture(info=" pour %s" % nomConfig)
def ConnectBase(self, etat= False):
if self.db: return
# test de connexion par défaut
DB = xdb.DB(mute=True)
self.echec = DB.echec
self.etat = False
if DB.echec == 0:
self.etat = True
self.db = DB
return
def GetOnePays(filtre=""):
filtre = filtre.upper().replace("'", "?")
if filtre == "FRANCE":
wx.MessageBox(
"La France n'est pas un pays étranger, il faut laisser le champ à blanc!"
)
return ""
if filtre in ("ANGLETERRE", "ECOSSE", "PAYS DE GALLE"):
return "ROYAUME UNI"
if len(filtre) > 0:
condition = "WHERE secteurs.nom LIKE '%s%%'" % filtre
else:
condition = ""
db = xdb.DB()
def Requete(condition):
db = xdb.DB()
req = """SELECT secteurs.nom
FROM secteurs
%s ;""" % condition
db.ExecuterReq(req, mess="UTILS_Adresses_saisie.GetOnePays")
return db.ResultatReq()
lstDonnees = Requete(condition)
if len(lstDonnees) == 1:
pays = lstDonnees[0][0]
else:
pays = ""
if len(lstDonnees) == 0:
# le pays saisi n'existe pas on propose tout
lstDonnees = Requete("")
# Choisir dans la liste
dlg = xcl.DialogAffiche(
lstDonnees=lstDonnees,
titre="Précisez le pays",
intro=
"Si le pays n'existe pas passer par la gestion des pays postaux")
ret = dlg.ShowModal()
if ret == wx.OK:
pays = dlg.GetChoix()[0]
dlg.Destroy()
db.Close()
return pays
listeListeView = []
for item in lstDonnees:
valide = True
if listeID != None:
if item[0] not in listeID:
valide = False
if valide == True:
track = Track(item)
listeListeView.append(track)
if self.selectionID == item[0]:
self.selectionTrack = track
def __init__(self):
# boutons de bas d'écran - infos: texte ou objet window. Les infos sont placées en bas à gauche
lstInfos = [
wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_OTHER,
(16, 16)),
]
lstInfos += INFOS
dicPied = {'lstBtns': GetBoutons(self), "lstInfos": lstInfos}
# Propriétés du corps de l'écran
self.dicOlv = {'lstColonnes': GetOlvColonnes(self)}
self.dicOlv.update({'lstCodesSup': GetOlvCodesSup()})
self.dicOlv.update(GetOlvOptions(self))
# variables gérées par l'écran paramètres
self.today = datetime.date.today()
#self.periode = (None,None)
self.cuisine = True
self.analytique = '00'
self.midi = True
self.soir = True
self.matin = True
# Propriétés de l'écran global type Dialog
kwds = GetDlgOptions(self)
kwds['autoSizer'] = False
kwds['dicParams'] = GetDicParams()
#kwds['dicOlv'] = self.dicOlv
kwds['dicPied'] = dicPied
xdb.DB().Close()
kwds['db'] = xdb.DB()
super().__init__(None, **kwds)
self.pnlOlv = PNL_corps(self, self.dicOlv, **kwds)
self.ctrlOlv = self.pnlOlv.ctrlOlv
ret = self.Init()
if ret == wx.ID_ABORT: self.Destroy()
self.Sizer()
self.ctrlOlv.MAJ()
self.ctrlOlv.SetFocus()
def SetDBcorrespondant(dicCorrespondant):
# Stocke dans la base de donnée l'adresse avec 4 lignes obligatoires pour rue, 2 pour ville et cp à part.
lstDonnees = [("adresse_intitule", dicCorrespondant['designation']),
("adresse_individu", dicCorrespondant['IDindividu'])]
# envoi dans la base de donnée
DB = xdb.DB()
ret = DB.ReqMAJ("familles",
lstDonnees,
"IDfamille",
dicCorrespondant['IDfamille'],
mess="Insert familles Correspondant")
return ret
def GetBases(self, cfgParams=None):
# connexion actuelle stockée pour vérif modifs
oldval = None
if not cfgParams or cfgParams['nameDB'] == '':
#récupération d'un connexion antérieure, soit d'un précédent passage, soit celle par défaut
if not self.DB:
self.DB = xdb.DB(mute=True)
else:
oldval = cfgParams['nameDB']
self.DB = xdb.DB(config=cfgParams, mute=True)
if self.DB.connexion:
lstBases = [
x for (x, ) in self.DB.GetDataBases() if x[-4:].lower() == 'data'
]
else:
lstBases = [
oldval,
'Recherche échouée',
]
return lstBases
def GetDepartements():
# Importation de la base par défaut
DB = xdb.DB(nomFichier="srcNoelite/Data/Geographie.dat")
req = """ SELECT num_dep, num_region, departement
FROM departements"""
DB.ExecuterReq(req)
listeDepartements = DB.ResultatReq()
DB.Close()
dictDepartements = {}
for num_dep, num_region, departement in listeDepartements:
dictDepartements[num_dep] = (departement, num_region)
return dictDepartements
def VerificationDroits(dictUtilisateur=None,
categorie="",
action="",
IDactivite=""):
""" Vérifie si un utilisateur peut accéder à une action """
if ((dictUtilisateur == None) or ("droits" in dictUtilisateur)) == False:
return True
dictDroits = dictUtilisateur["droits"]
key = (categorie, action)
if (dictDroits != None) and (key in dictDroits):
etat = dictDroits[key]
# Autorisation
if etat.startswith("autorisation"):
return True
# Interdiction
if etat.startswith("interdiction"):
return False
# Restriction
if etat.startswith("restriction"):
code = etat.replace("restriction_", "")
mode, listeID = code.split(":")
listeID = [int(x) for x in listeID.split(";")]
if mode == "groupes":
if len(listeID) == 1:
condition = "IDtype_groupe_activite=%d" % listeID[0]
if len(listeID) > 1:
condition = "IDtype_groupe_activite IN %s" % str(
tuple(listeID))
DB = xdb.DB()
req = """SELECT IDgroupe_activite, activites
FROM groupes_activites
WHERE %s;""" % condition
DB.ExecuterReq(req)
lstDonnees = DB.ResultatReq()
listeActivites = []
for IDgroupe_activite, IDactivite_temp in lstDonnees:
listeActivites.append(IDactivite_temp)
DB.Close()
if mode == "activites":
listeActivites = listeID
if IDactivite in listeActivites:
return True
else:
return False
return True
def __init__(self,date=None,**kwd):
kwds = GetDlgOptions(self)
self.dicParams = GetDicParams(self)
self.dicOlv = {'lstColonnes': GetOlvColonnes(self)}
self.dicOlv.update({'lstCodesSup': GetOlvCodesSup()})
self.dicOlv.update(GetOlvOptions(self))
self.checkColonne = self.dicOlv.get('checkColonne',False)
self.dicOlv['lstCodes'] = xformat.GetCodesColonnes(GetOlvColonnes(self))
self.dicOlv['db'] = xdb.DB()
# boutons de bas d'écran - infos: texte ou objet window. Les infos sont placées en bas à gauche
txtInfo = "Ici de l'info apparaîtra selon le contexte de la grille de saisie"
lstInfos = [ wx.ArtProvider.GetBitmap(wx.ART_INFORMATION, wx.ART_OTHER, (16, 16)),txtInfo]
dicPied = {'lstBtns': GetBoutons(self), "lstInfos": lstInfos}
# Propriétés de l'écran global type Dialog
kwds = GetDlgOptions(self)
kwds['autoSizer'] = False
kwds['dicParams'] = GetDicParams(self)
kwds['dicOlv'] = {}
kwds['dicPied'] = dicPied
kwds['db'] = xdb.DB()
super().__init__(None, **kwds)
self.ordi = xuid.GetNomOrdi()
self.today = datetime.date.today()
if not date:
date = self.today
self.date = date
self.lstSaisons = SAISONS
ret = self.Init()
if ret == wx.ID_ABORT: self.Destroy()
self.Sizer()
# appel des données
self.oldParams = None
(self.qteZero, self.qteMini) = (True, True)
self.OnSaison(None)
def GetRegions():
# Importation de la base
DB = xdb.DB(nomFichier="srcNoelite/Data/Geographie.dat")
req = """ SELECT num_region, region
FROM regions"""
DB.ExecuterReq(req)
listeRegions = DB.ResultatReq()
DB.Close()
dictRegions = {}
for num_region, region in listeRegions:
dictRegions[num_region] = region
return dictRegions
def PostMouvements(champs=[],mouvements=[[],]):
# uddate des champs d'un mouvement, l'ID en dernière position
db = xdb.DB()
retour = True
for mouvement in mouvements:
ret = db.ReqMAJ('stMouvements',
nomChampID=champs[-1],
ID = mouvement[-1],
lstChamps=champs[:-1],lstValues=mouvement[:-1],
mess="UTILS_Stocks.PostMouvements")
if ret != 'ok':
retour = False
db.Close()
return retour
def SetDBoldAdresse(DB, IDindividu=None, adresse="\n\n\n\n\n\n\n"):
if not DB: DB = xdb.DB()
# Stocke dans la base de donnée l'adresse avec 4 lignes obligatoires pour rue, 2 pour ville et cp à part.
rue_resid, cp_resid, ville_resid = LstAdresseToChamps(adresse)
# envoi dans la base de donnée
lstDonnees = [("rue_resid", rue_resid), ("cp_resid", cp_resid),
("ville_resid", ville_resid), ("adresse_normee", 1),
("date_modification",
xdb.DateDDEnDateEng(datetime.date.today()))]
ret = DB.ReqMAJ("exadresses",
lstDonnees,
"IDindividu",
IDindividu,
mess="Insert exAdresse")
return ret
def SetDBadresse(DB, IDindividu=None, adresse="\n\n\n\n\n\n\n"):
# Stocke dans la base de donnée l'adresse avec 4 lignes obligatoires pour rue, 2 pour ville et cp à part.
if not DB: DB = xdb.DB()
def ajustetype(adresse):
#-------- validation
if isinstance(adresse, (str)):
# adresse en un texte de 6 ou 7 lignes dont la 5eme regroupe CP+ville
lstAdresse = adresse.split("\n")
if len(lstAdresse) == 5: lstAdresse.append("")
if len(lstAdresse) == 6:
lstcpvil = lstAdresse[4].split(" ")
cp = lstcpvil[0]
ville = lstAdresse[4][len(cp):].strip()
lstAdresse.append("")
lstAdresse[6] = lstAdresse[5]
lstAdresse[5] = ville
lstAdresse[4] = cp
elif isinstance(adresse, (list, tuple)):
lstAdresse = adresse
else:
mess = "Adresse d'un type non géré!\n\nvariable de type '%s'" % type(
adresse)
wx.MessageBox(mess)
return mess
if len(lstAdresse) != 7:
mess = "Adresse n'ayant pas sept lignes!\n\n%s" % str(adresse)
wx.MessageBox(mess)
return mess
return lstAdresse
lstAdresse = ajustetype(adresse)
if not IDindividu or int(IDindividu) == 0:
return "pas d'IDindividu fourni!"
# enlever les ponctuations, et mettre en majuscules les éléments significatifs
lstAdresse = Normalisation(lstAdresse)
rue_resid, cp_resid, ville_resid = LstAdresseToChamps(lstAdresse)
lstDonnees = [("rue_resid", rue_resid), ("cp_resid", cp_resid),
("ville_resid", ville_resid), ("adresse_normee", 1),
("adresse_auto", None)]
# envoi dans la base de donnée
ret = DB.ReqMAJ("individus",
lstDonnees,
"IDindividu",
IDindividu,
mess="Insert Adresse Individu")
return ret
def __init__(self, mode='individus', titre=TITRE, intro=INTRO):
self.limitSql = LIMITSQL
self.db = xdb.DB()
wx.Dialog.__init__(self,
None,
-1,
pos=(50, 80),
style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER)
if nuu.VerificationDroitsUtilisateurActuel("individus_fiche",
"consulter") == False:
if self.IsModal():
self.EndModal(wx.ID_CANCEL)
else:
self.Destroy()
self.mode = mode
self.SetTitle(NOM_MODULE)
self.choix = None
# Bandeau
self.ctrl_bandeau = xbandeau.Bandeau(
self,
titre=titre,
texte=intro,
hauteur=18,
nomImage="xpy/Images/32x32/Matth.png")
# composition des objets
if self.mode == 'familles':
dicOlv = dicOlvFamilles()
self.getDonnees = self.GetFamilles
else:
dicOlv = dicOlvIndividus()
self.getDonnees = self.GetIndividus
dicOlv['getDonnees'] = self.getDonnees
pnlOlv = Pnl_tableau(self, dicOlv)
self.ctrlOlv = pnlOlv.ctrlOlv
self.olv = pnlOlv
self.pnlPied = xgtr.PNL_pied(self, {'autoSizer': False, 'lstBtns': []})
# Initialisations
self.pnlPied.lstBtns = GetLstBtns(self.pnlPied, self.olv)
btnFermer = self.pnlPied.lstBtns[1]
self.Bind(wx.EVT_BUTTON, self.OnFermer, btnFermer)
self.pnlPied.Sizer()
self.__set_properties()
self.Sizer()
self.ctrlOlv.MAJ()
def InsertActions(listeActions=[], db=None):
""" dictAction = { IDutilisateur : None, IDfamille : None, IDindividu : None, IDcategorie : None, action : u"" } """
date = str(datetime.date.today())
heure = "%02d:%02d:%02d" % (datetime.datetime.now().hour,
datetime.datetime.now().minute,
datetime.datetime.now().second)
# Traitement des actions
listeAjouts = []
for dictAction in listeActions:
if "IDutilisateur" in dictAction.keys():
IDutilisateur = dictAction["IDutilisateur"]
else:
IDutilisateur = nuu.GetIDutilisateur()
if "IDfamille" in dictAction.keys():
IDfamille = dictAction["IDfamille"]
else:
IDfamille = None
if "IDindividu" in dictAction.keys():
IDindividu = dictAction["IDindividu"]
else:
IDindividu = None
if "IDcategorie" in dictAction.keys():
IDcategorie = dictAction["IDcategorie"]
else:
IDcategorie = None
if "action" in dictAction.keys():
action = dictAction["action"]
else:
action = u""
if len(action) >= 500:
action = action[:495] + "..." # Texte limité à 499 caractères
listeAjouts.append((date, heure, IDutilisateur, IDfamille, IDindividu,
IDcategorie, action))
# Enregistrement dans la base
if len(listeAjouts) > 0:
req = u"INSERT INTO historique (date, heure, IDutilisateur, IDfamille, IDindividu, IDcategorie, action) VALUES (?, ?, ?, ?, ?, ?, ?)"
if db == None:
db = xdb.DB()
db.Executermany(req, listeAjouts, commit=False)
db.Commit()
db.Close()
else:
db.Executermany(req, listeAjouts, commit=False)
def Init(self):
self.db = xdb.DB()
# définition de l'OLV
self.ctrlOlv = None
# récup des modesReglements nécessaires pour passer du texte à un ID d'un mode ayant un mot en commun
for colonne in self.dicOlv['lstColonnes']:
if 'mode' in colonne.valueGetter:
choicesMode = colonne.choices
if 'libelle' in colonne.valueGetter:
self.libelleDefaut = colonne.valueSetter
self.pnlOlv = PNL_corps(self, self.dicOlv)
#self.pnlPied = PNL_pied(self, dicPied)
self.ctrlOlv = self.pnlOlv.ctrlOlv
self.Bind(wx.EVT_CLOSE,self.OnClose)
self.InitOlv()
"""
def GetDBCorrespondant(IDfamille):
# Importation de la base par défaut
DB = xdb.DB()
IDindividu = None
designIndiv = None
lstChamps = [
'zero', 'IDindividu', 'titulaire', 'prenom', 'nom', 'rue', 'cp',
'ville'
]
req = """SELECT 0,rattachements.IDindividu,rattachements.titulaire, individus.prenom, individus.nom,
individus.rue_resid, individus.cp_resid, individus.ville_resid
FROM rattachements
INNER JOIN individus ON rattachements.IDindividu = individus.IDindividu
WHERE (((rattachements.IDfamille) = %d));
""" % IDfamille
DB.ExecuterReq(req)
lstMembres = DB.ResultatReq()
if len(lstMembres) == 0:
wx.MessageBox("Famille '%d' sans aucun membre!" % IDfamille,
style=wx.ICON_ERROR)
return wx.ID_ABORT
DB.Close()
lstColonnes = ["0", "ind", "tit", "prenom", "nom", "rue", "cp", "ville"]
lstWcol = [0, 80, 30, 120, 120, 180, 60, 180]
dlg = xcl.DialogAffiche(titre=u"Choisissez un membre ayant une adresse",
intro=u"Sinon allez gérer les individus",
lstDonnees=lstMembres,
lstColonnes=lstColonnes,
lstWcol=lstWcol)
ret = dlg.ShowModal()
if ret == wx.OK and dlg.GetChoix():
ix = lstMembres.index(dlg.GetChoix())
IDindividu = lstMembres[ix][lstChamps.index('IDindividu')]
prenom = lstMembres[ix][lstChamps.index('prenom')]
nom = lstMembres[ix][lstChamps.index('nom')]
designIndiv = "%d - %s %s" % (IDindividu, prenom, nom)
dlg.Destroy()
ix = lstChamps.index('ville')
lstVilles = [
x[ix] for x in lstMembres if (x[ix] != None) and (len(x[ix]) > 0)
]
if len(lstVilles) == 0:
# gestion d'absence d'une adresse dans la famille. ID_APPLI est un flag en retour
return (wx.ID_APPLY, IDindividu, designIndiv)
return IDindividu
def GetImmosComposants(self,lstChamps):
# appel des composants dans les tables immos
self.db.Close()
self.db = xdb.DB()
dlg = self.parent
req = """
SELECT %s
FROM immobilisations
INNER JOIN immosComposants ON immobilisations.IDimmo = immosComposants.IDimmo;
""" % (",".join(lstChamps))
lstDonnees = []
retour = self.db.ExecuterReq(req, mess='UTILS_Noegest.GetImmosComposants')
if retour == "ok":
recordset = self.db.ResultatReq()
lstDonnees = [list(x) for x in recordset]
dlg.ctrlOlv.lstDonnees = lstDonnees
dlg.ctrlOlv.MAJ()
dlg.ctrlOlv._FormatAllRows()
return
