Ihm/I_MCSIMP.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 import types,string
  22 import traceback
  23 from copy import copy
  24 from repr import Repr
  25 myrepr = Repr()
  26 myrepr.maxstring = 100
  27 myrepr.maxother = 100
  28
  29 from Noyau.N_utils import repr_float
  30
  31 # Attention : les classes ASSD,.... peuvent etre surchargées
  32 # dans le package Accas. Il faut donc prendre des précautions si
  33 # on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
  34 # Si on veut créer des objets comme des CO avec les classes du noyau
  35 # ils n'auront pas les conportements des autres packages (pb!!!)
  36 # Il vaut mieux les importer d'Accas mais problème d'import circulaire,
  37 # on ne peut pas les importer au début.
  38 # On fait donc un import local quand c'est nécessaire (peut occasionner
  39 # des pbs de prformance).
  40 from Noyau.N_ASSD import ASSD,assd
  41 from Noyau.N_GEOM import GEOM,geom
  42 from Noyau.N_CO import CO
  43 import Accas
  44 # fin attention
  45
  46 from Extensions import parametre
  47 from Extensions import param2
  48 import I_OBJECT
  49 import CONNECTOR
  50
  51 class MCSIMP(I_OBJECT.OBJECT):
  52
  53   def GetNomConcept(self):
  54       p=self
  55       while p.parent :
  56          try :
  57             nomconcept=p.get_sdname()
  58             return nomconcept
  59          except:
  60             try :
  61                nomconcept= p.object.get_sdname()
  62                return nomconcept
  63             except :
  64                pass
  65          p=p.parent
  66       return ""
  67
  68   def GetText(self):
  69     """
  70         Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
  71         pointé par self
  72     """
  73
  74     if self.valeur == None :
  75       return None
  76     elif type(self.valeur) == types.FloatType :
  77       # Traitement d'un flottant isolé
  78       # txt = repr_float(self.valeur)
  79       # Normalement str fait un travail correct
  80       txt = str(self.valeur)
  81       clefobj=self.GetNomConcept()
  82       if self.jdc.appli.dict_reels.has_key(clefobj):
  83         if self.jdc.appli.dict_reels[clefobj].has_key(self.valeur):
  84            txt=self.jdc.appli.dict_reels[clefobj][self.valeur]
  85     elif type(self.valeur) in (types.ListType,types.TupleType) :
  86       # Traitement des listes
  87       txt='('
  88       i=0
  89       for val in self.valeur:
  90         if type(val) == types.FloatType :
  91            # CCAR : Normalement str fait un travail correct
  92            #txt=txt + i*',' + repr_float(val)
  93            clefobj=self.GetNomConcept()
  94            if self.jdc.appli.dict_reels.has_key(clefobj):
  95               if self.jdc.appli.dict_reels[clefobj].has_key(val):
  96                  txt=txt + i*',' +self.jdc.appli.dict_reels[clefobj][val]
  97               else :
  98                  txt=txt + i*',' + str(val)
  99            else :
 100               txt=txt + i*',' + str(val)
 101         elif isinstance(val,ASSD):
 102            txt = txt + i*',' + val.get_name()
 103     #PN
 104     # ajout du elif
 105         elif type(val) == types.InstanceType and val.__class__.__name__ in  ('PARAMETRE','PARAMETRE_EVAL'):
 106            txt = txt + i*','+ str(val)
 107         else:
 108            txt = txt + i*','+ myrepr.repr(val)
 109         i=1
 110       txt=txt+')'
 111     elif isinstance(self.valeur,ASSD):
 112       # Cas des ASSD
 113       txt=self.getval()
 114     elif type(self.valeur) == types.InstanceType and self.valeur.__class__.__name__ in  ('PARAMETRE','PARAMETRE_EVAL'):
 115       # Cas des PARAMETRES
 116       txt=str(self.valeur)
 117     else:
 118       # Traitement des autres cas
 119       txt = myrepr.repr(self.valeur)
 120
 121     # txt peut etre une longue chaine sur plusieurs lignes.
 122     # Il est possible de tronquer cette chaine au premier \n et
 123     # de limiter la longueur de la chaine a 30 caracteres. Cependant
 124     # ceci provoque une perte d'information pour l'utilisateur
 125     # Pour le moment on retourne la chaine telle que
 126     return txt
 127
 128   def getval(self):
 129     """
 130        Retourne une chaîne de caractère représentant la valeur de self
 131     """
 132     val=self.valeur
 133     if type(val) == types.FloatType :
 134       clefobj=self.GetNomConcept()
 135       if self.jdc.appli.dict_reels.has_key(clefobj):
 136         if self.jdc.appli.dict_reels[clefobj].has_key(val):
 137            return self.jdc.appli.dict_reels[clefobj][val]
 138     if type(val) != types.TupleType :
 139       try:
 140         return val.get_name()
 141       except:
 142         return val
 143     else :
 144       s='( '
 145       for item in val :
 146         try :
 147           s=s+item.get_name()+','
 148         except:
 149           s=s+`item`+','
 150       s=s+' )'
 151       return s
 152
 153   def wait_co(self):
 154     """
 155         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
 156         qui n'existe pas encore (type CO()), 0 sinon
 157     """
 158     for typ in self.definition.type:
 159       if type(typ) == types.ClassType :
 160         if issubclass(typ,CO) :
 161            return 1
 162     return 0
 163
 164   def wait_assd(self):
 165     """
 166         Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
 167         ou dérivé, 0 sinon
 168     """
 169     for typ in self.definition.type:
 170       if type(typ) == types.ClassType :
 171         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
 172           return 1
 173     return 0
 174
 175   def wait_assd_or_geom(self):
 176     """
 177          Retourne 1 si le mot-clé simple attend un objet de type
 178          assd, ASSD, geom ou GEOM
 179          Retourne 0 dans le cas contraire
 180     """
 181     for typ in self.definition.type:
 182       if type(typ) == types.ClassType :
 183         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
 184           return 1
 185     return 0
 186
 187   def wait_geom(self):
 188     """
 189          Retourne 1 si le mot-clé simple attend un objet de type GEOM
 190          Retourne 0 dans le cas contraire
 191     """
 192     for typ in self.definition.type:
 193       if type(typ) == types.ClassType :
 194         if issubclass(typ,GEOM) : return 1
 195     return 0
 196
 197   def wait_TXM(self):
 198     """
 199          Retourne 1 si le mot-clé simple attend un objet de type TXM
 200          Retourne 0 dans le cas contraire
 201     """
 202     for typ in self.definition.type:
 203       if typ == 'TXM' :return 1
 204     return 0
 205
 206   def get_liste_valeurs(self):
 207     """
 208     """
 209     if self.valeur == None:
 210       return []
 211     elif type(self.valeur) == types.TupleType:
 212       return list(self.valeur)
 213     elif type(self.valeur) == types.ListType:
 214       return self.valeur
 215     else:
 216       return [self.valeur]
 217
 218   def isoblig(self):
 219     return self.definition.statut=='o'
 220
 221   def valid_valeur(self,new_valeur):
 222       """
 223         Verifie que la valeur passee en argument (new_valeur) est valide
 224         sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
 225       """
 226       old_valeur=self.valeur
 227       old_val=self.val
 228       self.valeur = new_valeur
 229       self.val = new_valeur
 230       self.state="modified"
 231       validite=self.isvalid()
 232       self.valeur = old_valeur
 233       self.val = old_valeur
 234       self.state="modified"
 235       self.isvalid()
 236       return validite
 237
 238   def valid_valeur_partielle(self,new_valeur):
 239       """
 240         Verifie que la valeur passee en argument (new_valeur) est partiellement valide
 241         sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
 242       """
 243       old_valeur=self.valeur
 244       old_val=self.val
 245
 246       self.valeur = new_valeur
 247       self.val = new_valeur
 248       self.state="modified"
 249       validite=0
 250       if self.isvalid():
 251          validite=1
 252       elif self.definition.validators :
 253          validite=self.definition.validators.valide_liste_partielle(new_valeur)
 254
 255       if validite==0:
 256          min,max=self.get_min_max()
 257          if len(new_valeur) < min :
 258             validite=1
 259
 260       self.valeur = old_valeur
 261       self.val = old_valeur
 262       self.state="modified"
 263       self.isvalid()
 264       return validite
 265
 266   def update_condition_bloc(self):
 267       """ Met a jour les blocs conditionnels dependant du mot cle simple self
 268       """
 269       if self.definition.position == 'global' :
 270          self.etape.deep_update_condition_bloc()
 271       elif self.definition.position == 'global_jdc' :
 272          self.jdc.deep_update_condition_bloc()
 273       else:
 274          self.parent.update_condition_bloc()
 275
 276   def set_valeur(self,new_valeur,evaluation='oui'):
 277         #print "set_valeur",new_valeur
 278         self.init_modif()
 279         self.valeur = new_valeur
 280         self.val = new_valeur
 281         self.update_condition_bloc()
 282         self.fin_modif()
 283         return 1
 284
 285   def eval_valeur(self,new_valeur):
 286     """
 287         Essaie d'évaluer new_valeur comme une SD, une déclaration Python
 288         ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
 289     """
 290     sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
 291     #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
 292     #print sd
 293     if sd :
 294       return sd,1
 295     lsd = self.jdc.cherche_list_avant(self.etape,new_valeur)
 296     if lsd :
 297       return lsd,1
 298     else:
 299       d={}
 300       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
 301       d['EVAL']=Accas.EVAL
 302       try :
 303         objet = eval(new_valeur,d)
 304         return objet,1
 305       except Exception:
 306         itparam=self.cherche_item_parametre(new_valeur)
 307         if itparam:
 308              return itparam,1
 309         try :
 310              object=eval(new_valeur.valeur,d)
 311         except :
 312              pass
 313         if CONTEXT.debug : traceback.print_exc()
 314         return None,0
 315
 316   def cherche_item_parametre (self,new_valeur):
 317         try:
 318           nomparam=new_valeur[0:new_valeur.find("[")]
 319           indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
 320           for p in self.jdc.params:
 321              if p.nom == nomparam :
 322                 if int(indice) < len(p.get_valeurs()):
 323                    itparam=parametre.ITEM_PARAMETRE(p,int(indice))
 324                    return itparam
 325           return None
 326         except:
 327           return None
 328
 329   def update_concept(self,sd):
 330     if type(self.valeur) in (types.ListType,types.TupleType) :
 331        if sd in self.valeur:self.fin_modif()
 332     else:
 333        if sd == self.valeur:self.fin_modif()
 334
 335   def delete_concept(self,sd):
 336     """
 337         Inputs :
 338            - sd=concept detruit
 339         Fonction :
 340         Met a jour la valeur du mot cle simple suite à la disparition
 341         du concept sd
 342     """
 343     #print "delete_concept",sd
 344     if type(self.valeur) == types.TupleType :
 345       if sd in self.valeur:
 346         self.init_modif()
 347         self.valeur=list(self.valeur)
 348         self.valeur.remove(sd)
 349         self.fin_modif()
 350     elif type(self.valeur) == types.ListType:
 351       if sd in self.valeur:
 352         self.init_modif()
 353         self.valeur.remove(sd)
 354         self.fin_modif()
 355     else:
 356       if self.valeur == sd:
 357         self.init_modif()
 358         self.valeur=None
 359         self.val=None
 360         self.fin_modif()
 361
 362   def replace_concept(self,old_sd,sd):
 363     """
 364         Inputs :
 365            - old_sd=concept remplacé
 366            - sd=nouveau concept
 367         Fonction :
 368         Met a jour la valeur du mot cle simple suite au remplacement
 369         du concept old_sd
 370     """
 371     #print "replace_concept",old_sd,sd
 372     if type(self.valeur) == types.TupleType :
 373       if old_sd in self.valeur:
 374         self.init_modif()
 375         self.valeur=list(self.valeur)
 376         i=self.valeur.index(old_sd)
 377         self.valeur[i]=sd
 378         self.fin_modif()
 379     elif type(self.valeur) == types.ListType:
 380       if old_sd in self.valeur:
 381         self.init_modif()
 382         i=self.valeur.index(old_sd)
 383         self.valeur[i]=sd
 384         self.fin_modif()
 385     else:
 386       if self.valeur == old_sd:
 387         self.init_modif()
 388         self.valeur=sd
 389         self.val=sd
 390         self.fin_modif()
 391
 392   def set_valeur_co(self,nom_co):
 393       """
 394           Affecte à self l'objet de type CO et de nom nom_co
 395       """
 396       #print "set_valeur_co",nom_co
 397       step=self.etape.parent
 398       if nom_co == None or nom_co == '':
 399          new_objet=None
 400       else:
 401          # Avant de créer un concept il faut s'assurer du contexte : step
 402          # courant
 403          sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
 404          if sd:
 405             # Si un concept du meme nom existe deja dans la portée de l'étape
 406             # on ne crée pas le concept
 407             return 0,"un concept de meme nom existe deja"
 408          # Il n'existe pas de concept de meme nom. On peut donc le créer
 409          # Il faut néanmoins que la méthode NommerSdProd de step gère les
 410          # contextes en mode editeur
 411          # Normalement la méthode  du Noyau doit etre surchargée
 412          # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
 413          cs= CONTEXT.get_current_step()
 414          CONTEXT.unset_current_step()
 415          CONTEXT.set_current_step(step)
 416          step.set_etape_context(self.etape)
 417          new_objet = Accas.CO(nom_co)
 418          CONTEXT.unset_current_step()
 419          CONTEXT.set_current_step(cs)
 420       self.init_modif()
 421       self.valeur = new_objet
 422       self.val = new_objet
 423       self.fin_modif()
 424       step.reset_context()
 425       # On force l'enregistrement de new_objet en tant que concept produit
 426       # de la macro en appelant get_type_produit avec force=1
 427       self.etape.get_type_produit(force=1)
 428       #print "set_valeur_co",new_objet
 429       return 1,"Concept créé"
 430
 431   def verif_existence_sd(self):
 432      """
 433         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 434         avant étape, sinon enlève la référence à ces concepts
 435      """
 436      #print "verif_existence_sd"
 437      # Attention : possible probleme avec include
 438      l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
 439      if type(self.valeur) in (types.TupleType,types.ListType) :
 440        l=[]
 441        self.init_modif()
 442        for sd in self.valeur:
 443          if isinstance(sd,ASSD) :
 444             if sd in l_sd_avant_etape :
 445                l.append(sd)
 446          else:
 447             l.append(sd)
 448        self.valeur=tuple(l)
 449        self.fin_modif()
 450      else:
 451        if isinstance(self.valeur,ASSD) :
 452           if self.valeur not in l_sd_avant_etape :
 453              self.init_modif()
 454              self.valeur = None
 455              self.fin_modif()
 456
 457   def get_min_max(self):
 458      """
 459      Retourne les valeurs min et max admissibles pour la valeur de self
 460      """
 461      return self.definition.min,self.definition.max
 462
 463
 464   def get_type(self):
 465      """
 466      Retourne le type attendu par le mot-clé simple
 467      """
 468      return self.definition.type
 469
 470   def delete_mc_global(self):
 471       """ Retire self des declarations globales
 472       """
 473       if self.definition.position == 'global' :
 474          etape = self.get_etape()
 475          if etape :
 476             del etape.mc_globaux[self.nom]
 477       elif self.definition.position == 'global_jdc' :
 478          del self.jdc.mc_globaux[self.nom]
 479
 480   def update_mc_global(self):
 481      """
 482         Met a jour les mots cles globaux enregistrés dans l'étape parente
 483         et dans le jdc parent.
 484         Un mot cle simple peut etre global.
 485      """
 486      if self.definition.position == 'global' :
 487         etape = self.get_etape()
 488         if etape :
 489            etape.mc_globaux[self.nom]=self
 490      elif self.definition.position == 'global_jdc' :
 491         if self.jdc:
 492            self.jdc.mc_globaux[self.nom]=self
 493
 494   def nbrColonnes(self):
 495      genea = self.get_genealogie()
 496      if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3
 497      if "VALE" in genea and "DEFI_FONCTION" in genea : return 2
 498      print dir(self)
 499      return 0
 500
 501 #--------------------------------------------------------------------------------
 502
 503 #ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
 504 # Elles doivent etre reintegrees des que possible
 505
 506
 507   def isvalid(self,cr='non'):
 508       """
 509          Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
 510
 511            - 0 si l'objet est invalide
 512            - 1 si l'objet est valide
 513
 514          Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
 515          la méthode construit également un comte-rendu de validation
 516          dans self.cr qui doit avoir été créé préalablement.
 517       """
 518       if self.state == 'unchanged':
 519         return self.valid
 520       else:
 521         valid = 1
 522         v=self.valeur
 523         #  verification presence
 524         if self.isoblig() and v == None :
 525           if cr == 'oui' :
 526             self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé")))
 527           valid = 0
 528
 529         if v is None:
 530            valid=0
 531            if cr == 'oui' :
 532               self.cr.fatal("None n'est pas une valeur autorisée")
 533         else:
 534            # type,into ...
 535            #PN ??? je n ose pas y toucher ???
 536            #if v.__class__.__name__ in ('PARAMETRE','EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'):
 537            if ((issubclass(v.__class__,param2.Formula)) or
 538                 (v.__class__.__name__  in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
 539               verif_type=self.verif_typeihm(v)
 540            else:
 541               verif_type=self.verif_type(val=v,cr=None)
 542               # cas des tuples avec un ITEM_PARAMETRE
 543               if verif_type == 0:
 544                  if type(v) == types.TupleType :
 545                    new_val=[]
 546                    for i in v:
 547                      if ((issubclass(i.__class__,param2.Formula)) or
 548                          (i.__class__.__name__  in ('EVAL', 'ITEM_PARAMETRE','PARAMETRE_EVAL'))):
 549                           if self.verif_typeihm(val=i,cr=cr) == 0:
 550                              verif_type = 0
 551                              break
 552                      else:
 553                           new_val.append(i)
 554                    if new_val != [] :
 555                      verif_type=self.verif_type(val=new_val,cr=cr)
 556                    else :
 557                      # Cas d une liste de paramétre
 558                      verif_type=self.verif_typeliste(val=v,cr=cr)
 559                  else:
 560                      verif_type=self.verif_type(val=v,cr=cr)
 561            valid = verif_type*self.verif_into(cr=cr)*self.verif_card(cr=cr)
 562            #
 563            # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
 564            #
 565            if valid and self.definition.validators and not self.definition.validators.verif(self.valeur):
 566               if cr == 'oui' :
 567                  self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info())))
 568               valid=0
 569            # fin des validateurs
 570            #
 571         # cas d un item Parametre
 572         if self.valeur.__class__.__name__ == 'ITEM_PARAMETRE':
 573            valid=self.valeur.isvalid()
 574            if valid == 0:
 575               if cr == 'oui' :
 576                  self.cr.fatal(string.join( repr (self.valeur), " a un indice incorrect"))
 577
 578         self.set_valid(valid)
 579         return self.valid
 580
 581
 582   def verif_typeihm(self,val,cr='non'):
 583       try :
 584          val.eval()
 585          return 1
 586       except :
 587         pass
 588       return self.verif_type(val,cr)
 589
 590   def verif_typeliste(self,val,cr='non') :
 591       verif=0
 592       for v in val :
 593         verif=verif+self.verif_typeihm(v,cr)
 594       return verif
 595