Validation/V_MACRO_ETAPE.py

   1 #@ MODIF V_MACRO_ETAPE Validation  DATE 07/09/2009   AUTEUR COURTOIS M.COURTOIS
   2 # -*- coding: iso-8859-1 -*-
   3 # RESPONSABLE COURTOIS M.COURTOIS
   4 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   5 # ======================================================================
   6 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   7 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   8 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   9 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
  10 # (AT YOUR OPTION) ANY LATER VERSION.
  11 #
  12 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  13 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  14 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  15 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  16 #
  17 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  18 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  19 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  20 #
  21 #
  22 # ======================================================================
  23
  24
  25 """
  26    Ce module contient la classe mixin MACRO_ETAPE qui porte les méthodes
  27    nécessaires pour réaliser la validation d'un objet de type MACRO_ETAPE
  28    dérivé de OBJECT.
  29
  30    Une classe mixin porte principalement des traitements et est
  31    utilisée par héritage multiple pour composer les traitements.
  32 """
  33 # Modules Python
  34 import string,types,sys
  35 import traceback
  36
  37 # Modules EFICAS
  38 import V_MCCOMPO
  39 import V_ETAPE
  40 from Noyau.N_Exception import AsException
  41 from Noyau.N_utils import AsType
  42
  43 class MACRO_ETAPE(V_ETAPE.ETAPE):
  44    """
  45    """
  46
  47    def isvalid(self,sd='oui',cr='non'):
  48       """
  49          Methode pour verifier la validité de l'objet ETAPE. Cette méthode
  50          peut etre appelée selon plusieurs modes en fonction de la valeur
  51          de sd et de cr.
  52
  53          Si cr vaut oui elle crée en plus un compte-rendu.
  54
  55          Cette méthode a plusieurs fonctions :
  56
  57           - mettre à jour l'état de self (update)
  58
  59           - retourner un indicateur de validité 0=non, 1=oui
  60
  61           - produire un compte-rendu : self.cr
  62
  63       """
  64       if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
  65       if self.state == 'unchanged' :
  66         return self.valid
  67       else:
  68         valid=1
  69         # On marque les concepts CO pour verification ulterieure de leur bonne utilisation
  70         l=self.mark_CO()
  71         # On verifie que les concepts CO sont bien passes par type_sdprod
  72         for c in l:
  73           if c.etape is self.parent:
  74              # le concept est propriete de l'etape parent
  75              # Il n'a pas ete transforme par type_sdprod
  76              # Cette situation est interdite
  77              # Pb: La macro-commande a passe le concept a une commande (macro ?) mal definie
  78              if cr =='oui':
  79                self.cr.fatal("Macro-commande mal definie : manque probablement appel a type_sdprod pour %s" % c.nom)
  80              valid=0
  81
  82         valid=valid * self.valid_child()
  83         valid=valid * self.valid_regles(cr)
  84
  85         if self.reste_val != {}:
  86           if cr == 'oui' :
  87             self.cr.fatal("Mots cles inconnus :" + string.join(self.reste_val.keys(),','))
  88           valid=0
  89
  90         if sd == "non":
  91            # Dans ce cas, on ne calcule qu'une validite partielle, on ne modifie pas l'état de self
  92            # on retourne simplement l'indicateur valid
  93            return valid
  94
  95         if self.sd != None :
  96            valid = valid * self.valid_sdnom(cr)
  97
  98         if self.definition.reentrant == 'n' and self.reuse:
  99            # Il ne peut y avoir de concept reutilise avec une MACRO  non reentrante
 100            if cr == 'oui' : self.cr.fatal('Macro-commande non reentrante : ne pas utiliser reuse ')
 101            valid=0
 102
 103         if valid:
 104           valid = self.update_sdprod(cr)
 105
 106         # Si la macro comprend des etapes internes, on teste leur validite
 107         for e in self.etapes:
 108           if not e.isvalid():
 109             valid=0
 110             break
 111
 112         self.set_valid(valid)
 113
 114         return self.valid
 115
 116    def update_sdprod(self,cr='non'):
 117       """
 118            Cette méthode met à jour le concept produit en fonction des conditions initiales :
 119
 120             1. Il n'y a pas de concept retourné (self.definition.sd_prod == None)
 121
 122             2. Le concept retourné n existait pas (self.sd == None)
 123
 124             3. Le concept retourné existait. On change alors son type ou on le supprime
 125
 126            En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
 127       """
 128       sd_prod=self.definition.sd_prod
 129       # On memorise le type retourné dans l attribut typret
 130       self.typret=None
 131       if type(sd_prod) == types.FunctionType:
 132         # Type de concept retourné calculé
 133         d=self.cree_dict_valeurs(self.mc_liste)
 134         try:
 135           # la sd_prod d'une macro a l'objet lui meme en premier argument
 136           # contrairement à une ETAPE ou PROC_ETAPE
 137           # Comme sd_prod peut invoquer la méthode type_sdprod qui ajoute
 138           # les concepts produits dans self.sdprods, il faut le mettre à zéro
 139           self.sdprods=[]
 140           sd_prod= apply(sd_prod,(self,),d)
 141         except:
 142           # Erreur pendant le calcul du type retourné
 143           if CONTEXT.debug:traceback.print_exc()
 144           self.sd=None
 145           if cr == 'oui' :
 146              l=traceback.format_exception(sys.exc_info()[0],
 147                                            sys.exc_info()[1],
 148                                            sys.exc_info()[2])
 149              self.cr.fatal('Impossible d affecter un type au résultat\n'+string.join(l[2:]))
 150           return 0
 151       # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
 152       valid=1
 153       if self.reuse:
 154         # Un concept reutilise a ete specifie
 155         if AsType(self.reuse) != sd_prod:
 156           if cr == 'oui' : self.cr.fatal('Type de concept reutilise incompatible avec type produit')
 157           valid=0
 158         if self.sdnom!='':
 159            if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
 160              # Le nom de la variable de retour (self.sdnom) doit etre le meme que celui du concept reutilise (self.reuse.nom)
 161              if cr == 'oui' :
 162                 self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' %(self.reuse.nom,self.sdnom))
 163              valid= 0
 164         if valid:self.sd=self.reuse
 165       else:
 166         #Cas d'un concept non reutilise
 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             if CONTEXT.debug:print "changement de type:",self.sd,sd_prod
 174             if self.sd.__class__ != sd_prod:
 175               self.sd.change_type(sd_prod)
 176             self.typret=sd_prod
 177           else:
 178             # Le sd n existait pas , on ne le crée pas
 179             self.typret=sd_prod
 180             if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
 181             valid=0
 182         if self.definition.reentrant == 'o':
 183            if cr == 'oui' : self.cr.fatal('Commande obligatoirement reentrante : specifier reuse=concept')
 184            valid=0
 185       return valid
 186
 187    def report(self):
 188       """
 189           Methode pour la generation d un rapport de validation
 190       """
 191       V_ETAPE.ETAPE.report(self)
 192       for e in self.etapes :
 193         self.cr.add(e.report())
 194       return self.cr
 195