Ihm/I_ETAPE.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 """
  21 """
  22 # Modules Python
  23 from __future__ import absolute_import
  24 from __future__ import print_function
  25 import sys,re
  26 import types
  27 from copy import copy
  28
  29 from Extensions.i18n import tr
  30 from Extensions.eficas_exception import EficasException
  31
  32 # Objet re pour controler les identificateurs Python
  33 conceptRE=re.compile(r'[a-zA-Z_]\w*$')
  34
  35 # import rajoute suite a l'ajout de buildSd --> a resorber
  36 import traceback
  37 import Noyau
  38 from Noyau import N_Exception
  39 from Noyau.N_Exception import AsException
  40 import Validation
  41 # fin import a resorber
  42
  43 # Modules EFICAS
  44 from . import I_MCCOMPO
  45 from . import CONNECTOR
  46 from Extensions import commande_comm
  47
  48 class ETAPE(I_MCCOMPO.MCCOMPO):
  49
  50    def ident(self):
  51       return self.nom
  52
  53    def getSdname(self):
  54       #print "SDNAME ",self.reuse,self.sd,self.sd.getName()
  55       if CONTEXT.debug :
  56           print(("SDNAME ",  self.reuse,  self.sd,  self.sd.getName()))
  57       sdname=''
  58       if self.reuse != None:
  59         sdname= self.reuse.getName()
  60       else:
  61         if self.sd:sdname=self.sd.getName()
  62       if sdname.find('sansnom') != -1 or sdname.find('SD_') != -1:
  63         # dans le cas ou la SD est 'sansnom' ou 'SD_' on retourne la chaine vide
  64         return ''
  65       return sdname
  66
  67    def isReentrant(self):
  68       """
  69           Indique si la commande est reentrante
  70       """
  71       return self.definition.reentrant == 'o'
  72
  73    def initModif(self):
  74       """
  75          Met l'etat de l'etape a : modifie
  76          Propage la modification au parent
  77       """
  78       # initModif doit etre appele avant de realiser une modification
  79       # La validite devra etre recalculee apres cette modification
  80       # mais dans l'appel a finModif pour preserver l'etat modified
  81       # de tous les objets entre temps
  82       #print "initModif",self,self.parent
  83       self.state = 'modified'
  84       if self.parent:
  85         self.parent.initModif()
  86
  87    def finModif(self):
  88       """
  89           Methode appelee une fois qu'une modification a ete faite afin de
  90           declencher d'eventuels traitements post-modification
  91           ex : INCLUDE et POURSUITE
  92           Ne pas mettre de traitement qui risque d'induire des recursions (soit a peu pres rien)
  93       """
  94       CONNECTOR.Emit(self,"valid")
  95       if self.parent:
  96         self.parent.finModif()
  97
  98    def nommeSd(self,nom) :
  99       """
 100           Cette methode a pour fonction de donner un nom (nom) au concept
 101           produit par l'etape (self).
 102             - si le concept n'existe pas, on essaye de le creer a condition que l'etape soit valide ET non reentrante)
 103             - si il existe dea, on le renomme et on repercute les changements dans les autres etapes
 104           Les valeurs de retour sont :
 105             - 0 si le nommage n'a pas pu etre menea son terme,
 106             - 1 dans le cas contraire
 107       """
 108       # Le nom d'un concept doit etre un identificateur Python (toujours vrai ou insuffisant?)
 109       if not conceptRE.match(nom):
 110          return 0, tr("Un nom de concept doit etre un identificateur Python")
 111
 112       # pour eviter que le nom du concept soit le nom de la classe --> souci pour utiliser le concept
 113       if (nom == self.definition.nom) : return  (0, tr("un concept de type ")+ nom + tr(" ne peut pas se nommer ") +  nom)
 114       if ( nom in dir(self.jdc.cata)) : return (0, nom + tr("est un not reserve"))
 115       #if (not isinstance(nom,str)) : return (0, tr("Le nom ") + nom + tr(" est un mot reserve"))
 116       #if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
 117       #  return 0, tr("Nom de concept trop long (maxi 8 caracteres)")
 118
 119       self.initModif()
 120       #
 121       # On verifie d'abord si les mots cles sont valides
 122       #
 123       if not self.isValid(sd='non') : return 0,"Nommage du concept refuse : l'operateur n'est pas valide"
 124       #
 125       # Cas particulier des operateurs obligatoirement reentrants
 126       # plus de concept reentrant (pour Aster)
 127       #
 128       if self.definition.reentrant == 'o':
 129         self.sd = self.reuse = self.jdc.getSdAvantEtape(nom,self)
 130         if self.sd != None :
 131           self.sdnom=self.sd.nom
 132           self.finModif()
 133           return 1, tr("Concept existant")
 134         else:
 135           return 0, tr("Operateur reentrant mais concept non existant")
 136       #
 137       # Cas particulier des operateurs facultativement reentrants
 138       #
 139       old_reuse=None
 140       if self.definition.reentrant == 'f' :
 141         sd = self.jdc.getSdAvantEtape(nom,self)
 142         if sd != None :
 143           if isinstance(sd,self.getType_produit()) :
 144              self.sd = self.reuse = sd
 145              self.sdnom = sd.nom
 146              self.finModif()
 147              return 1, tr("Operateur reentrant et concept existant trouve")
 148           else:
 149              return 0, tr("Concept deja existant et de mauvais type")
 150         else :
 151           # il faut enlever le lien vers une SD existante car si on passe ici
 152           # cela signifie que l'operateur n'est pas utilise en mode reentrant.
 153           # Si on ne fait pas cela, on risque de modifier une SD produite par un autre operateur
 154           if self.reuse :
 155              old_reuse=self.reuse
 156              self.sd = self.reuse = self.sdnom = None
 157       #
 158       # On est dans le cas ou l'operateur n'est pas reentrant ou est facultativement reentrant
 159       # mais est utilise en mode non reentrant
 160       #
 161       if self.sd == None :
 162           #Pas de concept produit preexistant
 163           if self.parent.getSdAutourEtape(nom,self):
 164             # Un concept de ce nom existe dans le voisinage de l'etape courante
 165             # On retablit l'ancien concept reentrant s'il existait
 166             if old_reuse:
 167                self.sd=self.reuse=old_reuse
 168                self.sdnom=old_reuse.nom
 169             return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
 170           else:
 171             # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
 172             # On peut donc creer le concept retourne
 173             # Il est cree sans nom mais enregistre dans la liste des concepts existants
 174             try:
 175                self.getSdProd()
 176                # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
 177                self.sd.nom = nom
 178                self.sdnom=nom
 179                self.parent.sdsDict[nom]=self.sd
 180                self.parent.updateConceptAfterEtape(self,self.sd)
 181                self.finModif()
 182                return 1, tr("Nommage du concept effectue")
 183             except:
 184                return 0, tr("Nommage impossible %s", str(sys.exc_info()[1]))
 185       else :
 186           #Un concept produit preexiste
 187           old_nom=self.sd.nom
 188           if old_nom.find('sansnom') :
 189             # Dans le cas ou old_nom == sansnom, isValid retourne 0 alors que ...
 190             # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'etape est valide
 191             # on peut donc le nommer sans test prealable
 192             if self.parent.getSdAutourEtape(nom,self):
 193               return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
 194             else:
 195               # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
 196               self.sd.nom=nom
 197               self.sdnom=nom
 198               self.parent.updateConceptAfterEtape(self,self.sd)
 199               self.finModif()
 200               return 1, tr("Nommage du concept effectue")
 201           if self.isValid() :
 202             # Normalement l appel de isValid a mis a jour le concept produit (son type)
 203             # Il suffit de specifier l attribut nom de sd pour le nommer si le nom n est pas
 204             # deja attribue
 205             if self.parent.getSdAutourEtape(nom,self):
 206               return 0, tr("Nommage du concept refuse : un concept de meme nom existe deja")
 207             else:
 208               # Renommage du concept : Il suffit de changer son attribut nom pour le nommer
 209               self.sd.nom=nom
 210               self.sdnom=nom
 211               self.parent.updateConceptAfterEtape(self,self.sd)
 212               self.finModif()
 213               return 1, tr("Nommage du concept effectue")
 214           else:
 215             # Normalement on ne devrait pas passer ici
 216             return 0, 'Normalement on ne devrait pas passer ici'
 217
 218    def getSdprods(self,nom_sd):
 219       """
 220          Fonction : retourne le concept produit par l etape de nom nom_sd
 221          s il existe sinon None
 222       """
 223       if self.sd:
 224         if self.sd.nom == nom_sd:return self.sd
 225
 226    def active(self):
 227       """
 228           Rend l'etape courante active.
 229           Il faut ajouter la sd si elle existe au contexte global du JDC
 230           et a la liste des sd
 231       """
 232       if self.actif:return
 233       self.actif = 1
 234       self.initModif()
 235       if self.sd :
 236         try:
 237           self.jdc.appendSdProd(self.sd)
 238         except:
 239           pass
 240       CONNECTOR.Emit(self,"add",None)
 241       CONNECTOR.Emit(self,"valid")
 242
 243    def inactive(self):
 244       """
 245           Rend l'etape courante inactive
 246           Il faut supprimer la sd du contexte global du JDC
 247           et de la liste des sd
 248       """
 249       self.actif = 0
 250       self.initModif()
 251       if self.sd :
 252          self.jdc.delSdprod(self.sd)
 253          self.jdc.deleteConceptAfterEtape(self,self.sd)
 254       CONNECTOR.Emit(self,"supp",None)
 255       CONNECTOR.Emit(self,"valid")
 256
 257    def controlSdprods(self,d):
 258       """
 259           Cette methode doit verifier que ses concepts produits ne sont pas
 260           deja definis dans le contexte
 261           Si c'est le cas, les concepts produits doivent etre supprimes
 262       """
 263       print ("controlSdprods etape",d.keys(),self.sd and self.sd.nom,self.nom)
 264       if self.sd:
 265         if self.sd.nom in d :
 266            # Le concept est deja defini
 267            if self.reuse and self.reuse is d[self.sd.nom]:
 268               # Le concept est reutilise : situation normale
 269               pass
 270            else:
 271               # Redefinition du concept, on l'annule
 272               #XXX on pourrait simplement annuler son nom pour conserver les objets
 273               # l'utilisateur n'aurait alors qu'a renommer le concept (faisable??)
 274               self.initModif()
 275               sd=self.sd
 276               self.sd=self.reuse=self.sdnom=None
 277               #supprime les references a sd dans les etapes suivantes
 278               self.parent.deleteConceptAfterEtape(self,sd)
 279               self.finModif()
 280
 281    def supprimeSdprod(self,sd):
 282       """
 283          Supprime le concept produit sd s'il est produit par l'etape
 284       """
 285       if sd is not self.sd:return
 286       if self.sd != None :
 287          self.initModif()
 288          self.parent.delSdprod(sd)
 289          self.sd=None
 290          self.finModif()
 291          self.parent.deleteConcept(sd)
 292
 293    def supprimeSdProds(self):
 294       """
 295             Fonction:
 296             Lors d'une destruction d'etape, detruit tous les concepts produits
 297             Un operateur n a qu un concept produit
 298             Une procedure n'en a aucun
 299             Une macro en a en general plus d'un
 300       """
 301       self.deleteRef()
 302       #print "supprimeSdProds",self
 303       if self.reuse is self.sd :return
 304       # l'etape n'est pas reentrante
 305       # le concept retourne par l'etape est a supprimer car il etait
 306       # cree par l'etape
 307       if self.sd != None :
 308          self.parent.delSdprod(self.sd)
 309          self.parent.deleteConcept(self.sd)
 310
 311    def close(self):
 312       return
 313
 314    def updateConcept(self,sd):
 315       for child in self.mcListe :
 316           child.updateConcept(sd)
 317
 318    def deleteConcept(self,sd):
 319       """
 320           Inputs :
 321              - sd=concept detruit
 322           Fonction :
 323           Mettre a jour les mots cles de l etape et eventuellement
 324           le concept produit si reuse
 325           suite a la disparition du concept sd
 326           Seuls les mots cles simples MCSIMP font un traitement autre
 327           que de transmettre aux fils
 328       """
 329       if self.reuse and self.reuse == sd:
 330         self.sd=self.reuse=None
 331         self.initModif()
 332       for child in self.mcListe :
 333         child.deleteConcept(sd)
 334
 335    def replaceConcept(self,old_sd,sd):
 336       """
 337           Inputs :
 338              - old_sd=concept remplace
 339              - sd = nouveau concept
 340           Fonction :
 341           Mettre a jour les mots cles de l etape et eventuellement
 342           le concept produit si reuse
 343           suite au remplacement  du concept old_sd
 344       """
 345       if self.reuse and self.reuse == old_sd:
 346         self.sd=self.reuse=sd
 347         self.initModif()
 348       for child in self.mcListe :
 349         child.replaceConcept(old_sd,sd)
 350
 351    def resetContext(self):
 352       pass
 353
 354    def getNomsSdOperReentrant(self):
 355       """
 356           Retourne la liste des noms de concepts utilisesa l'interieur de la commande
 357           qui sont du type que peut retourner cette commande
 358       """
 359       liste_sd = self.getSd_utilisees()
 360       l_noms = []
 361       if type(self.definition.sd_prod) == types.FunctionType:
 362         d=self.creeDictValeurs(self.mcListe)
 363         try:
 364           classe_sd_prod = self.definition.sd_prod(*(), **d)
 365         except:
 366           return []
 367       else:
 368         classe_sd_prod = self.definition.sd_prod
 369       for sd in liste_sd :
 370         if sd.__class__ is classe_sd_prod : l_noms.append(sd.nom)
 371       l_noms.sort()
 372       return l_noms
 373
 374    def getGenealogiePrecise(self):
 375       return [self.nom]
 376
 377    def getNomDsXML(self):
 378      # en xml on a un choice
 379      index=0
 380      for e in self.parent.etapes :
 381          if e == self : break
 382          if e.nom == self.nom : index+=1
 383      nomDsXML = self.nom + "[" + str(index) + "]"
 384      return nomDsXML
 385
 386
 387    def getGenealogie(self):
 388       """
 389           Retourne la liste des noms des ascendants de l'objet self
 390           en s'arretant a la premiere ETAPE rencontree
 391       """
 392       return [self.nom]
 393
 394    def verifExistenceSd(self):
 395      """
 396         Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
 397         avant etape, sinon enleve la referea ces concepts
 398      """
 399      #print "verifExistenceSd",self.sd
 400      for motcle in self.mcListe :
 401          motcle.verifExistenceSd()
 402
 403    def updateMcGlobal(self):
 404      """
 405         Met a jour les mots cles globaux enregistres dans l'etape
 406         et dans le jdc parent.
 407         Une etape ne peut pas etre globale. Elle se contente de passer
 408         la requete a ses fils apres avoir reinitialise le dictionnaire
 409         des mots cles globaux.
 410      """
 411      self.mc_globaux={}
 412      I_MCCOMPO.MCCOMPO.updateMcGlobal(self)
 413
 414    def updateConditionBloc(self):
 415      """
 416         Realise l'update des blocs conditionnels fils de self
 417      """
 418      self._updateConditionBloc()
 419
 420    def getObjetCommentarise(self,format):
 421       """
 422           Cette methode retourne un objet commande commentarisee
 423           representant la commande self
 424       """
 425       import generator
 426       g=generator.plugins[format]()
 427       texte_commande = g.gener(self,format='beautifie')
 428       # Il faut enlever la premiere ligne vide de texte_commande que
 429       # rajoute le generator
 430       # on construit l'objet COMMANDE_COMM repesentatif de self mais non
 431       # enregistre dans le jdc (pas ajoute dans jdc.etapes)
 432       parent=self.parent
 433       pos=self.parent.etapes.index(self)
 434       # on ajoute une fin à la commande pour pouvoir en commenter 2
 435       texte_commande+='\nFin Commentaire'
 436       commande_comment = commande_comm.COMMANDE_COMM(texte=texte_commande,
 437                                                      reg='non',
 438                                                      parent=parent)
 439       self.parent.suppEntite(self)
 440       parent.addEntite(commande_comment,pos)
 441
 442       return commande_comment
 443
 444    def modified(self):
 445       """Le contenu de l'etape (mots cles, ...) a ete modifie"""
 446       if self.nom=="DETRUIRE":
 447         self.parent.controlContextApres(self)
 448
 449
 450
 451 #ATTENTION SURCHARGE: a garder en synchro ou a reintegrer dans le Noyau
 452    def buildSd(self,nom):
 453       """
 454            Methode de Noyau surchargee pour poursuivre malgre tout
 455            si une erreur se produit pendant la creation du concept produit
 456       """
 457       try:
 458          sd=Noyau.N_ETAPE.ETAPE.buildSd(self,nom)
 459       except AsException as e :
 460          # Une erreur s'est produite lors de la construction du concept
 461          # Comme on est dans EFICAS, on essaie de poursuivre quand meme
 462          # Si on poursuit, on a le choix entre deux possibilites :
 463          # 1. on annule la sd associee a self
 464          # 2. on la conserve mais il faut la retourner
 465          # En plus il faut rendre coherents sdnom et sd.nom
 466          self.sd=None
 467          self.sdnom=None
 468          self.state="unchanged"
 469          self.valid=0
 470
 471       return self.sd
 472
 473 #ATTENTION SURCHARGE: cette methode doit etre gardee en synchronisation avec Noyau
 474    def makeRegister(self):
 475       """
 476          Initialise les attributs jdc, id, niveau et realise les
 477          enregistrements necessaires
 478          Pour EFICAS, on tient compte des niveaux
 479          Surcharge la methode makeRegister du package Noyau
 480       """
 481       if self.parent :
 482          self.jdc = self.parent.getJdcRoot()
 483          self.id=   self.parent.register(self)
 484          self.UserError=self.jdc.UserError
 485          if self.definition.niveau :
 486             # La definition est dans un niveau. En plus on
 487             # l'enregistre dans le niveau
 488             self.nom_niveau_definition = self.definition.niveau.nom
 489             self.niveau = self.parent.dict_niveaux[self.nom_niveau_definition]
 490             self.niveau.register(self)
 491          else:
 492             # La definition est au niveau global
 493             self.nom_niveau_definition = 'JDC'
 494             self.niveau=self.parent
 495       else:
 496          self.jdc = self.parent =None
 497          self.id=None
 498          self.niveau=None
 499          self.UserError="UserError"
 500
 501    def report(self):
 502      cr= Validation.V_ETAPE.ETAPE.report(self)
 503      #rafraichisst de la validite de l'etape (probleme avec l'ordre dans les macros : etape puis mots cles)
 504      self.isValid()
 505      if not self.isValid() and self.nom == "INCLUDE" :
 506         self.cr.fatal('Etape : {} ligne : {}  {}'.format(self.nom, self.appel[0],  tr("\n   Include Invalide. \n  ne sera pas pris en compte")))
 507      return cr
 508