Validation/V_ETAPE.py

   1 # -*- coding: utf-8 -*-
   2 #@ MODIF V_ETAPE Validation  DATE 26/09/2003   AUTEUR DURAND C.DURAND
   3 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   4 # ======================================================================
   5 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   6 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   7 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   8 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   9 # (AT YOUR OPTION) ANY LATER VERSION.
  10 #
  11 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  12 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  13 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  14 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  15 #
  16 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  17 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  18 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  19 #
  20 #
  21 # ======================================================================
  22 """
  23    Ce module contient la classe mixin ETAPE qui porte les méthodes
  24    nécessaires pour réaliser la validation d'un objet de type ETAPE
  25    dérivé de OBJECT.
  26
  27    Une classe mixin porte principalement des traitements et est
  28    utilisée par héritage multiple pour composer les traitements.
  29 """
  30 # Modules Python
  31 import string,types,sys
  32 import traceback
  33
  34 # Modules EFICAS
  35 import V_MCCOMPO
  36 from Noyau.N_Exception import AsException
  37 from Noyau.N_utils import AsType
  38
  39 class ETAPE(V_MCCOMPO.MCCOMPO):
  40    """
  41    """
  42
  43    def valid_child(self):
  44        """ Cette methode teste la validite des mots cles de l'etape """
  45        for child in self.mc_liste :
  46            if not child.isvalid():
  47               return 0
  48        return 1
  49
  50    def valid_regles(self,cr):
  51        """ Cette methode teste la validite des regles de l'etape """
  52        text_erreurs,test_regles = self.verif_regles()
  53        if not test_regles :
  54           if cr == 'oui' : self.cr.fatal(string.join(("Règle(s) non respectée(s) :", text_erreurs)))
  55           return 0
  56        return 1
  57
  58    def valid_sdnom(self,cr):
  59        """ Cette methode teste la validite du nom du concept produit par l'etape """
  60        valid=1
  61        if self.sd.nom != None :
  62           if self.jdc and self.jdc.definition.code == 'ASTER' and len(self.sd.nom) > 8 :
  63              #  le nom de la sd doit avoir une longueur <= 8 caractères pour ASTER
  64              if cr == 'oui' :
  65                 self.cr.fatal("Le nom de concept %s est trop long (8 caractères maxi)" %self.sd.nom)
  66              valid = 0
  67           if string.find(self.sd.nom,'sansnom') != -1 :
  68              # la SD est 'sansnom' : --> erreur
  69              if cr == 'oui' :
  70                 self.cr.fatal("Pas de nom pour le concept retourné")
  71              valid = 0
  72           elif string.find(self.sd.nom,'SD_') != -1 :
  73              # la SD est 'SD_' cad son nom = son id donc pas de nom donné par utilisateur : --> erreur
  74              if cr == 'oui' :
  75                 self.cr.fatal("Pas de nom pour le concept retourné")
  76              valid = 0
  77        return valid
  78
  79    def get_valid(self):
  80        if hasattr(self,'valid'):
  81           return self.valid
  82        else:
  83           self.valid=None
  84           return None
  85
  86    def set_valid(self,valid):
  87        old_valid=self.get_valid()
  88        self.valid = valid
  89        self.state = 'unchanged'
  90        if not old_valid or old_valid != self.valid :
  91            self.init_modif_up()
  92
  93    def isvalid(self,sd='oui',cr='non'):
  94       """
  95          Methode pour verifier la validité de l'objet ETAPE. Cette méthode
  96          peut etre appelée selon plusieurs modes en fonction de la valeur
  97          de sd et de cr.
  98
  99          Si cr vaut oui elle crée en plus un compte-rendu.
 100
 101          Cette méthode a plusieurs fonctions :
 102
 103           - mettre à jour l'état de self (update)
 104
 105           - retourner un indicateur de validité 0=non, 1=oui
 106
 107           - produire un compte-rendu : self.cr
 108
 109       """
 110       if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
 111       if self.state == 'unchanged' :
 112         return self.valid
 113       else:
 114         valid=self.valid_child()
 115         valid=valid * self.valid_regles(cr)
 116
 117         if self.reste_val != {}:
 118           if cr == 'oui' :
 119             self.cr.fatal("Mots cles inconnus :" + string.join(self.reste_val.keys(),','))
 120           valid=0
 121
 122         if sd == "non":
 123           # Dans ce cas, on ne teste qu'une validité partielle (sans tests sur le concept produit)
 124           # Conséquence : on ne change pas l'état ni l'attribut valid, on retourne simplement
 125           # l'indicateur de validité valid
 126           return valid
 127
 128         if self.definition.reentrant == 'n' and self.reuse:
 129           # Il ne peut y avoir de concept reutilise avec un OPER non reentrant
 130           if cr == 'oui' : self.cr.fatal('Operateur non reentrant : ne pas utiliser reuse ')
 131           valid=0
 132
 133         if self.sd == None:
 134           # Le concept produit n'existe pas => erreur
 135           if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
 136           valid = 0
 137         else:
 138           valid = valid * self.valid_sdnom(cr)
 139
 140         if valid:
 141           valid = self.update_sdprod(cr)
 142
 143         self.set_valid(valid)
 144
 145         return self.valid
 146
 147    def update_sdprod(self,cr='non'):
 148       """
 149            Cette méthode met à jour le concept produit en fonction des conditions initiales :
 150
 151             1- Il n'y a pas de concept retourné (self.definition.sd_prod == None)
 152
 153             2- Le concept retourné n existait pas (self.sd == None)
 154
 155             3- Le concept retourné existait. On change alors son type ou on le supprime
 156
 157            En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
 158       """
 159       sd_prod=self.definition.sd_prod
 160       if type(sd_prod) == types.FunctionType: # Type de concept retourné calculé
 161         d=self.cree_dict_valeurs(self.mc_liste)
 162         try:
 163           sd_prod= apply(sd_prod,(),d)
 164         except:
 165           # Erreur pendant le calcul du type retourné
 166           if CONTEXT.debug:traceback.print_exc()
 167           self.sd=None
 168           if cr == 'oui' :
 169              l=traceback.format_exception(sys.exc_info()[0],
 170                                            sys.exc_info()[1],
 171                                            sys.exc_info()[2])
 172              self.cr.fatal('Impossible d affecter un type au résultat\n'+string.join(l[2:]))
 173           return 0
 174       # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
 175       valid=1
 176       if self.reuse:
 177         if AsType(self.reuse) != sd_prod:
 178           if cr == 'oui' : self.cr.fatal('Type de concept reutilise incompatible avec type produit')
 179           valid= 0
 180         if self.sdnom!='':
 181            if self.sdnom[0] != '_' and self.reuse.nom != self.sdnom:
 182              # Le nom de la variable de retour (self.sdnom) doit etre le meme que celui du concept reutilise (self.reuse.nom)
 183              if cr == 'oui' :
 184                 self.cr.fatal('Concept reutilise : le nom de la variable de retour devrait etre %s et non %s' %(self.reuse.nom,self.sdnom))
 185              valid= 0
 186         if valid:self.sd=self.reuse
 187       else:
 188         if sd_prod == None:# Pas de concept retourné
 189           # Que faut il faire de l eventuel ancien sd ?
 190           self.sd = None
 191         else:
 192           if self.sd:
 193              # Un sd existe deja, on change son type
 194              self.sd.__class__=sd_prod
 195           else:
 196              # Le sd n existait pas , on ne le crée pas
 197              if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
 198              valid=0
 199         if self.definition.reentrant == 'o':
 200            if cr == 'oui' : self.cr.fatal('Commande obligatoirement reentrante : specifier reuse=concept')
 201            valid=0
 202       return valid
 203
 204
 205    def report(self):
 206       """
 207           Methode pour generation d un rapport de validite
 208       """
 209       self.cr=self.CR(debut='Etape : '+self.nom \
 210                 + '    ligne : '+`self.appel[0]`\
 211                 + '    fichier : '+`self.appel[1]`,
 212                  fin = 'Fin Etape : '+self.nom)
 213       self.state = 'modified'
 214       try:
 215         self.isvalid(cr='oui')
 216       except AsException,e:
 217         if CONTEXT.debug : traceback.print_exc()
 218         self.cr.fatal(string.join(('Etape :',self.nom,
 219                               'ligne :',`self.appel[0]`,
 220                               'fichier :',`self.appel[1]`,str(e))))
 221       for child in self.mc_liste:
 222         self.cr.add(child.report())
 223       return self.cr
 224