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