1 # -*- coding: utf-8 -*-
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.
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.
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.
20 # ======================================================================
25 import traceback,types,string
29 from Noyau.N_ASSD import ASSD
31 # import rajoutés suite à l'ajout de Build_sd --> à résorber
32 import Noyau, Validation.V_MACRO_ETAPE
33 from Noyau import N_Exception
34 from Noyau.N_Exception import AsException
35 import Accas # attention aux imports circulaires
36 # fin import à résorber
38 class MACRO_ETAPE(I_ETAPE.ETAPE):
42 self.recorded_units={}
44 def get_sdprods(self,nom_sd):
46 Fonction : retourne le concept produit par l etape de nom nom_sd
47 s il existe sinon None
49 if self.sd and self.sd.nom == nom_sd :return self.sd
50 for co in self.sdprods:
51 if co.nom == nom_sd:return co
52 if type(self.definition.op_init) == types.FunctionType:
54 apply(self.definition.op_init,(self,d))
55 return d.get(nom_sd,None)
58 def get_contexte_jdc(self,fichier,text):
60 Interprète text comme un texte de jdc et retourne le
62 cad le dictionnaire des sd disponibles à la dernière étape
63 Si text n'est pas un texte de jdc valide, retourne None
65 --> utilisée par ops.POURSUITE et INCLUDE
67 #print "get_contexte_jdc"
69 # on essaie de créer un objet JDC auxiliaire avec un contexte initial
70 # Attention get_contexte_avant retourne un dictionnaire qui contient
71 # le contexte courant. Ce dictionnaire est reactualise regulierement.
72 # Si on veut garder l'etat du contexte fige, il faut en faire une copie.
73 context_ini = self.parent.get_contexte_avant(self).copy()
75 # Indispensable avant de creer un nouveau JDC
76 CONTEXT.unset_current_step()
79 if hasattr(self,'prefix'):
80 prefix_include=self.prefix
81 # ATTENTION : le dictionnaire recorded_units sert à memoriser les unites des
82 # fichiers inclus. Il est preferable de garder le meme dictionnaire pendant
83 # tout le traitement et de ne pas le reinitialiser brutalement (utiliser
84 # clear plutot) si on ne veut pas perdre la memoire des unites.
85 # En principe si la memorisation est faite au bon moment il n'est pas necessaire
86 # de prendre cette precaution mais ce n'est pas vrai partout.
87 old_recorded_units=self.recorded_units.copy()
88 #print "get_contexte_jdc",id(self.recorded_units)
89 #self.recorded_units.clear()
91 j=self.JdC_aux( procedure=text, nom=fichier,
94 cata_ord_dico=self.jdc.cata_ordonne_dico,
95 context_ini = context_ini,
96 jdc_pere=self.jdc,etape_include=self,
97 prefix_include=prefix_include,
98 recorded_units=self.recorded_units,
99 old_recorded_units=old_recorded_units,**args)
102 # On récupère les étapes internes (pour validation)
105 #print "get_contexte_jdc",id(self.etapes)
107 traceback.print_exc()
108 # On force le contexte (etape courante) à self
109 CONTEXT.unset_current_step()
110 CONTEXT.set_current_step(self)
113 if not j.cr.estvide():
114 # Erreurs dans l'INCLUDE. On garde la memoire du fichier
115 # mais on n'insere pas les concepts
116 # On force le contexte (etape courante) à self
117 CONTEXT.unset_current_step()
118 CONTEXT.set_current_step(self)
119 raise Exception("Impossible de relire le fichier\n"+str(j.cr))
122 # L'INCLUDE n'est pas valide.
123 # on produit un rapport d'erreurs
124 # On force le contexte (etape courante) à self
126 CONTEXT.unset_current_step()
127 CONTEXT.set_current_step(self)
128 raise Exception("Le fichier include contient des erreurs\n"+str(cr))
130 # Si aucune erreur rencontrée
131 # On recupere le contexte de l'include verifie
132 #print "context_ini",j.context_ini
133 #print "g_context",j.g_context
135 j_context=j.get_verif_contexte()
137 CONTEXT.unset_current_step()
138 CONTEXT.set_current_step(self)
141 #print "context_ini",j.context_ini
143 # On remplit le dictionnaire des concepts produits inclus
144 # en retirant les concepts présents dans le contexte initial
145 # On ajoute egalement le concept produit dans le sds_dict du parent
146 # sans verification car on est sur (verification integrée) que
147 # le nommage est possible
148 self.g_context.clear()
149 for k,v in j_context.items():
150 if not context_ini.has_key(k) or context_ini[k] != v:
152 self.parent.sds_dict[k]=v
155 # On recupere le contexte courant
156 self.current_context=j.current_context
157 self.index_etape_courante=j.index_etape_courante
160 # XXX j.supprime() ???
161 # On rétablit le contexte (etape courante) à self
162 CONTEXT.unset_current_step()
163 CONTEXT.set_current_step(self)
164 #print "context_ini",self.jdc_aux.context_ini
168 def reevalue_sd_jdc(self):
170 Avec la liste des SD qui ont été supprimées, propage la
171 disparition de ces SD dans toutes les étapes et descendants
173 #print "reevalue_sd_jdc"
174 l_sd_supp,l_sd_repl = self.diff_contextes()
176 self.parent.delete_concept_after_etape(self,sd)
177 for old_sd,sd in l_sd_repl:
178 self.parent.replace_concept_after_etape(self,old_sd,sd)
180 def diff_contextes(self):
182 Réalise la différence entre les 2 contextes
183 old_contexte_fichier_init et contexte_fichier_init
184 cad retourne la liste des sd qui ont disparu ou ne derivent pas
185 de la meme classe et des sd qui ont ete remplacees
187 if not hasattr(self,'old_contexte_fichier_init'):return [],[]
190 for old_key in self.old_contexte_fichier_init.keys():
191 if not self.contexte_fichier_init.has_key(old_key):
192 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
193 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
195 if isinstance(self.old_contexte_fichier_init[old_key],ASSD):
196 # Un concept de meme nom existe
197 old_class=self.old_contexte_fichier_init[old_key].__class__
198 if not isinstance(self.contexte_fichier_init[old_key],old_class):
199 # S'il n'est pas d'une classe derivee, on le supprime
200 l_sd_suppressed.append(self.old_contexte_fichier_init[old_key])
202 l_sd_replaced.append((self.old_contexte_fichier_init[old_key],self.contexte_fichier_init[old_key]))
203 return l_sd_suppressed,l_sd_replaced
205 def control_sdprods(self,d):
207 Cette methode doit updater le contexte fournit par
208 l'appelant en argument (d) en fonction de sa definition
209 tout en verifiant que ses concepts produits ne sont pas
210 deja definis dans le contexte
212 if hasattr(self,"fichier_unite"):
213 self.update_fichier_init(self.fichier_unite)
216 if type(self.definition.op_init) == types.FunctionType:
217 apply(self.definition.op_init,(self,d))
219 if d.has_key(self.sd.nom):
220 # Le concept est deja defini
221 if self.reuse and self.reuse is d[self.sd.nom]:
222 # Le concept est reutilise : situation normale
225 # Redefinition du concept, on l'annule
226 #XXX on pourrait simplement annuler son nom pour conserver les objets
227 # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
228 self.sd=self.reuse=self.sdnom=None
231 # Le concept n'est pas defini, on peut updater d
232 d[self.sd.nom]=self.sd
233 # On verifie les concepts a droite du signe =
234 for co in self.sdprods:
235 if d.has_key(co.nom) and co is not d[co.nom] :
236 self.delete_concept(co)
240 def supprime_sdprod(self,sd):
242 Supprime le concept produit sd s'il est produit par l'etape
244 if sd in self.sdprods:
246 self.parent.del_sdprod(sd)
247 self.sdprods.remove(sd)
249 self.parent.delete_concept(sd)
252 if sd is not self.sd :return
253 if self.sd is not None :
255 self.parent.del_sdprod(sd)
258 self.parent.delete_concept(sd)
260 def supprime_sdprods(self):
262 Fonction: Lors de la destruction de la macro-etape, detruit tous les concepts produits
263 Un opérateur n a qu un concept produit
264 Une procedure n'en a aucun
265 Une macro en a en général plus d'un
267 #print "supprime_sdprods"
268 if self.reuse is not self.sd :
269 # l'étape n'est pas réentrante
270 # le concept retourné par l'étape est à supprimer car il était
273 self.parent.del_sdprod(self.sd)
274 self.parent.delete_concept(self.sd)
275 # On détruit les concepts à droite du signe =
276 for co in self.sdprods:
277 self.parent.del_sdprod(co)
278 self.parent.delete_concept(co)
279 # Si la macro a des etapes et des concepts inclus, on les detruit
280 for nom_sd,co in self.g_context.items():
281 if not isinstance(co,ASSD):continue
282 self.parent.del_sdprod(co)
283 self.parent.delete_concept(co)
284 # On met g_context à blanc
288 #print "MACRO_ETAPE.close",self
289 if hasattr(self,"jdc_aux") and self.jdc_aux:
290 # La macro a un jdc auxiliaire inclus. On demande sa fermeture
293 def delete_concept(self,sd):
295 Fonction : Mettre a jour les mots cles de l etape et eventuellement
296 le concept produit si reuse suite à la disparition du concept sd
297 Seuls les mots cles simples MCSIMP font un traitement autre
298 que de transmettre aux fils
300 #print "delete_concept",sd
301 I_ETAPE.ETAPE.delete_concept(self,sd)
302 for etape in self.etapes:
303 etape.delete_concept(sd)
305 def replace_concept(self,old_sd,sd):
307 Fonction : Mettre a jour les mots cles de l etape et le concept produit si reuse
308 suite au remplacement du concept old_sd par sd
310 #print "replace_concept",old_sd,sd
311 I_ETAPE.ETAPE.replace_concept(self,old_sd,sd)
312 for etape in self.etapes:
313 etape.replace_concept(old_sd,sd)
315 def change_fichier_init(self,new_fic,text):
317 Tente de changer le fichier include. Le precedent include est conservé
320 if not hasattr(self,'fichier_ini'):
321 self.fichier_ini=None
322 self.fichier_text=None
323 self.fichier_err="Le fichier n'est pas defini"
324 self.contexte_fichier_init={}
325 self.recorded_units={}
327 self.fichier_unite="PasDefini"
328 import Extensions.jdc_include
329 self.JdC_aux=Extensions.jdc_include.JdC_include
331 self.old_fic = self.fichier_ini
332 self.old_text = self.fichier_text
333 self.old_err = self.fichier_err
334 self.old_context=self.contexte_fichier_init
335 self.old_units=self.recorded_units
336 self.old_etapes=self.etapes
337 self.old_jdc_aux=self.jdc_aux
339 self.fichier_ini = new_fic
340 self.fichier_text=text
343 self.make_contexte_include(new_fic,text)
345 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
346 self.fichier_err=string.join(l)
349 # L'evaluation de text dans un JDC auxiliaire s'est bien passé
350 # on peut poursuivre le traitement
352 self.state="undetermined"
353 self.fichier_err=None
354 # On enregistre la modification de fichier
356 # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
357 self.parent.reset_context()
359 # Si des concepts ont disparu lors du changement de fichier, on demande leur suppression
360 self.old_contexte_fichier_init=self.old_context
361 self.reevalue_sd_jdc()
365 def restore_fichier_init(self):
367 Restaure le fichier init enregistre dans old_xxx
369 self.fichier_ini=self.old_fic
370 self.fichier_text=self.old_text
371 self.fichier_err=self.old_err
372 self.contexte_fichier_init=self.old_context
373 self.recorded_units=self.old_units
374 self.etapes=self.old_etapes
375 self.jdc_aux=self.old_jdc_aux
377 def force_fichier_init(self):
379 Force le remplacement du fichier init meme si le remplacant est en erreur
381 # Reinitialisation complete du compte-rendu d'erreurs
382 self.jdc_aux.cr=self.jdc_aux.CR()
383 # On remplit le dictionnaire des concepts produits inclus
384 # en retirant les concepts présents dans le contexte initial
385 # On ajoute egalement le concept produit dans le sds_dict du parent
386 # sans verification car on est sur (verification integrée) que
387 # le nommage est possible
388 j_context=self.jdc_aux.get_contexte_avant(None)
389 self.g_context.clear()
390 context_ini=self.jdc_aux.context_ini
391 for k,v in j_context.items():
392 if not context_ini.has_key(k) or context_ini[k] != v:
394 self.parent.sds_dict[k]=v
395 # On recupere le contexte courant
396 self.current_context=self.jdc_aux.current_context
397 self.index_etape_courante=self.jdc_aux.index_etape_courante
398 self.contexte_fichier_init = j_context
400 # On enregistre la modification de fichier
402 self.state="undetermined"
404 # Le contexte du parent doit etre reinitialise car les concepts produits ont changé
405 self.parent.reset_context()
407 # On remplace les anciens concepts par les nouveaux (y compris ajouts
408 # et suppression) et on propage les modifications aux etapes precedentes et suivantes
409 # reevalue_sd_jdc construit la liste des differences entre les contextes contexte_fichier_init
410 # et old_contexte_fichier_init et effectue les destructions et remplacements de concept
412 self.old_contexte_fichier_init=self.old_context
413 self.reevalue_sd_jdc()
416 self.jdc_aux.force_contexte(self.g_context)
419 def make_contexte_include(self,fichier,text):
421 Cette méthode sert à créer un contexte en interprétant un texte source
424 #print "make_contexte_include"
425 # on récupère le contexte d'un nouveau jdc dans lequel on interprete text
426 contexte = self.get_contexte_jdc(fichier,text)
427 if contexte == None :
428 raise Exception("Impossible de construire le jeu de commandes correspondant au fichier")
430 # Pour les macros de type include : INCLUDE, INCLUDE_MATERIAU et POURSUITE
431 # l'attribut g_context est un dictionnaire qui contient les concepts produits par inclusion
432 # l'attribut contexte_fichier_init est un dictionnaire qui contient les concepts produits
433 # en sortie de macro. g_context est obtenu en retirant de contexte_fichier_init les concepts
434 # existants en debut de macro contenus dans context_ini (dans get_contexte_jdc)
435 # g_context est utilisé pour avoir les concepts produits par la macro
436 # contexte_fichier_init est utilisé pour avoir les concepts supprimés par la macro
437 self.contexte_fichier_init = contexte
439 def reevalue_fichier_init_OBSOLETE(self):
440 """Recalcule les concepts produits par le fichier enregistre"""
441 #print "reevalue_fichier_init"
442 old_context=self.contexte_fichier_init
444 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
446 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
447 self.fichier_err = string.join(l)
451 self.old_contexte_fichier_init=old_context
452 self.contexte_fichier_init={}
453 self.reevalue_sd_jdc()
456 # L'evaluation s'est bien passee
457 self.fichier_err = None
458 self.old_contexte_fichier_init=old_context
459 self.reevalue_sd_jdc()
460 #print "reevalue_fichier_init",self.jdc_aux.context_ini
462 def update_fichier_init(self,unite):
463 """Reevalue le fichier init sans demander (dans la mesure du possible) a l'utilisateur
464 les noms des fichiers
465 Ceci suppose que les relations entre unites et noms ont été memorisees préalablement
467 #print "update_fichier_init",unite
468 self.fichier_err=None
469 self.old_contexte_fichier_init=self.contexte_fichier_init
470 old_fichier_ini=self.fichier_ini
472 #print "update_fichier_init",self,self.parent,self.parent.recorded_units
474 #if unite != self.fichier_unite or not self.parent.recorded_units.has_key(unite):
475 if not self.parent.recorded_units.has_key(unite):
476 # Le numero d'unite a ete change. Le nouveau numero ne fait pas partie des numeros
478 f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
481 self.fichier_text=text
482 #print "update_fichier_init",self.recorded_units
485 f,text,units=self.parent.recorded_units[unite]
487 self.fichier_text=text
488 self.recorded_units=units
490 if self.fichier_ini is None:
491 # Le fichier n'est pas défini
492 self.fichier_err="Le fichier associé n'est pas défini"
493 self.parent.change_unit(unite,self,self.fichier_unite)
497 self.contexte_fichier_init={}
498 self.parent.reset_context()
499 self.reevalue_sd_jdc()
502 if old_fichier_ini == self.fichier_ini:
503 # Le fichier inclus n'a pas changé. On ne recrée pas le contexte
504 #print "update_fichier_init.fichier inchange",self.jdc_aux.context_ini
508 self.make_contexte_include(self.fichier_ini,self.fichier_text)
509 # Les 3 attributs fichier_ini fichier_text recorded_units doivent etre corrects
510 # avant d'appeler change_unit
511 self.parent.change_unit(unite,self,self.fichier_unite)
513 # Erreurs lors de l'evaluation de text dans un JDC auxiliaire
514 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
515 # On conserve la memoire du nouveau fichier
516 # mais on n'utilise pas les concepts crees par ce fichier
517 # on met l'etape en erreur : fichier_err=string.join(l)
518 self.fichier_err=string.join(l)
519 self.parent.change_unit(unite,self,self.fichier_unite)
523 self.contexte_fichier_init={}
525 # Le contexte du parent doit etre reinitialise car les concepts
526 # produits ont changé
527 self.parent.reset_context()
528 # Si des concepts ont disparu lors du changement de fichier, on
529 # demande leur suppression
530 self.reevalue_sd_jdc()
531 #print "update_fichier_init",self.jdc_aux.context_ini
533 def record_unite(self):
534 if self.nom == "POURSUITE":
535 self.parent.record_unit(None,self)
537 if hasattr(self,'fichier_unite') :
538 self.parent.record_unit(self.fichier_unite,self)
540 def get_file_memo(self,unite=None,fic_origine=''):
541 """Retourne le nom du fichier et le source correspondant a l'unite unite
542 Initialise en plus recorded_units
544 #print "get_file_memo",unite,fic_origine,self,self.parent
545 #print self.parent.old_recorded_units
546 #print self.parent.recorded_units
548 # On est dans le cas d'une poursuite. On ne reutilise aucune unite de parent
551 # On est dans le cas d'un include. On reutilise toutes les unites de parent
552 units=self.parent.recorded_units
554 #if self.parent.old_recorded_units.has_key(unite):
555 if self.parent.recorded_units.has_key(unite):
556 f,text,units=self.parent.recorded_units[unite]
557 #f,text,units=self.parent.old_recorded_units[unite]
558 #print id(self.recorded_units)
559 self.recorded_units=units
560 #print id(self.recorded_units)
563 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
567 self.recorded_units=units
568 if f is None and self.jdc.appli:
569 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
570 message="Ce fichier ne sera pas pris en compte\n"+"Le fichier associé n'est pas défini")
573 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
574 def get_file(self,unite=None,fic_origine=''):
575 """Retourne le nom du fichier et le source correspondant a l'unite unite
578 f,text=self.jdc.get_file(unite=unite,fic_origine=fic_origine)
583 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
584 def make_include(self,unite=None):
586 Inclut un fichier dont l'unite logique est unite
587 Cette methode est appelee par la fonction sd_prod de la macro INCLUDE
588 Si l'INCLUDE est invalide, la methode doit produire une exception
589 Sinon on retourne None. Les concepts produits par l'INCLUDE sont
590 pris en compte par le JDC parent lors du calcul du contexte (appel de ???)
592 #print "make_include",unite
593 # On supprime l'attribut unite qui bloque l'evaluation du source de l'INCLUDE
594 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
596 # Si unite n'a pas de valeur, l'etape est forcement invalide. On peut retourner None
597 if not unite : return
599 if not hasattr(self,'fichier_ini') :
600 # Si le fichier n'est pas defini on le demande
601 f,text=self.get_file_memo(unite=unite,fic_origine=self.parent.nom)
602 # On memorise le fichier retourne
604 self.fichier_text = text
605 self.contexte_fichier_init={}
606 self.fichier_unite=unite
607 self.fichier_err=None
609 import Extensions.jdc_include
611 traceback.print_exc()
613 self.JdC_aux=Extensions.jdc_include.JdC_include
616 self.fichier_err="Le fichier INCLUDE n est pas defini"
617 self.parent.record_unit(unite,self)
618 raise Exception(self.fichier_err)
621 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
622 self.parent.record_unit(unite,self)
623 #print "make_include.context_ini",self.jdc_aux.context_ini
625 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
627 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier inclus",
628 message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
630 self.parent.record_unit(unite,self)
634 self.fichier_err = string.join(l)
635 self.contexte_fichier_init={}
639 # Si le fichier est deja defini on ne reevalue pas le fichier
640 # et on leve une exception si une erreur a été enregistrée
641 self.update_fichier_init(unite)
642 self.fichier_unite=unite
643 if self.fichier_err is not None: raise Exception(self.fichier_err)
646 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
647 def make_contexte(self,fichier,text):
649 Cette méthode sert à créer un contexte pour INCLUDE_MATERIAU
650 en interprétant un texte source Python
651 Elle est appelee par la fonction sd_prd d'INCLUDE_MATERIAU
653 # On supprime l'attribut mat qui bloque l'evaluation du source de l'INCLUDE_MATERIAU
654 # car on ne s'appuie pas sur lui dans EFICAS mais sur l'attribut fichier_ini
655 if hasattr(self,'mat'):del self.mat
656 self.fichier_ini =fichier
657 self.fichier_unite =fichier
658 self.fichier_text=text
659 self.fichier_err=None
660 self.contexte_fichier_init={}
661 # On specifie la classe a utiliser pour le JDC auxiliaire
663 import Extensions.jdc_include
665 traceback.print_exc()
667 self.JdC_aux=Extensions.jdc_include.JdC_include
669 self.make_contexte_include(self.fichier_ini ,self.fichier_text)
670 self.parent.record_unit(self.fichier_unite,self)
672 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
673 self.fichier_err = string.join(l)
674 self.parent.record_unit(self.fichier_unite,self)
678 self.contexte_fichier_init={}
681 #ATTENTION SURCHARGE : cette methode surcharge celle de Noyau (a garder en synchro)
682 def update_sdprod(self,cr='non'):
683 # Cette methode peut etre appelee dans EFICAS avec des mots cles de
684 # la commande modifies. Ceci peut conduire a la construction ou
685 # a la reconstruction d'etapes dans le cas d'INCLUDE ou d'INCLUDE_MATERIAU
686 # Il faut donc positionner le current_step avant l'appel
687 CONTEXT.unset_current_step()
688 CONTEXT.set_current_step(self)
689 valid=Validation.V_MACRO_ETAPE.MACRO_ETAPE.update_sdprod(self,cr=cr)
690 CONTEXT.unset_current_step()
693 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
694 def Build_sd(self,nom):
696 Methode de Noyau surchargee pour poursuivre malgre tout
697 si une erreur se produit pendant la creation du concept produit
700 sd=Noyau.N_MACRO_ETAPE.MACRO_ETAPE.Build_sd(self,nom)
701 except AsException,e:
702 # Une erreur s'est produite lors de la construction du concept
703 # Comme on est dans EFICAS, on essaie de poursuivre quand meme
704 # Si on poursuit, on a le choix entre deux possibilités :
705 # 1. on annule la sd associée à self
706 # 2. on la conserve mais il faut la retourner
707 # On choisit de l'annuler
708 # En plus il faut rendre coherents sdnom et sd.nom
711 self.state="unchanged"
716 #ATTENTION SURCHARGE: cette methode surcharge celle de Noyau a garder en synchro
717 def make_poursuite(self):
718 """ Cette methode est appelée par la fonction sd_prod de la macro POURSUITE
720 #print "make_poursuite"
721 if not hasattr(self,'fichier_ini') :
722 # Si le fichier n'est pas defini on le demande
723 f,text=self.get_file_memo(fic_origine=self.parent.nom)
724 # On memorise le fichier retourne
726 self.fichier_unite = None
727 self.fichier_text = text
728 self.fichier_err=None
730 import Extensions.jdc_include
732 traceback.print_exc()
734 self.JdC_aux=Extensions.jdc_include.JdC_poursuite
735 self.contexte_fichier_init={}
738 self.fichier_err="Le fichier POURSUITE n'est pas defini"
739 self.parent.record_unit(None,self)
740 raise Exception(self.fichier_err)
743 self.make_contexte_include(self.fichier_ini,self.fichier_text)
744 self.parent.record_unit(None,self)
746 l=traceback.format_exception_only("Fichier invalide",sys.exc_info()[1])
748 self.jdc.appli.affiche_alerte("Erreur lors de l'evaluation du fichier poursuite",
749 message="Ce fichier ne sera pas pris en compte\n"+string.join(l)
751 self.parent.record_unit(None,self)
755 self.fichier_err = string.join(l)
756 self.contexte_fichier_init={}
760 # Si le fichier est deja defini on ne reevalue pas le fichier
761 # et on leve une exception si une erreur a été enregistrée
762 self.update_fichier_init(None)
763 if self.fichier_err is not None: raise Exception(self.fichier_err)