def f_schema_liste_classes(regle, _):
'''#aide||cree des objets virtuels ou reels a partir des schemas (1 objet par classe)
#helper||chargeur
#pattern||;;;liste_schema;C;?=reel
'''
schema = regle.stock_params.schemas.get(regle.params.cmp1.val)
if schema is None:
return False
virtuel = True
if regle.params.cmp2.val:
virtuel = False
for i in schema.classes:
niveau, classe = i
obj2 = Objet(niveau,
classe,
format_natif='interne',
conversion='virtuel' if virtuel else None,
schema=schema.classes[i])
obj2.initattr()
try:
regle.stock_param.moteur.traite_objet(
obj2, regle.branchements.brch["next:"])
except StopIteration as abort:
# print("intercepte abort",abort.args[0])
if abort.args[0] == '2':
break
raise
return True
def f_schema_liste_classes(regle, _):
"""#aide||cree des objets virtuels ou reels a partir des schemas (1 objet par classe)
#aide_spec||liste_schema;nom;?reel
#aide_spec2||cree des objets virtuels par defaut sauf si on precise reel
#helper||chargeur
#schema||change_schema
#pattern||?=#schema;?C;?A;liste_schema;C;?=reel
"""
schema = regle.getschema(regle.params.cmp1.val)
if schema is None:
return False
virtuel = not regle.params.cmp2.val
classes = list(schema.classes)
for i in classes:
niveau, classe = i
obj2 = Objet(
niveau,
classe,
format_natif="interne",
conversion="virtuel" if virtuel else None,
schema=schema.classes[i],
)
obj2.initattr()
try:
regle.stock_param.moteur.traite_objet(
obj2, regle.branchements.brch["gen"])
except StopIteration as abort:
# print("intercepte abort",abort.args[0])
if abort.args[0] == 2:
break
raise
return True
def _execbatch(regle, obj):
"""execute un batch"""
if obj is None: # pas d'objet on en fabrique un sur mesure
obj = Objet("_batch", "_batch", format_natif="interne")
obj.attributs["nom"] = regle.getvar("_nom_batch", "batch")
# on lui donne un nom
_, commande, entree, sortie, params = regle.prepare(regle, obj)
processor = regle.stock_param.getpyetl(commande,
liste_params=params,
entree=entree,
rep_sortie=sortie)
if processor is None:
return False
processor.process(debug=1)
renseigne_attributs_batch(regle, obj, processor.retour)
return True
def traitement_virtuel(self, unique=0):
''' cree un objet virtuel et le traite pour toutes les classes non utilisees '''
# if self.debug != 0:
# print("moteur: traitement virtuel", unique)
LOGGER.info("traitement virtuel" + str(unique))
# for i in self.regles:
# print (i.chargeur, i)
if unique: # on lance un virtuel unique pour les traitements sans entree
# on lance un virtuel unique puis on verifie toutes les regles de chargement
self.traite_regles_chargement()
else:
for sch in list(self.mapper.schemas.values()):
if sch.origine in 'LB' and not sch.nom.startswith('#'):
print('moteur: traitement schema', sch.nom, sch.origine,
len(sch.classes))
LOGGER.info("traitement schema" + sch.nom + ' ' +
sch.origine)
#(on ne traite que les schemas d'entree')
for schemaclasse in list(sch.classes.values()):
if schemaclasse.utilise:
# print ('traitement virtuel classe ignoree',j.identclasse)
continue
print('traitement objet virtuel ',
schemaclasse.identclasse)
groupe, classe = schemaclasse.identclasse
obj = Objet(groupe,
classe,
conversion='virtuel',
schema=schemaclasse)
obj.attributs['#categorie'] = 'traitement_virtuel'
# obj = Objet(groupe, classe)
# obj.virtuel = True
# obj.setschema(schemaclasse)
# obj.initattr()
obj.attributs['#type_geom'] = schemaclasse.info[
"type_geom"]
self.traite_objet(obj, self.regles[0])
def f_creobj(regle, obj):
"""#aide||cree des objets de test pour les tests fonctionnels
#aide_spec||parametres:liste d'attributs,liste valeurs,nom(niv,classe),nombre
#pattern||L;LC;?L;creobj;C;?N||sortie
#test||obj||^A;1;;creobj;essai;2||cnt;3
"""
noms = regle.params.att_sortie.liste
vals = regle.getlist_entree(obj)
tmp = regle.params.cmp1.liste
# print ('testobj: ',regle.params.cmp1,noms,vals)
ident = (tmp[0], tmp[1]) if len(tmp) == 2 else ("niv_test", tmp[0])
schema = regle.getschema(regle.getvar("schema_entree"))
if schema is None:
schema = regle.stock_param.init_schema("schema_test",
origine="B",
stable=False)
gen_schema = ident not in schema.classes
schemaclasse = schema.setdefault_classe(ident)
if gen_schema:
schemaclasse.info["type_geom"] = "0"
# TODO gérer les dates
for nom, val in zip(noms, vals):
try:
int(val)
type_attribut = "E"
except (ValueError, TypeError):
try:
float(val)
type_attribut = "F"
except (ValueError, TypeError):
type_attribut = "T"
if gen_schema:
schemaclasse.stocke_attribut(nom, type_attribut=type_attribut)
nombre = int(
regle.params.cmp2.num) if regle.params.cmp2.num is not None else 1
for i in range(nombre):
obj2 = Objet(ident[0], ident[1], format_natif="interne")
obj2.setschema(schemaclasse)
obj2.attributs.update([j for j in zip(noms, vals)])
# print ("objet_test",obj2.attributs,obj2.schema.schema.nom)
obj2.setorig(i)
try:
regle.stock_param.moteur.traite_objet(
obj2, regle.branchements.brch["gen"])
except StopIteration as abort:
# print("intercepte abort",abort.args[0])
if abort.args[0] == 1:
continue
elif abort.args[0] == 2:
break
else:
raise
return True
def f_start(regle, obj):
"""#aide||ne fait rien mais envoie un objet virtuel dans le circuit
#pattern||;;;start;;
#test||rien||^;;;start||^;;;reel||cnt;1
"""
if obj: # on a deja un objet pas la peirn d'en refaire un
return True
obj2 = Objet('_declencheur',
'_autostart',
format_natif='interne',
conversion='virtuel')
print('start: declenchement ', obj2)
regle.stock_param.moteur.traite_objet(obj2,
regle.branchements.brch["next:"])
return True
def execbatch(regle, obj):
'''execute un batch'''
if obj is None: # pas d'objet on en fabrique un sur mesure
obj = Objet('_batch', '_batch', format_natif='interne')
_, commande, entree, sortie, params = prepare_batch_from_object(regle, obj)
processor = regle.stock_param.getpyetl(commande,
liste_params=params,
entree=entree,
rep_sortie=sortie)
if processor is None:
return False
processor.process(debug=1)
renseigne_attributs_batch(regle, obj, processor.retour)
return True
def f_start(regle, obj):
"""#aide||ne fait rien mais envoie un objet virtuel dans le circuit
#pattern||;;;start;;
#test||rien||^;;;start||^;;;reel||cnt;1
"""
# print ('start',obj)
if obj: # on a deja un objet pas la peine d'en refaire un
return True
obj2 = Objet("_declencheur",
"_start",
format_natif="interne",
conversion="virtuel")
# print('commande start: declenchement ', obj2)
regle.stock_param.moteur.traite_objet(obj2,
regle.branchements.brch["next"])
return True
def traite_regles_chargement(self):
''' declenche les regles de chargement pour les traitements sans entree'''
# if self.debug:
# print('moteur: regles de chargement pour un traitement sans entree')
self.regles[0].chargeur = True # on force la premiere
if self.regles[0].mode == "start": #on prends la main dans le script
self.regles[0].fonc(self.regles[0], None)
return
for i in self.regles:
# print ('-------------------------------traite_charge ', i.declenchee ,i.chargeur,i )
if not i.declenchee and i.chargeur:
obj = Objet('_declencheur',
'_chargement',
format_natif='interne',
conversion='virtuel')
i.mode_chargeur = True
self.traite_objet(obj, i)
i.mode_chargeur = False
def f_creobj(regle, obj):
'''#aide||cree des objets de test pour les tests fonctionnels
#aide_spec||parametres:liste d'attributs,liste valeurs,nom(niv,classe),nombre
#pattern||L;LC;?L;creobj;C;?N||sortie
#test||obj||^A;1;;creobj;essai;2||cnt;3
'''
noms = regle.params.att_sortie.liste
vals = regle.params.val_entree.liste
tmp = regle.params.cmp1.liste
# print ('testobj: ',regle.params.cmp1)
ident = (tmp[0], tmp[1]) if len(tmp) == 2 else ('niv_test', tmp[0])
if regle.getvar("schema_entree"):
schema = regle.stock_param.schemas[regle.getvar("schema_entree")]
else:
schema = regle.stock_param.init_schema('schema_test',
origine='B',
stable=False)
gen_schema = ident not in schema.classes
schemaclasse = schema.setdefault_classe(ident)
#TODO gérer les dates
for nom, val in zip(noms, vals):
try:
int(val)
type_attribut = 'E'
except (ValueError, TypeError):
try:
float(val)
type_attribut = 'F'
except (ValueError, TypeError):
type_attribut = 'T'
if gen_schema:
schemaclasse.stocke_attribut(nom, type_attribut=type_attribut)
nombre = int(
regle.params.cmp2.num) if regle.params.cmp2.num is not None else 1
for i in range(nombre):
obj2 = Objet(ident[0], ident[1], format_natif='interne')
obj2.setschema(schemaclasse)
obj2.attributs.update([j for j in zip(noms, vals)])
# print ("objet_test",obj2.attributs,obj2.schema.schema.nom)
obj2.setorig(i)
try:
regle.stock_param.moteur.traite_objet(
obj2, regle.branchements.brch["next:"])
except StopIteration as abort:
# print("intercepte abort",abort.args[0])
if abort.args[0] == '2':
break
raise
return True
def traite_regles_chargement(self):
""" declenche les regles de chargement pour les traitements sans entree"""
# if self.debug:
# print('moteur: regles de chargement pour un traitement sans entree', self.regles[0].mode)
self.regles[0].chargeur = True # on force la premiere
# if self.regles[0].mode == "start": #on prends la main dans le script
# self.regles[0].fonc(self.regles[0], None)
# return
for i in self.regles:
# print ('-------------------------------traite_charge ', i.declenchee ,i.chargeur,i )
if not i.declenchee and i.chargeur:
if i.mode == "start": # on prends la main dans le script
i.fonc(i, None)
obj = Objet(
"_declencheur",
"_chargement",
format_natif="interne",
conversion="virtuel",
)
i.mode_chargeur = True
self.traite_objet(obj, i)
i.mode_chargeur = False
def liste_table_traite_stock(regle):
"""retourne la liste des tables du schema"""
liste = regle.schema_courant.classes.keys()
nom_groupe = regle.schema_courant.nom
nom_classe = "liste_tables"
schemaclasse = regle.schema_courant.setdefault_classe((nom_groupe, nom_classe))
schemaclasse.stocke_attribut("nom_schema", "T")
schemaclasse.stocke_attribut("nom_classe", "T")
for i in liste:
sch, nom = i
obj = Objet(nom_groupe, nom_classe)
obj.attributs["nom_schema"] = sch
obj.attributs["nom_classe"] = nom
obj.setschema(schemaclasse)
regle.stock_param.moteur.traite_objet(obj, regle.branchements.brch["gen"])
regle.nbstock = 0
regle.store = False
def traitement_virtuel(self, unique=0):
""" cree un objet virtuel et le traite pour toutes les classes non utilisees """
# if self.debug != 0:
# print("moteur: traitement virtuel", unique)
LOGGER.info("traitement virtuel :%s", "chargement" if unique else "virtuel")
# for i in self.regles:
# print (i.chargeur, i)
if unique: # on lance un virtuel unique pour les traitements sans entree
# on lance un virtuel unique puis on verifie toutes les regles de chargement
self.traite_regles_chargement()
else:
f_v = self.mapper.getvar("force_virtuel")
force_virtuel = False
if f_v == "1" or f_v.lower() == "all" or f_v.lower() == "true":
force_virtuel = True
elif self.mapper.worker and (f_v == "worker" or f_v == "w"):
force_virtuel = True
elif not self.mapper.worker and (f_v == "master" or f_v == "m"):
force_virtuel = True
for sch in list(self.mapper.schemas.values()):
# print("traitement virtuel: schema a traiter", sch.nom, sch.origine)
if sch.origine in "LB" and not sch.nom.startswith("#"):
# print(
# "moteur: traitement schema",
# sch.nom,
# sch.origine,
# len(sch.classes),
# )
LOGGER.info("traitement schema" + sch.nom + " " + sch.origine)
# (on ne traite que les schemas d'entree')
for schemaclasse in list(sch.classes.values()):
# print(
# "traitement virtuel", schemaclasse.nom, schemaclasse.utilise
# )
if schemaclasse.utilise and not force_virtuel:
# print(
# "traitement virtuel classe ignoree",
# schemaclasse.identclasse,
# )
continue
# if schemaclasse.identclasse == ("ELYEA", "E_PROGRA"):
# print(
# self.mapper.getvar("_wid"),
# "traitement virtuel classe",
# sch.nom,
# schemaclasse.identclasse,
# schemaclasse.utilise,
# schemaclasse.maxobj,
# )
# if not self.mapper.worker:
# print("traitement objet virtuel ", schemaclasse.identclasse)
groupe, classe = schemaclasse.identclasse
obj = Objet(
groupe, classe, conversion="virtuel", schema=schemaclasse
)
obj.attributs["#categorie"] = "traitement_virtuel"
obj.attributs["#type_geom"] = schemaclasse.info["type_geom"]
# print("tv:traitement obj", obj)
self.traite_objet(obj, self.regles[0])
def f_liste_selecteur(regle, obj):
"""#aide||cree des objets virtuels ou reels a partir d un selecteur (1 objet par classe)
#parametres_c||type tables;nom du schema
#parametres1||idclasse resultante;;#1;#2
#parametres2||;;#1;#2
#parametres3||;#1;#2
#aide_spec||cree des objets reels par defaut sauf si on mets la variable virtuel a 1
#aide_spec3||cree un objet par classe
#schema||change_schema
#pattern1||A.C;;;dblist;?C;?C
#pattern2||=#obj;;;dblist;?C;?C
#pattern3||;;;dblist;?C;?C
"""
selecteur = setdb(regle, obj)
virtuel = regle.getvar("virtuel") == "1"
if regle.idclasse:
niveau, classe = regle.idclasse
schemaclasse = regle.schema.get_classe(
regle.idclasse) if regle.schema else None
# print("traitement liste selecteur", selecteur)
for i in selecteur.get_classes():
idbase, selinfo = i
idsel, description = selinfo
# print(" lecture selecteur", i, "->", idbase, idsel, description)
nsel, csel = idsel
server = ""
infos = {
"#sel_codebase": idbase,
"#sel_niveau": nsel,
"#sel_classe": csel,
"#sel_host": regle.getvar("server_" + idbase),
"#sel_user": regle.getvar("user_" + idbase),
"#sel_base": regle.getvar("base_" + idbase),
"#sel_type_base": regle.getvar("db_" + idbase),
}
# print("infos selecteur", infos)
schemabase = selecteur.baseselectors[idbase].schemabase
infoschema = {
i if i.startswith("#") else ("#" + i): j
for i, j in itertools.chain(schemabase.metas.items(),
schemabase.classes[idsel].info.items())
}
infos.update(infoschema)
infos["#alias_niveau"] = schemabase.alias_groupes.get(nsel, "")
if regle.params.pattern == "2":
obj2 = obj.dupplique()
obj2.attributs.update(infos)
if regle.idclasse:
obj2.setschema(schemaclasse)
else:
if not regle.idclasse:
niveau, classe = idsel
if regle.schema:
schemaclasse = selecteur.schemabase.get_classe(idsel)
else:
schemaclasse = None
obj2 = Objet(
niveau,
classe,
format_natif="interne",
conversion="virtuel" if virtuel else None,
attributs=infos,
schema=schemaclasse,
)
obj2.initattr()
if regle.debug:
obj2.debug("cree", attlist=regle.champsdebug)
regle.debug -= 1
try:
regle.stock_param.moteur.traite_objet(
obj2, regle.branchements.brch["gen"])
except StopIteration as abort:
# print("intercepte abort",abort.args[0])
if abort.args[0] == 2:
break
raise
return True