from Noyau.N_ASSD import ASSD,assd
from Noyau.N_GEOM import GEOM,geom
from Noyau.N_CO import CO
+import Accas
# fin attention
from Extensions import parametre
import I_OBJECT
+import CONNECTOR
class MCSIMP(I_OBJECT.OBJECT):
if type(val) == types.FloatType :
# CCAR : Normalement str fait un travail correct
#txt=txt + i*',' + repr_float(val)
- txt=txt + i*',' + str(val)
+ clefobj=self.GetNomConcept()
+ if self.jdc.appli.dict_reels.has_key(clefobj):
+ if self.jdc.appli.dict_reels[clefobj].has_key(val):
+ txt=txt + i*',' +self.jdc.appli.dict_reels[clefobj][val]
+ else :
+ txt=txt + i*',' + str(val)
+ else :
+ txt=txt + i*',' + str(val)
elif isinstance(val,ASSD):
txt = txt + i*',' + val.get_name()
#PN
def isoblig(self):
return self.definition.statut=='o'
+ def valid_valeur(self,new_valeur):
+ """
+ Verifie que la valeur passee en argument (new_valeur) est valide
+ sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+ """
+ old_valeur=self.valeur
+ old_val=self.val
+ self.valeur = new_valeur
+ self.val = new_valeur
+ self.state="modified"
+ validite=self.isvalid()
+ self.valeur = old_valeur
+ self.val = old_valeur
+ self.state="modified"
+ self.isvalid()
+ return validite
+
+ def valid_valeur_partielle(self,new_valeur):
+ """
+ Verifie que la valeur passee en argument (new_valeur) est partiellement valide
+ sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+ """
+ old_valeur=self.valeur
+ old_val=self.val
+
+ self.valeur = new_valeur
+ self.val = new_valeur
+ self.state="modified"
+ validite=0
+ if self.isvalid():
+ validite=1
+ elif self.definition.validators :
+ validite=self.definition.validators.valide_liste_partielle(new_valeur)
+
+ if validite==0:
+ min,max=self.get_min_max()
+ if len(new_valeur) < min :
+ validite=1
+
+ self.valeur = old_valeur
+ self.val = old_valeur
+ self.state="modified"
+ self.isvalid()
+ return validite
+
def set_valeur(self,new_valeur,evaluation='oui'):
+ #print "set_valeur",new_valeur
self.init_modif()
self.valeur = new_valeur
self.val = new_valeur
+ if self.definition.position == 'global' :
+ self.etape.deep_update_condition_bloc()
+ elif self.definition.position == 'global_jdc' :
+ self.jdc.deep_update_condition_bloc()
+ else:
+ self.parent.update_condition_bloc()
self.fin_modif()
return 1
Essaie d'évaluer new_valeur comme une SD, une déclaration Python
ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
"""
- sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
+ #print "eval_valeur",new_valeur
+ sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
+ #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
if sd :
return sd,1
else:
d={}
# On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
- from Accas import EVAL
- d['EVAL']=EVAL
+ d['EVAL']=Accas.EVAL
try :
objet = eval(new_valeur,d)
return objet,1
except:
return None
+ def update_concept(self,sd):
+ if type(self.valeur) in (types.ListType,types.TupleType) :
+ if sd in self.valeur:self.fin_modif()
+ else:
+ if sd == self.valeur:self.fin_modif()
def delete_concept(self,sd):
"""
Met a jour la valeur du mot cle simple suite à la disparition
du concept sd
"""
+ #print "delete_concept",sd
if type(self.valeur) == types.TupleType :
if sd in self.valeur:
+ self.init_modif()
self.valeur=list(self.valeur)
self.valeur.remove(sd)
- self.init_modif()
+ self.fin_modif()
elif type(self.valeur) == types.ListType:
if sd in self.valeur:
- self.valeur.remove(sd)
self.init_modif()
+ self.valeur.remove(sd)
+ self.fin_modif()
else:
if self.valeur == sd:
+ self.init_modif()
self.valeur=None
self.val=None
- self.init_modif()
+ self.fin_modif()
def replace_concept(self,old_sd,sd):
"""
Met a jour la valeur du mot cle simple suite au remplacement
du concept old_sd
"""
+ #print "replace_concept",old_sd,sd
if type(self.valeur) == types.TupleType :
if old_sd in self.valeur:
+ self.init_modif()
self.valeur=list(self.valeur)
i=self.valeur.index(old_sd)
self.valeur[i]=sd
- self.init_modif()
+ self.fin_modif()
elif type(self.valeur) == types.ListType:
if old_sd in self.valeur:
+ self.init_modif()
i=self.valeur.index(old_sd)
self.valeur[i]=sd
- self.init_modif()
+ self.fin_modif()
else:
if self.valeur == old_sd:
+ self.init_modif()
self.valeur=sd
self.val=sd
- self.init_modif()
+ self.fin_modif()
def set_valeur_co(self,nom_co):
"""
Affecte à self l'objet de type CO et de nom nom_co
"""
+ #print "set_valeur_co",nom_co
step=self.etape.parent
if nom_co == None or nom_co == '':
new_objet=None
else:
- # Pour le moment on importe en local le CO de Accas.
- # Si problème de perfs, il faudra faire autrement
- from Accas import CO
# Avant de créer un concept il faut s'assurer du contexte : step
# courant
sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
CONTEXT.unset_current_step()
CONTEXT.set_current_step(step)
step.set_etape_context(self.etape)
- new_objet = CO(nom_co)
+ new_objet = Accas.CO(nom_co)
CONTEXT.unset_current_step()
CONTEXT.set_current_step(cs)
self.init_modif()
# On force l'enregistrement de new_objet en tant que concept produit
# de la macro en appelant get_type_produit avec force=1
self.etape.get_type_produit(force=1)
+ #print "set_valeur_co",new_objet
return 1,"Concept créé"
def verif_existence_sd(self):
Vérifie que les structures de données utilisées dans self existent bien dans le contexte
avant étape, sinon enlève la référence à ces concepts
"""
+ #print "verif_existence_sd"
+ # Attention : possible probleme avec include
l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
if type(self.valeur) in (types.TupleType,types.ListType) :
l=[]
+ self.init_modif()
for sd in self.valeur:
if isinstance(sd,ASSD) :
if sd in l_sd_avant_etape :
else:
l.append(sd)
self.valeur=tuple(l)
- # Est ce init_modif ou init_modif_up
- # Normalement init_modif va avec fin_modif
- self.init_modif()
self.fin_modif()
else:
if isinstance(self.valeur,ASSD) :
if self.valeur not in l_sd_avant_etape :
- self.valeur = None
self.init_modif()
+ self.valeur = None
self.fin_modif()
def get_min_max(self):
self.cr.fatal("None n'est pas une valeur autorisée")
else:
# type,into ...
- if v.__class__.__name__=='PARAMETRE' or v.__class__.__name__ == 'ITEM_PARAMETRE':
+ if v.__class__.__name__ in ('PARAMETRE' , 'EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
verif_type=1
else:
verif_type=self.verif_type(val=v,cr=None)
if type(v) == types.TupleType :
new_val=[]
for i in v:
- if i.__class__.__name__ != 'PARAMETRE':
- if i.__class__.__name__ != 'ITEM_PARAMETRE':
- new_val.append(i)
+ if i.__class__.__name__ not in ('PARAMETRE','EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
+ new_val.append(i)
if new_val != [] :
verif_type=self.verif_type(val=new_val,cr=cr)
else :
# Cas d une liste de paramétre
verif_type= 1
else:
- verif_type=self.verif_type(val=v,cr=None)
+ verif_type=self.verif_type(val=v,cr=cr)
valid = verif_type*self.verif_into(cr=cr)*self.verif_card(cr=cr)
#
# On verifie les validateurs s'il y en a et si necessaire (valid == 1)