Extensions/jdc_include.py

   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.
   9 #
  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.
  14 #
  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.
  18 #
  19 #
  20 # ======================================================================
  21
  22 """
  23    Ce module contient la classe JDC_INCLUDE qui sert a inclure
  24    dans un jeu de commandes une partie de jeu de commandes
  25    au moyen de la fonctionnalite INCLUDE ou INCLUDE_MATERIAU
  26    Quand l'utilisateur veut inclure un fichier il faut versifier
  27    que le jeu de commandes inclus est valide et compatible
  28    avec le contexte avant et apres l'insertion
  29 """
  30 from Accas import JDC,ASSD,AsException,JDC_CATA
  31 from Ihm import CONNECTOR
  32
  33 class JDC_POURSUITE(JDC):
  34    def __init__(self,definition=None,procedure=None,cata=None,
  35                      cata_ord_dico=None,parent=None,
  36                      nom='SansNom',appli=None,context_ini=None,
  37                      jdc_pere=None,etape_include=None,prefix_include=None,
  38                      recorded_units=None,old_recorded_units=None,**args):
  39
  40       JDC.__init__(self, definition=definition,
  41                          procedure=procedure,
  42                          cata=cata,
  43                          cata_ord_dico=cata_ord_dico,
  44                          parent=parent,
  45                          nom=nom,
  46                          appli=appli,
  47                          context_ini=context_ini,
  48                          **args
  49                          )
  50       self.jdc_pere=jdc_pere
  51       self.etape_include=etape_include
  52       self.prefix_include=prefix_include
  53       if recorded_units is not None:self.recorded_units=recorded_units
  54       if old_recorded_units is not None:self.old_recorded_units=old_recorded_units
  55
  56    def NommerSdprod(self,sd,sdnom,restrict='non'):
  57       """
  58           Nomme la SD apres avoir verifie que le nommage est possible : nom
  59           non utilise
  60           Ajoute un prefixe s'il est specifie (INCLUDE_MATERIAU)
  61           Si le nom est deja utilise, leve une exception
  62           Met le concept créé dans le contexe global g_context
  63       """
  64       #print "NommerSdprod",sd,sdnom,restrict
  65       if self.prefix_include:
  66           if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
  67       o=self.sds_dict.get(sdnom,None)
  68       if isinstance(o,ASSD):
  69          raise AsException("Nom de concept deja defini : %s" % sdnom)
  70
  71       # On pourrait verifier que le jdc_pere apres l'etape etape_include
  72       # ne contient pas deja un concept de ce nom
  73       #if self.jdc_pere.get_sd_apres_etape_avec_detruire(sdnom,etape=self.etape_include):
  74          # Il existe un concept apres self => impossible d'inserer
  75       #   raise AsException("Nom de concept deja defini : %s" % sdnom)
  76       # On a choisi de ne pas faire ce test ici mais de le faire en bloc
  77       # si necessaire apres en appelant la methode verif_contexte
  78
  79       # ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
  80       # Ajoute a la creation (appel de reg_sd).
  81       self.sds_dict[sdnom]=sd
  82       sd.nom=sdnom
  83
  84       # En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
  85       if restrict == 'non':
  86          self.g_context[sdnom]=sd
  87
  88    def get_verif_contexte(self):
  89       #print "get_verif_contexte"
  90       j_context=self.get_contexte_avant(None)
  91       self.verif_contexte(j_context)
  92       return j_context
  93
  94    def force_contexte(self,contexte):
  95       for nom_sd,sd in contexte.items():
  96         if not isinstance(sd,ASSD):continue
  97         autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
  98                                                        etape=self.etape_include)
  99         if autre_sd is None:continue
 100         if sd is not autre_sd:
 101            # Il existe un autre concept de meme nom produit par une etape apres self
 102            # on detruit ce concept pour pouvoir inserer les etapes du jdc_include
 103            if sd.etape:
 104               sd.etape.supprime_sdprod(sd)
 105
 106       return contexte
 107
 108    def verif_contexte(self,context):
 109       """
 110          Cette methode verifie si le contexte passé en argument (context)
 111          peut etre inséré dans le jdc pere de l'include.
 112          Elle verifie que les concepts contenus dans ce contexte n'entrent
 113          pas en conflit avec les concepts produits dans le jdc pere
 114          apres l'include.
 115          Si le contexte ne peut pas etre inséré, la méthode leve une
 116          exception sinon elle retourne le contexte inchangé
 117       """
 118       #print "verif_contexte"
 119       for nom_sd,sd in context.items():
 120         if not isinstance(sd,ASSD):continue
 121         autre_sd= self.jdc_pere.get_sd_apres_etape_avec_detruire(nom_sd,sd,
 122                                                        etape=self.etape_include)
 123         if autre_sd is None:continue
 124         if sd is not autre_sd:
 125            # Il existe un concept produit par une etape apres self
 126            # => impossible d'inserer
 127            raise Exception("Impossible d'inclure le fichier. Un concept de nom " +
 128                            "%s existe déjà dans le jeu de commandes." % nom_sd)
 129
 130       return context
 131
 132    def get_liste_cmd(self):
 133       """
 134           Retourne la liste des commandes du catalogue
 135       """
 136       if self.jdc_pere is None:
 137          return JDC.get_liste_cmd(self)
 138       return self.jdc_pere.get_liste_cmd()
 139
 140    def get_groups(self):
 141       """
 142           Retourne la liste des commandes du catalogue par groupes
 143       """
 144       if self.jdc_pere is None:
 145          return JDC.get_groups(self)
 146       return self.jdc_pere.get_groups()
 147
 148    def init_modif(self):
 149       """
 150          Met l'état de l'étape à : modifié
 151          Propage la modification au parent
 152
 153          Attention : init_modif doit etre appelé avant de réaliser une modification
 154          La validité devra etre recalculée apres cette modification
 155          mais par un appel à fin_modif pour préserver l'état modified
 156          de tous les objets entre temps
 157       """
 158       #print "jdc_include.init_modif",self,self.etape_include
 159       self.state = 'modified'
 160       if self.etape_include:
 161          self.etape_include.init_modif()
 162
 163    def fin_modif(self):
 164       """
 165           Méthode appelée une fois qu'une modification a été faite afin de
 166           déclencher d'éventuels traitements post-modification
 167           ex : INCLUDE et POURSUITE
 168       """
 169       #print "jdc_include.fin_modif",self,self.etape_include
 170       CONNECTOR.Emit(self,"valid")
 171       if self.etape_include:
 172          self.etape_include.fin_modif()
 173
 174    def supprime(self):
 175       """
 176           On ne supprime rien directement pour un jdc auxiliaire d'include ou de poursuite
 177           Utiliser supprime_aux
 178       """
 179       pass
 180
 181    def supprime_aux(self):
 182       #print "supprime_aux",self
 183       JDC.supprime(self)
 184       self.jdc_pere=None
 185       self.etape_include=None
 186    #   self.cata_ordonne_dico={}
 187       self.appli=None
 188    #   self.context_ini={}
 189    #   self.procedure=None
 190
 191    def get_contexte_avant(self,etape):
 192       """
 193          Retourne le dictionnaire des concepts connus avant etape
 194          On tient compte des concepts produits par le jdc pere
 195          en reactualisant le contexte initial context_ini
 196          On tient compte des commandes qui modifient le contexte
 197          comme DETRUIRE ou les macros
 198          Si etape == None, on retourne le contexte en fin de JDC
 199       """
 200       #print "jdc_include.get_contexte_avant",etape,etape and etape.nom
 201       if self.etape_include:
 202          new_context=self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
 203          self.context_ini=new_context
 204       d= JDC.get_contexte_avant(self,etape)
 205       return d
 206
 207    def reset_context(self):
 208       #print "jdc_include.reset_context",self,self.nom
 209       if self.etape_include:
 210          self.etape_include.parent.reset_context()
 211          new_context=self.etape_include.parent.get_contexte_avant(self.etape_include).copy()
 212          self.context_ini=new_context
 213       JDC.reset_context(self)
 214
 215    def get_sd_apres_etape(self,nom_sd,etape,avec='non'):
 216       """
 217            Cette méthode retourne la SD de nom nom_sd qui est éventuellement
 218            définie apres etape
 219            Si avec vaut 'non' exclut etape de la recherche
 220       """
 221       if self.etape_include:
 222          sd=self.etape_include.parent.get_sd_apres_etape(nom_sd,self.etape_include,'non')
 223          if sd:return sd
 224       return JDC.get_sd_apres_etape(self,nom_sd,etape,avec)
 225
 226    def get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec='non'):
 227       """
 228            On veut savoir ce que devient le concept sd de nom nom_sd apres etape.
 229            Il peut etre detruit, remplacé ou conservé
 230            Cette méthode retourne la SD sd de nom nom_sd qui est éventuellement
 231            définie apres etape en tenant compte des concepts detruits
 232            Si avec vaut 'non' exclut etape de la recherche
 233       """
 234       #print "jdc_include.get_sd_apres_etape_avec_detruire",nom_sd,sd,id(sd)
 235       autre_sd=JDC.get_sd_apres_etape_avec_detruire(self,nom_sd,sd,etape,avec)
 236       # si autre_sd vaut None le concept sd a ete detruit. On peut terminer
 237       # la recherche en retournant None
 238       # Si autre_sd ne vaut pas sd, le concept a ete redefini. On peut terminer
 239       # la recherche en retournant le concept nouvellement defini
 240       # Sinon, on poursuit la recherche dans les etapes du niveau superieur.
 241       if autre_sd is None or autre_sd is not sd :return autre_sd
 242       return self.etape_include.parent.get_sd_apres_etape_avec_detruire(nom_sd,sd,self.etape_include,'non')
 243
 244    def delete_concept(self,sd):
 245       """
 246           Fonction : Mettre a jour les etapes du JDC suite à la disparition du
 247           concept sd
 248           Seuls les mots cles simples MCSIMP font un traitement autre
 249           que de transmettre aux fils
 250       """
 251       # Nettoyage des etapes de l'include
 252       JDC.delete_concept(self,sd)
 253       # Nettoyage des etapes du parent
 254       if self.etape_include:
 255          self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
 256
 257    def delete_concept_after_etape(self,etape,sd):
 258       """
 259           Fonction : Mettre à jour les étapes du JDC qui sont après etape suite à
 260           la disparition du concept sd
 261       """
 262       # Nettoyage des etapes de l'include
 263       JDC.delete_concept_after_etape(self,etape,sd)
 264       # Nettoyage des etapes du parent
 265       if self.etape_include:
 266          self.etape_include.parent.delete_concept_after_etape(self.etape_include,sd)
 267
 268    def update_concept_after_etape(self,etape,sd):
 269       """
 270           Fonction : mettre a jour les etapes du JDC suite a une modification
 271           du concept sd (principalement renommage)
 272       """
 273       JDC.update_concept_after_etape(self,etape,sd)
 274       if self.etape_include:
 275          self.etape_include.parent.update_concept_after_etape(self.etape_include,sd)
 276
 277    def replace_concept_after_etape(self,etape,old_sd,sd):
 278       """
 279           Fonction : Mettre à jour les étapes du JDC qui sont après etape suite au
 280           remplacement du concept old_sd par sd
 281       """
 282       # Nettoyage des etapes de l'include
 283       JDC.replace_concept_after_etape(self,etape,old_sd,sd)
 284       # Nettoyage des etapes du parent
 285       if self.etape_include:
 286          self.etape_include.parent.replace_concept_after_etape(self.etape_include,old_sd,sd)
 287
 288    def changefichier(self,fichier):
 289       if self.etape_include:
 290          self.etape_include.fichier_ini=fichier
 291       self.fin_modif()
 292
 293    def control_context_apres(self,etape):
 294       """
 295          Cette méthode verifie que les etapes apres l'etape etape
 296          ont bien des concepts produits acceptables (pas de conflit de
 297          nom principalement)
 298          Si des concepts produits ne sont pas acceptables ils sont supprimés.
 299          Effectue les verifications sur les etapes du jdc mais aussi sur les
 300          jdc parents s'ils existent.
 301       """
 302       #print "jdc_include.control_context_apres",self,etape
 303       #Regularise les etapes du jdc apres l'etape etape
 304       self.control_jdc_context_apres(etape)
 305       if self.etape_include:
 306          #print "CONTROL_INCLUDE:",self.etape_include,self.etape_include.nom
 307          # il existe un jdc pere. On propage la regularisation
 308          self.etape_include.parent.control_context_apres(self.etape_include)
 309
 310 class JDC_INCLUDE(JDC_POURSUITE):
 311    def get_liste_cmd(self):
 312       """
 313           Retourne la liste des commandes du catalogue
 314       """
 315       if self.jdc_pere is None:
 316          return JDC.get_liste_cmd(self)
 317       return [e for e in self.jdc_pere.get_liste_cmd() if e not in ("DEBUT","POURSUITE","FIN") ]
 318
 319    def active_etapes(self):
 320       for e in self.etapes:
 321          e.active()
 322
 323 class JDC_CATA_INCLUDE(JDC_CATA):
 324    class_instance=JDC_INCLUDE
 325
 326 class JDC_CATA_POURSUITE(JDC_CATA):
 327    class_instance=JDC_POURSUITE
 328
 329 from Accas import AU_MOINS_UN,A_CLASSER
 330
 331 JdC_include=JDC_CATA_INCLUDE(code='ASTER', execmodul=None)
 332
 333 JdC_poursuite=JDC_CATA_POURSUITE(code='ASTER', execmodul=None,
 334                                  regles = (AU_MOINS_UN('DEBUT','POURSUITE'),
 335                                            AU_MOINS_UN('FIN'),
 336                                            A_CLASSER(('DEBUT','POURSUITE'),'FIN')
 337                                           )
 338                                )
 339
 340