Validation/V_MACRO_ETAPE.py

   1 #@ MODIF V_MACRO_ETAPE Validation  DATE 09/10/2002   AUTEUR DURAND C.DURAND
   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 """
  22    Ce module contient la classe mixin MACRO_ETAPE qui porte les méthodes
  23    nécessaires pour réaliser la validation d'un objet de type MACRO_ETAPE
  24    dérivé de OBJECT.
  25
  26    Une classe mixin porte principalement des traitements et est
  27    utilisée par héritage multiple pour composer les traitements.
  28 """
  29 # Modules Python
  30 import string,types,sys
  31 import traceback
  32
  33 # Modules EFICAS
  34 import V_MCCOMPO
  35 import V_ETAPE
  36 from Noyau.N_Exception import AsException
  37 from Noyau.N_utils import AsType
  38
  39 class MACRO_ETAPE(V_ETAPE.ETAPE):
  40    """
  41    """
  42
  43    def isvalid(self,sd='oui',cr='non'):
  44       """
  45          Methode pour verifier la validité de l'objet ETAPE. Cette méthode
  46          peut etre appelée selon plusieurs modes en fonction de la valeur
  47          de sd et de cr.
  48
  49          Si cr vaut oui elle crée en plus un compte-rendu.
  50
  51          Cette méthode a plusieurs fonctions :
  52
  53           - mettre à jour l'état de self (update)
  54
  55           - retourner un indicateur de validité 0=non, 1=oui
  56
  57           - produire un compte-rendu : self.cr
  58
  59       """
  60       if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
  61       if self.state == 'unchanged' :
  62         return self.valid
  63       else:
  64         valid = 1
  65         # on teste les mots cles de la commande
  66         for child in self.mc_liste :
  67           if not child.isvalid():
  68             valid = 0
  69             break
  70         # on teste les règles de la commande
  71         text_erreurs,test_regles = self.verif_regles()
  72         if not test_regles :
  73           if cr == 'oui' : self.cr.fatal(string.join(("Règle(s) non respectée(s) :", text_erreurs)))
  74           valid = 0
  75         if self.reste_val != {}:
  76           if cr == 'oui' :
  77             self.cr.fatal("Mots cles inconnus :" + string.join(self.reste_val.keys(),','))
  78           valid=0
  79         if sd == "non":
  80            # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'état de self
  81            # on retourne simplement l'indicateur valid
  82            return valid
  83         if hasattr(self,'valid'):
  84           old_valid = self.valid
  85         else:
  86           old_valid = None
  87         # on teste, si elle existe, le nom de la sd (sa longueur doit etre <= 8 caractères)
  88         if self.sd != None :
  89           # la SD existe déjà : on regarde son nom
  90           if self.sd.get_name() != None :
  91             if len(self.sd.nom) > 8 :
  92               if cr == 'oui' :
  93                 self.cr.fatal("Le nom de concept %s est trop long (8 caractères maxi)" %self.sd.nom)
  94               valid = 0
  95           if string.find(self.sd.nom,'sansnom') != -1 :
  96               # la SD est 'sansnom' : --> erreur
  97               if cr == 'oui' :
  98                 self.cr.fatal("Pas de nom pour le concept retourné")
  99               valid = 0
 100           elif string.find(self.sd.nom,'SD_') != -1 :
 101               # la SD est 'SD_' cad son nom = son id donc pas de nom donné par utilisateur : --> erreur
 102               if cr == 'oui' :
 103                 self.cr.fatal("Pas de nom pour le concept retourné")
 104               valid = 0
 105         if valid:
 106           valid = self.update_sdprod(cr)
 107         # Si la macro comprend des etapes internes, on teste leur validite
 108         for e in self.etapes:
 109           if not e.isvalid():
 110             valid=0
 111             break
 112         self.valid = valid
 113         self.state = 'unchanged'
 114         if old_valid:
 115           if old_valid != self.valid : self.init_modif_up()
 116         return self.valid
 117
 118    def update_sdprod(self,cr='non'):
 119       """
 120            Cette méthode met à jour le concept produit en fonction des conditions initiales :
 121
 122             1- Il n'y a pas de concept retourné (self.definition.sd_prod == None)
 123
 124             2- Le concept retourné n existait pas (self.sd == None)
 125
 126             3- Le concept retourné existait. On change alors son type ou on le supprime
 127
 128            En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
 129       """
 130       sd_prod=self.definition.sd_prod
 131       # On memorise le type retourné dans l attribut typret
 132       self.typret=None
 133       if type(sd_prod) == types.FunctionType:
 134         # Type de concept retourné calculé
 135         d=self.cree_dict_valeurs(self.mc_liste)
 136         try:
 137           # la sd_prod d'une macro a l'objet lui meme en premier argument
 138           # contrairement à une ETAPE ou PROC_ETAPE
 139           # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
 140           # les concepts produits dans self.sdprods, il faut le mettre à zéro
 141           self.sdprods=[]
 142           sd_prod= apply(sd_prod,(self,),d)
 143         except:
 144           # Erreur pendant le calcul du type retourné
 145           if CONTEXT.debug:traceback.print_exc()
 146           self.sd=None
 147           if cr == 'oui' :
 148              l=traceback.format_exception(sys.exc_info()[0],
 149                                            sys.exc_info()[1],
 150                                            sys.exc_info()[2])
 151              self.cr.fatal('Impossible d affecter un type au résultat\n'+string.join(l[2:]))
 152           return 0
 153       # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
 154       valid=1
 155       if self.reuse:
 156         # Un concept reutilise a ete specifie
 157         if AsType(self.reuse) != sd_prod:
 158           if cr == 'oui' : self.cr.fatal('Type de concept reutilise incompatible avec type produit')
 159           valid=0
 160         if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
 161           # Le nom de la variable de retour (self.sdnom) doit etre le meme que celui du concept reutilise (self.reuse.nom)
 162           if cr == 'oui' :
 163              self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' %(self.reuse.nom,self.sdnom))
 164           valid= 0
 165         if valid:self.sd=self.reuse
 166       else:
 167         if sd_prod == None:# Pas de concept retourné
 168           # Que faut il faire de l eventuel ancien sd ?
 169           self.sd = None
 170         else:
 171           if self.sd:
 172             # Un sd existe deja, on change son type
 173             self.sd.__class__=sd_prod
 174             self.typret=sd_prod
 175           else:
 176             # Le sd n existait pas , on ne le crée pas
 177             self.typret=sd_prod
 178             if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
 179             valid=0
 180         if self.definition.reentrant == 'o':
 181            if cr == 'oui' : self.cr.fatal('Commande obligatoirement reentrante : specifier reuse=concept')
 182            valid=0
 183            #self.reuse = self.sd
 184       return valid
 185
 186    def report(self):
 187       """
 188           Methode pour la generation d un rapport de validation
 189       """
 190       V_ETAPE.ETAPE.report(self)
 191       for e in self.etapes :
 192         self.cr.add(e.report())
 193       return self.cr
 194