Ihm/I_ETAPE.py

   1 """
   2 """
   3 # Modules Python
   4 import string,types
   5 from copy import copy
   6
   7 # import rajoutés suite à l'ajout de Build_sd --> à résorber
   8 import traceback
   9 import Noyau
  10 from Noyau import N_Exception
  11 from Noyau.N_Exception import AsException
  12 # fin import à résorber
  13
  14 # Modules EFICAS
  15 import I_MCCOMPO
  16
  17 class ETAPE(I_MCCOMPO.MCCOMPO):
  18
  19    def __init__(self):
  20       self.niveau=self.jdc
  21
  22    def ident(self):
  23       return self.nom
  24
  25    def get_fr(self):
  26       """
  27          Retourne l'attribut fr de self.definition
  28       """
  29       try:
  30          return self.definition.fr
  31       except:
  32          return ''
  33
  34    def get_sdname(self):
  35       if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
  36       if self.reuse != None:
  37         sdname= self.reuse.get_name()
  38       else:
  39         sdname=self.sd.get_name()
  40       if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
  41         # dans le cas où la SD est 'sansnom' ou 'SD_' on retourne la chaîne vide
  42         return ''
  43       return sdname
  44
  45    def is_reentrant(self):
  46       """
  47           Indique si la commande est reentrante
  48       """
  49       return self.definition.reentrant == 'o'
  50
  51    def init_modif(self):
  52       """
  53          Met l'état de l'étape à : modifié
  54          Propage la modification au parent
  55          Si la fonction op_init existe, l'active
  56       """
  57       # Une action
  58       # doit etre realisée apres init_modif et la validite reevaluée
  59       # apres cette action. L'état modified de tous les objets doit etre
  60       # preservé.
  61       self.state = 'modified'
  62       if self.parent:
  63         self.parent.init_modif()
  64
  65    def fin_modif(self):
  66       """
  67           Méthode appelée une fois qu'une modification a été faite afin de
  68           déclencher d'éventuels traitements post-modification
  69           ex : INCLUDE et POURSUITE
  70       """
  71       if self.isvalid() :
  72          if type(self.definition.op_init) == types.FunctionType :
  73             # XXX Normalement en mode editeur g_context ne peut pas etre utilisé
  74             apply(self.definition.op_init,(self,self.parent.g_context))
  75       self.state = 'modified'
  76
  77    def nomme_sd(self,nom) :
  78       """
  79           Cette méthode a pour fonction de donner un nom (nom) au concept
  80           produit par l'étape (self).
  81           - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
  82           - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes
  83           Les valeurs de retour sont :
  84            0 si le nommage n'a pas pu etre mené à son terme,
  85            1 dans le cas contraire
  86       """
  87       if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
  88         return 0,"Nom de concept trop long (maxi 8 caractères)"
  89       self.init_modif()
  90       # Cas particulier des opérateurs réentrants
  91       if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
  92       if self.definition.reentrant == 'o':
  93         # FR : appel à get_sdprod incorrect : il faut appeler get_sd_avant_etape
  94         #self.sd = self.reuse = self.jdc.get_sdprod(nom)
  95         self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
  96         if self.sd != None :
  97           return 1,"Concept existant"
  98         else:
  99           return 0,"Opérateur réentrant mais concept non existant"
 100       if self.definition.reentrant == 'f' :
 101         sd = self.jdc.get_sd_avant_etape(nom,self)
 102         if sd != None :
 103           # FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
 104           if isinstance(sd,self.get_type_produit()) :
 105              self.sd = self.reuse = sd
 106              return 1,"Opérateur facultativement réentrant et concept existant trouvé"
 107           else:
 108              return 0,"Concept déjà existant et de mauvais type"
 109         else :
 110           # il faut éventuellement enlever le lien vers une SD existante car si on passe ici
 111           # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
 112           # Si on ne fait pas cela, le nom de l'opérateur réutilisé est aussi modifié
 113           # et on ne peut plus modifier la SD de l'opérateur
 114           if self.reuse :
 115              self.sd = self.reuse = None
 116       # l'opérateur n'est pas réentrant ou facultativement reentrant mais pas dans ce cas
 117       if self.sd == None :
 118           if self.parent.get_sd_autour_etape(nom,self):
 119             # On force self.valid a 0 car l appel a isvalid precedent l a mis a 1
 120             # mais ceci indique seulement une validité partielle
 121             # isvalid ne devrait peut etre pas mettre l attribut valid à 1 si sd == 'non'
 122             self.valid=0
 123             return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
 124           # Il n'existe pas de sd de nom sdnom. On peut donc créer le concept retourné.
 125           # Il est créé sans nom mais enregistré dans la liste des concepts existants
 126           self.get_sd_prod()
 127           self.sd.nom = nom
 128           return 1,"Nommage du concept effectué"
 129       else :
 130         old_nom=self.sd.nom
 131         if string.find(old_nom,'sansnom') :
 132            # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
 133            # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
 134            # on peut donc le nommer sans test préalable
 135            self.sd.nom=nom
 136            return 1,"Nommage du concept effectué"
 137         if self.isvalid() :
 138           # Normalement l appel de isvalid a mis a jour le concept produit (son type)
 139           # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
 140           # deja attribué
 141           if self.parent.get_sd_autour_etape(nom,self):
 142             return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
 143           else:
 144             self.sd.nom=nom
 145             return 1,"Nommage du concept effectué"
 146         else:
 147           # Normalement on ne devrait pas passer ici
 148           return 0,'Normalement on ne devrait pas passer ici'
 149
 150    def get_sdprods(self,nom_sd):
 151       """
 152          Fonction : retourne le concept produit par l etape de nom nom_sd
 153                     s il existe sinon None
 154       """
 155       if self.sd:
 156         if self.sd.nom == nom_sd:return self.sd
 157
 158    def active(self):
 159       """
 160           Rend l'etape courante active.
 161           Il faut ajouter la sd si elle existe au contexte global du JDC
 162           et à la liste des sd
 163       """
 164       self.actif = 1
 165       if not self.sd : return
 166       # XXX Pourquoi faut-il faire ce qui suit ??? par defaut les etapes sont actives
 167       try:
 168         self.jdc.append_sdprod(self.sd)
 169       except:
 170         pass
 171
 172    def inactive(self):
 173       """
 174           Rend l'etape courante inactive
 175           Il faut supprimer la sd du contexte global du JDC
 176           et de la liste des sd
 177       """
 178       self.actif = 0
 179       if not self.sd : return
 180       self.jdc.del_sdprod(self.sd)
 181       self.jdc.delete_concept_after_etape(self,self.sd)
 182
 183    def supprime_sdprods(self):
 184       """
 185           Fonction:
 186             Lors d'une destruction d'etape, detruit tous les concepts produits
 187             Un opérateur n a qu un concept produit
 188             Une procedure n'en a aucun
 189             Une macro en a en général plus d'un
 190       """
 191       # XXX pour les macros il faudrait peut etre aussi
 192       #     supprimer les concepts a droite du = ???
 193       if not self.is_reentrant() :
 194         # l'étape n'est pas réentrante
 195         # le concept retourné par l'étape est à supprimer car il était
 196         # créé par l'étape
 197         if self.sd != None :
 198           self.parent.del_sdprod(self.sd)
 199           self.parent.delete_concept(self.sd)
 200
 201    def delete_concept(self,sd):
 202       """
 203           Inputs :
 204              sd=concept detruit
 205           Fonction :
 206              Mettre a jour les mots cles de l etape et eventuellement
 207              le concept produit si reuse
 208              suite à la disparition du concept sd
 209              Seuls les mots cles simples MCSIMP font un traitement autre
 210              que de transmettre aux fils
 211       """
 212       if self.reuse and self.reuse == sd:
 213         self.sd=self.reuse=None
 214         self.init_modif()
 215       for child in self.mc_liste :
 216         child.delete_concept(sd)
 217
 218    def make_register(self):
 219       """
 220          Initialise les attributs jdc, id, niveau et réalise les
 221          enregistrements nécessaires
 222          Pour EFICAS, on tient compte des niveaux
 223       """
 224       if self.parent :
 225          self.jdc = self.parent.get_jdc_root()
 226          self.id=   self.parent.register(self)
 227          if self.definition.niveau :
 228             # La définition est dans un niveau. En plus on
 229             # l'enregistre dans le niveau
 230             self.nom_niveau_definition = self.definition.niveau.nom
 231             self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
 232             self.niveau.register(self)
 233          else:
 234             # La définition est au niveau global
 235             self.nom_niveau_definition = 'JDC'
 236             self.niveau=self.parent
 237       else:
 238          self.jdc = self.parent =None
 239          self.id=None
 240          self.niveau=None
 241
 242    def copy(self):
 243       """ Méthode qui retourne une copie de self non enregistrée auprès du JDC
 244           et sans sd
 245       """
 246       etape = copy(self)
 247       etape.sd = None
 248       etape.state = 'modified'
 249       etape.reuse = None
 250       etape.sdnom = None
 251       etape.etape=etape
 252       etape.mc_liste=[]
 253       for objet in self.mc_liste:
 254         new_obj = objet.copy()
 255         new_obj.reparent(etape)
 256         etape.mc_liste.append(new_obj)
 257       return etape
 258
 259    def get_noms_sd_oper_reentrant(self):
 260       """
 261           Retourne la liste des noms de concepts utilisés à l'intérieur de la commande
 262           qui sont du type que peut retourner cette commande
 263       """
 264       liste_sd = self.get_sd_utilisees()
 265       l_noms = []
 266       if type(self.definition.sd_prod) == types.FunctionType:
 267         d=self.cree_dict_valeurs(self.mc_liste)
 268         try:
 269           classe_sd_prod = apply(self.definition.sd_prod,(),d)
 270         except:
 271           return []
 272       else:
 273         classe_sd_prod = self.definition.sd_prod
 274       for sd in liste_sd :
 275         if sd.__class__ is classe_sd_prod : l_noms.append(sd.nom)
 276       l_noms.sort()
 277       return l_noms
 278
 279    def get_sd_utilisees(self):
 280       """
 281           Retourne la liste des concepts qui sont utilisés à l'intérieur d'une commande
 282           ( comme valorisation d'un MCS)
 283       """
 284       l=[]
 285       for child in self.mc_liste:
 286         l.extend(child.get_sd_utilisees())
 287       return l
 288
 289    def get_genealogie(self):
 290       """
 291           Retourne la liste des noms des ascendants de l'objet self
 292           en s'arretant à la première ETAPE rencontrée
 293       """
 294       return [self.nom]
 295
 296    def reparent(self,parent):
 297      """
 298          Cette methode sert a reinitialiser la parente de l'objet
 299      """
 300      self.parent=parent
 301      self.jdc=parent.get_jdc_root()
 302      self.etape=self
 303      for mocle in self.mc_liste:
 304         mocle.reparent(self)
 305
 306    def verif_existence_sd(self):
 307      """
 308         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 309         avant étape, sinon enlève la référence à ces concepts
 310      """
 311      for motcle in self.mc_liste :
 312          motcle.verif_existence_sd()
 313
 314    def Build_sd(self,nom):
 315       """
 316          Construit le concept produit de l'opérateur. Deux cas
 317          peuvent se présenter :
 318
 319          - le parent n'est pas défini. Dans ce cas, l'étape prend en charge la création
 320            et le nommage du concept.
 321
 322          - le parent est défini. Dans ce cas, l'étape demande au parent la création et
 323            le nommage du concept.
 324
 325       """
 326       if not self.isactif():return
 327       # FR : attention cette méthode ne devrait pas se trouver là car elle surcharge celle qui
 328       # se trouve dans N_ETAPE.py et elle est partie intégrante du noyau, mais, suite à l'absence de
 329       # test de validité de l'opérateur avant d'essayer de déterminer la sd produite, on n'arrivait
 330       # pas à relire avec EFICAS un fichier contenant une étape encore incomplète du style :
 331       #  sansnom = AFFE_CHAR_CINE(MODELE=None)
 332       # Suite à la stabilisation du noyau d'Aster, je n'ai pas eu d'autre solution que de surcharger
 333       # cette méthode ici en rajoutant le test manquant ...
 334       if not self.isvalid(sd='non') : return
 335       try:
 336          if self.parent:
 337             sd= self.parent.create_sdprod(self,nom)
 338             if type(self.definition.op_init) == types.FunctionType:
 339                apply(self.definition.op_init,(self,self.parent.g_context))
 340          else:
 341             sd=self.get_sd_prod()
 342             # On n'utilise pas self.definition.op_init car self.parent
 343             # n'existe pas
 344             if sd != None and self.reuse == None:
 345                # On ne nomme le concept que dans le cas de non reutilisation
 346                # d un concept
 347                sd.nom=nom
 348          if self.jdc and self.jdc.par_lot == "NON" :
 349             self.Execute()
 350          return sd
 351       except AsException,e:
 352          raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
 353                               'fichier : ',self.appel[1],e)
 354       except EOFError:
 355          # XXX Normalement le contexte courant doit etre le parent.
 356          # Il n'y a pas de raison de remettre le contexte au parent
 357          #self.reset_current_step()
 358          raise
 359       except :
 360          l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2])
 361          raise AsException("Etape ",self.nom,'ligne : ',self.appel[0],
 362                            'fichier : ',self.appel[1]+'\n',
 363                             string.join(l))
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384