Validation/V_ETAPE.py

   1 """
   2    Ce module contient la classe mixin ETAPE qui porte les méthodes
   3    nécessaires pour réaliser la validation d'un objet de type ETAPE
   4    dérivé de OBJECT.
   5
   6    Une classe mixin porte principalement des traitements et est
   7    utilisée par héritage multiple pour composer les traitements.
   8 """
   9 # Modules Python
  10 import string,types,sys
  11 import traceback
  12
  13 # Modules EFICAS
  14 import V_MCCOMPO
  15 from Noyau.N_Exception import AsException
  16 from Noyau.N_utils import AsType
  17
  18 class ETAPE(V_MCCOMPO.MCCOMPO):
  19    """
  20    """
  21
  22    def isvalid(self,sd='oui',cr='non'):
  23       """
  24          Methode pour verifier la validité de l'objet ETAPE. Cette méthode
  25          peut etre appelée selon plusieurs modes en fonction de la valeur
  26          de sd et de cr.
  27
  28          Si cr vaut oui elle crée en plus un compte-rendu.
  29
  30          Cette méthode a plusieurs fonctions :
  31
  32           - mettre à jour l'état de self (update)
  33
  34           - retourner un indicateur de validité 0=non, 1=oui
  35
  36           - produire un compte-rendu : self.cr
  37
  38       """
  39       if CONTEXT.debug : print "ETAPE.isvalid ",self.nom
  40       if self.state == 'unchanged' :
  41         return self.valid
  42       else:
  43         valid = 1
  44         if hasattr(self,'valid'):
  45           old_valid = self.valid
  46         else:
  47           old_valid = None
  48         # on teste si demandé la structure de donnée (par défaut)
  49         if sd == 'oui':
  50           if self.sd != None :pass
  51             # Ce test parait superflu. Il est sur que si sd existe il s'agit du concept produit
  52             # Quelle pourrait etre la raison qui ferait que sd n existe pas ???
  53             #if self.jdc.get_sdprod(self.sd.nom) == None :
  54             #  if cr == 'oui' :
  55             #    self.cr.fatal('Le concept '+self.sd.nom+" n'existe pas")
  56             #  valid = 0
  57           else :
  58             if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
  59             valid = 0
  60         # on teste, si elle existe, le nom de la sd (sa longueur doit être <= 8 caractères)
  61         if self.sd != None :
  62           # la SD existe déjà : on regarde son nom
  63           if self.sd.nom != None :
  64             if len(self.sd.nom) > 8 and self.jdc.definition.code == 'ASTER' :
  65               if cr == 'oui' :
  66                 self.cr.fatal("Le nom de concept %s est trop long (8 caractères maxi)" %self.sd.nom)
  67               valid = 0
  68             if string.find(self.sd.nom,'sansnom') != -1 :
  69               # la SD est 'sansnom' : --> erreur
  70               if cr == 'oui' :
  71                 self.cr.fatal("Pas de nom pour le concept retourné")
  72               valid = 0
  73             elif string.find(self.sd.nom,'SD_') != -1 :
  74               # la SD est 'SD_' cad son nom = son id donc pas de nom donné par utilisateur : --> erreur
  75               if cr == 'oui' :
  76                 self.cr.fatal("Pas de nom pour le concept retourné")
  77               valid = 0
  78         # on teste les enfants
  79         for child in self.mc_liste :
  80           if not child.isvalid():
  81             valid = 0
  82             break
  83         # on teste les règles de self
  84         text_erreurs,test_regles = self.verif_regles()
  85         if not test_regles :
  86           if cr == 'oui' : self.cr.fatal(string.join(("Règle(s) non respectée(s) :", text_erreurs)))
  87           valid = 0
  88         if self.reste_val != {}:
  89           if cr == 'oui' :
  90             self.cr.fatal("Mots cles inconnus :" + string.join(self.reste_val.keys(),','))
  91           valid=0
  92         if sd == 'oui' and valid:
  93           valid = self.update_sdprod(cr)
  94         self.valid = valid
  95         self.state = 'unchanged'
  96         if old_valid:
  97           if old_valid != self.valid : self.init_modif_up()
  98         return self.valid
  99
 100    def update_sdprod(self,cr='non'):
 101       """
 102            Cette méthode met à jour le concept produit en fonction des conditions initiales :
 103
 104             1- Il n'y a pas de concept retourné (self.definition.sd_prod == None)
 105
 106             2- Le concept retourné n existait pas (self.sd == None)
 107
 108             3- Le concept retourné existait. On change alors son type ou on le supprime
 109
 110            En cas d'erreur (exception) on retourne un indicateur de validité de 0 sinon de 1
 111       """
 112       sd_prod=self.definition.sd_prod
 113       if type(sd_prod) == types.FunctionType: # Type de concept retourné calculé
 114         d=self.cree_dict_valeurs(self.mc_liste)
 115         try:
 116           sd_prod= apply(sd_prod,(),d)
 117         except:
 118           # Erreur pendant le calcul du type retourné
 119           if CONTEXT.debug:traceback.print_exc()
 120           self.sd=None
 121           if cr == 'oui' :
 122              l=traceback.format_exception(sys.exc_info()[0],
 123                                           sys.exc_info()[1],
 124                                           sys.exc_info()[2])
 125              self.cr.fatal('Impossible d affecter un type au résultat\n'+ string.join(l[2:]))
 126           return 0
 127       # on teste maintenant si la SD est r\351utilis\351e ou s'il faut la cr\351er
 128       if self.reuse:
 129         if AsType(self.reuse) != sd_prod:
 130           if cr == 'oui' : self.cr.fatal('Type de concept reutilise incompatible avec type produit')
 131           return 0
 132         self.sd=self.reuse
 133         return 1
 134       else:
 135         if sd_prod == None:# Pas de concept retourné
 136           # Que faut il faire de l eventuel ancien sd ?
 137           self.sd = None
 138         else:
 139           if self.sd:
 140              # Un sd existe deja, on change son type
 141              self.sd.__class__=sd_prod
 142           else:
 143              # Le sd n existait pas , on ne le crée pas
 144              if cr == 'oui' : self.cr.fatal("Concept retourné non défini")
 145              return 0
 146         if self.definition.reentrant == 'o':
 147           self.reuse = self.sd
 148         return 1
 149
 150
 151    def report(self):
 152       """
 153           Methode pour generation d un rapport de validite
 154       """
 155       self.cr=self.CR(debut='Etape : '+self.nom \
 156                 + '    ligne : '+`self.appel[0]`\
 157                 + '    fichier : '+`self.appel[1]`,
 158                  fin = 'Fin Etape : '+self.nom)
 159       self.state = 'modified'
 160       try:
 161         self.isvalid(cr='oui')
 162       except AsException,e:
 163         if CONTEXT.debug : traceback.print_exc()
 164         self.cr.fatal(string.join(('Etape :',self.nom,
 165                               'ligne :',`self.appel[0]`,
 166                               'fichier :',`self.appel[1]`,str(e))))
 167       for child in self.mc_liste:
 168         self.cr.add(child.report())
 169       return self.cr
 170