Ihm/I_ETAPE.py

   1 """
   2 """
   3 # Modules Python
   4 import string,types
   5 from copy import copy
   6
   7 # Modules EFICAS
   8 import I_MCCOMPO
   9
  10 class ETAPE(I_MCCOMPO.MCCOMPO):
  11
  12    def __init__(self):
  13       self.niveau=self.jdc
  14
  15    def ident(self):
  16       return self.nom
  17
  18    def get_fr(self):
  19       """
  20          Retourne l'attribut fr de self.definition
  21       """
  22       try:
  23          return self.definition.fr
  24       except:
  25          return ''
  26
  27    def get_sdname(self):
  28       if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
  29       if self.reuse != None:
  30         sdname= self.reuse.get_name()
  31       else:
  32         sdname=self.sd.get_name()
  33       if string.find(sdname,'sansnom') != -1 or string.find(sdname,'SD_') != -1:
  34         # dans le cas où la SD est 'sansnom' ou 'SD_' on retourne la chaîne vide
  35         return ''
  36       return sdname
  37
  38    def is_reentrant(self):
  39       """
  40           Indique si la commande est reentrante
  41       """
  42       return self.definition.reentrant == 'o'
  43
  44    def init_modif(self):
  45       """
  46          Met l'état de l'étape à : modifié
  47          Propage la modification au parent
  48          Si la fonction op_init existe, l'active
  49       """
  50       # Une action
  51       # doit etre realisée apres init_modif et la validite reevaluée
  52       # apres cette action. L'état modified de tous les objets doit etre
  53       # preservé.
  54       self.state = 'modified'
  55       if self.parent:
  56         self.parent.init_modif()
  57
  58    def fin_modif(self):
  59       """
  60           Méthode appelée une fois qu'une modification a été faite afin de
  61           déclencher d'éventuels traitements post-modification
  62           ex : INCLUDE et POURSUITE
  63       """
  64       if self.isvalid() :
  65          if type(self.definition.op_init) == types.FunctionType :
  66             apply(self.definition.op_init,(self,self.master.g_context))
  67       self.state = 'modified'
  68
  69    def nomme_sd(self,nom) :
  70       """
  71           Cette méthode a pour fonction de donner un nom (nom) au concept
  72           produit par l'étape (self).
  73           - si le concept n'existe pas, on essaye de le créer (à condition que l'étape soit valide ET non réentrante)
  74           - si il existe déjà, on le renomme et on répercute les changements dans les autres étapes
  75           Les valeurs de retour sont :
  76            0 si le nommage n'a pas pu etre mené à son terme,
  77            1 dans le cas contraire
  78       """
  79       if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
  80         return 0,"Nom de concept trop long (maxi 8 caractères)"
  81       self.init_modif()
  82       # Cas particulier des opérateurs réentrants
  83       if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
  84       if self.definition.reentrant == 'o':
  85         self.sd = self.reuse = self.jdc.get_sdprod(nom)
  86         if self.sd != None :
  87           return 1,"Concept existant"
  88         else:
  89           return 0,"Opérateur réentrant mais concept non existant"
  90       if self.definition.reentrant == 'f' :
  91         sd = self.jdc.get_sd_avant_etape(nom,self)
  92         if sd != None :
  93           self.sd = self.reuse = sd
  94           return 1,"Opérateur facultativement réentrant et concept existant trouvé"
  95         else :
  96           # il faut éventuellement enlever le lien vers une SD existante car si on passe ici
  97           # cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
  98           # Si on ne fait pas cela, le nom de l'opérateur réutilisé est aussi modifié
  99           # et on ne peut plus modifier la SD de l'opérateur
 100           if self.reuse :
 101              self.sd = self.reuse = None
 102       # l'opérateur n'est pas réentrant ou facultativement reentrant mais pas dans ce cas
 103       if self.sd == None :
 104           if self.parent.get_sd_autour_etape(nom,self):
 105             # On force self.valid a 0 car l appel a isvalid precedent l a mis a 1
 106             # mais ceci indique seulement une validité partielle
 107             # isvalid ne devrait peut etre pas mettre l attribut valid à 1 si sd == 'non'
 108             self.valid=0
 109             return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
 110           # Il n'existe pas de sd de nom sdnom. On peut donc créer le concept retourné.
 111           # Il est créé sans nom mais enregistré dans la liste des concepts existants
 112           self.get_sd_prod()
 113           self.sd.nom = nom
 114           return 1,"Nommage du concept effectué"
 115       else :
 116         old_nom=self.sd.nom
 117         if string.find(old_nom,'sansnom') :
 118            # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
 119            # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
 120            # on peut donc le nommer sans test préalable
 121            self.sd.nom=nom
 122            return 1,"Nommage du concept effectué"
 123         if self.isvalid() :
 124           # Normalement l appel de isvalid a mis a jour le concept produit (son type)
 125           # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
 126           # deja attribué
 127           if self.parent.get_sd_autour_etape(nom,self):
 128             return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
 129           else:
 130             self.sd.nom=nom
 131             return 1,"Nommage du concept effectué"
 132         else:
 133           # Normalement on ne devrait pas passer ici
 134           return 0,'Normalement on ne devrait pas passer ici'
 135
 136    def get_sdprods(self,nom_sd):
 137       """
 138          Fonction : retourne le concept produit par l etape de nom nom_sd
 139                     s il existe sinon None
 140       """
 141       if self.sd:
 142         if self.sd.nom == nom_sd:return self.sd
 143
 144    def active(self):
 145       """
 146           Rend l'etape courante active.
 147           Il faut ajouter la sd si elle existe au contexte global du JDC
 148           et à la liste des sd
 149       """
 150       self.actif = 1
 151       if not self.sd : return
 152       # XXX Pourquoi faut-il faire ce qui suit ??? par defaut les etapes sont actives
 153       try:
 154         self.jdc.append_sdprod(self.sd)
 155       except:
 156         pass
 157
 158    def inactive(self):
 159       """
 160           Rend l'etape courante inactive
 161           Il faut supprimer la sd du contexte global du JDC
 162           et de la liste des sd
 163       """
 164       self.actif = 0
 165       if not self.sd : return
 166       self.jdc.del_sdprod(self.sd)
 167       self.jdc.delete_concept_after_etape(self,self.sd)
 168
 169    def supprime_sdprods(self):
 170       """
 171           Fonction:
 172             Lors d'une destruction d'etape, detruit tous les concepts produits
 173             Un opérateur n a qu un concept produit
 174             Une procedure n'en a aucun
 175             Une macro en a en général plus d'un
 176       """
 177       # XXX pour les macros il faudrait peut etre aussi
 178       #     supprimer les concepts a droite du = ???
 179       if not self.is_reentrant() :
 180         # l'étape n'est pas réentrante
 181         # le concept retourné par l'étape est à supprimer car il était
 182         # créé par l'étape
 183         if self.sd != None :
 184           self.parent.del_sdprod(self.sd)
 185           self.parent.delete_concept(self.sd)
 186
 187    def delete_concept(self,sd):
 188       """
 189           Inputs :
 190              sd=concept detruit
 191           Fonction :
 192              Mettre a jour les mots cles de l etape et eventuellement
 193              le concept produit si reuse
 194              suite à la disparition du concept sd
 195              Seuls les mots cles simples MCSIMP font un traitement autre
 196              que de transmettre aux fils
 197       """
 198       if self.reuse and self.reuse == sd:
 199         self.sd=self.reuse=None
 200         self.init_modif()
 201       for child in self.mc_liste :
 202         child.delete_concept(sd)
 203
 204    def make_register(self):
 205       """
 206          Initialise les attributs jdc, id, niveau et réalise les
 207          enregistrements nécessaires
 208          Pour EFICAS, on tient compte des niveaux
 209       """
 210       if self.parent :
 211          self.jdc = self.parent.get_jdc_root()
 212          self.id=   self.parent.register(self)
 213          if self.definition.niveau :
 214             # La définition est dans un niveau. En plus on
 215             # l'enregistre dans le niveau
 216             self.nom_niveau_definition = self.definition.niveau.nom
 217             self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
 218             self.niveau.register(self)
 219          else:
 220             # La définition est au niveau global
 221             self.nom_niveau_definition = 'JDC'
 222             self.niveau=self.parent
 223       else:
 224          self.jdc = self.parent =None
 225          self.id=None
 226          self.niveau=None
 227
 228    def copy(self):
 229       """ Méthode qui retourne une copie de self non enregistrée auprès du JDC
 230           et sans sd
 231       """
 232       etape = copy(self)
 233       etape.sd = None
 234       etape.state = 'modified'
 235       etape.reuse = None
 236       etape.sdnom = None
 237       etape.mc_liste=[]
 238       for objet in self.mc_liste:
 239         new_obj = objet.copy()
 240         etape.mc_liste.append(new_obj)
 241       return etape
 242
 243    def get_noms_sd_oper_reentrant(self):
 244       """
 245           Retourne la liste des noms de concepts utilisés à l'intérieur de la commande
 246           qui sont du type que peut retourner cette commande
 247       """
 248       liste_sd = self.get_sd_utilisees()
 249       l_noms = []
 250       if type(self.definition.sd_prod) == types.FunctionType:
 251         d=self.cree_dict_valeurs(self.mc_liste)
 252         try:
 253           classe_sd_prod = apply(self.definition.sd_prod,(),d)
 254         except:
 255           return []
 256       else:
 257         classe_sd_prod = self.definition.sd_prod
 258       for sd in liste_sd :
 259         if sd.__class__ is classe_sd_prod : l_noms.append(sd.nom)
 260       l_noms.sort()
 261       return l_noms
 262
 263    def get_sd_utilisees(self):
 264       """
 265           Retourne la liste des concepts qui sont utilisés à l'intérieur d'une commande
 266           ( comme valorisation d'un MCS)
 267       """
 268       l=[]
 269       for child in self.mc_liste:
 270         l.extend(child.get_sd_utilisees())
 271       return l
 272