Extensions/commande_comm.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2013   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 from __future__ import absolute_import
  21 from __future__ import print_function
  22 try :
  23   from builtins import str
  24 except : pass
  25 import os,traceback
  26 import re
  27
  28 from Noyau.N_CR import CR
  29 from Noyau.N_Exception import AsException
  30 from Noyau import N_OBJECT
  31 from Ihm import I_OBJECT
  32 from Extensions.i18n import tr
  33
  34 class COMMANDE_COMM(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
  35     """
  36     Cette classe sert a definir les objets de type Commande commentarisee
  37     """
  38     nature = "COMMANDE_COMMENTARISEE"
  39     idracine='_comm'
  40
  41     def __init__(self,texte='',parent=None,reg='oui'):
  42         self.valeur = texte
  43         if not parent :
  44             self.jdc = self.parent = CONTEXT.get_current_step()
  45         else:
  46             self.jdc = self.parent = parent
  47         if hasattr(self.parent,'etape'):
  48           self.etape = self.parent.etape
  49         else :
  50           self.etape = None
  51         self.definition=self
  52         self.nom = ''
  53         self.niveau = self.parent.niveau
  54         self.actif=1
  55         self.state="unchanged"
  56         #self.appel = N_utils.callee_where(niveau=2)
  57         if reg=='oui' : self.register()
  58
  59     def isvalid(self):
  60         return 1
  61
  62     def report(self):
  63         """
  64         Genere l'objet rapport (classe CR)
  65         """
  66         self.cr=CR()
  67         if not self.isvalid(): self.cr.warn(tr("Objet commande commentarise invalide"))
  68         return self.cr
  69
  70     def copy(self):
  71         """
  72         Retourne une copie de self cad un objet COMMANDE_COMM
  73         """
  74         # XXX self.texte ne semble pas exister ???
  75         return COMMANDE_COMM(self.texte,parent = self.parent,reg='non')
  76
  77     def init_modif(self):
  78         self.state = 'modified'
  79         self.parent.init_modif()
  80
  81     def set_valeur(self,new_valeur):
  82         """
  83         Remplace la valeur de self(si elle existe) par new_valeur)
  84         """
  85         self.valeur = new_valeur
  86         self.init_modif()
  87
  88     def get_valeur(self) :
  89         """
  90         Retourne la valeur de self, cad le texte de la commande commentarisee
  91         """
  92         return self.valeur
  93
  94     def register(self):
  95         """
  96         Enregistre la commande commenatrisee dans la liste des etapes de son parent lorsque celui-ci
  97         est un JDC
  98         """
  99         self.parent.register(self)
 100
 101     def isoblig(self):
 102         """
 103         Indique si self est obligatoire ou non : retourne toujours 0
 104         """
 105         return 0
 106
 107     def ident(self):
 108         """
 109         Retourne le nom interne associe a self
 110         Ce nom n'est jamais vu par l'utilisateur dans EFICAS
 111         """
 112         return self.nom
 113
 114     def isrepetable(self):
 115         """
 116         Indique si self est repetable ou non : retourne toujours 1
 117         """
 118         return 1
 119
 120     def get_attribut(self,nom_attribut) :
 121         """
 122         Retourne l'attribut de nom nom_attribut de self (ou herite)
 123         """
 124         if hasattr(self,nom_attribut) :
 125           return getattr(self,nom_attribut)
 126         else :
 127           return None
 128
 129     def get_fr(self):
 130         """
 131         Retourne l'attribut fr de self.definition
 132         """
 133         if self.jdc.code=='ASTER' : return self.definition.fr
 134         try :
 135           return getattr(self.definition,self.jdc.lang)
 136         except:
 137           return ''
 138
 139     def liste_mc_presents(self):
 140         return []
 141
 142     def supprime(self):
 143         """
 144         Methode qui supprime toutes les boucles de references afin que l'objet puisse
 145         etre correctement detruit par le garbage collector
 146         """
 147         self.parent = None
 148         self.etape = None
 149         self.jdc = None
 150         self.niveau = None
 151         self.definition = None
 152         self.valeur = None
 153         self.val = None
 154         self.appel = None
 155
 156     def supprime_sdprods(self):
 157         pass
 158
 159     def update_context(self,d):
 160         """
 161         Update le dictionnaire d avec les concepts ou objets produits par self
 162         --> ne fait rien pour une commande en  commentaire
 163         """
 164         pass
 165
 166     def delete_concept(self,sd):
 167         pass
 168
 169     def replace_concept (self,old_sd,sd):
 170         pass
 171
 172     def get_sdprods(self,nom_sd):
 173         return None
 174
 175     def uncomment(self):
 176         """
 177         Cette methode a pour but de decommentariser l'objet courant,
 178         cad de retourner un tuple contenant :
 179           - l'objet CMD associe
 180           - le nom de la sdprod eventuellement produite (sinon None)
 181         """
 182         # on recupere le contexte avant la commande commentarisee
 183         context_ini = self.jdc.get_contexte_avant(self)
 184         try:
 185             # on essaie de creer un objet JDC...
 186             CONTEXT.unset_current_step()
 187             if re.search('Fin Commentaire',self.valeur) :
 188                self.valeur=self.valeur.replace('Fin Commentaire','')
 189             J=self.jdc.__class__(procedure=self.valeur,
 190                                  definition=self.jdc.definition,
 191                                  cata=self.jdc.cata,
 192                                  cata_ord_dico=self.jdc.cata_ordonne_dico,
 193                                  context_ini = context_ini,
 194                                 )
 195             J.analyse()
 196         except Exception as e:
 197             traceback.print_exc()
 198             #self.jdc.set_context()
 199             raise AsException(tr("Erreur"),e.__str__())
 200         if len(J.cr.crfatal)>0 :
 201             # des erreurs fatales ont ete rencontrees
 202             #self.jdc.set_context()
 203             print ('erreurs fatales !!!')
 204             raise AsException(tr("Erreurs fatales"),''.join(J.cr.crfatal))
 205         if not J.etapes :
 206             # des erreurs ont ete rencontrees
 207             raise AsException(tr("Impossible reconstruire commande\n"),str(J.cr))
 208         #self.jdc.set_context()
 209
 210         new_etape = J.etapes[0]
 211         if new_etape.sd :
 212             nom_sd = new_etape.sd.nom
 213         else:
 214             nom_sd = None
 215         #new_etape=new_etape.copy()
 216         #print "uncomment",new_etape.sd
 217
 218         pos=self.parent.etapes.index(self)
 219         # L'ordre d'appel est important : suppentite fait le menage des concepts dans les etapes suivantes
 220         self.parent.addentite(new_etape,pos)
 221         self.parent.suppentite(self)
 222         return new_etape,nom_sd
 223
 224     def active(self):
 225         """
 226         Rend l'etape courante active
 227         """
 228         self.actif = 1
 229
 230     def inactive(self):
 231         """
 232         Rend l'etape courante inactive
 233         """
 234         self.actif = 0
 235
 236     def isactif(self):
 237         """
 238         Booleenne qui retourne 1 si self est valide, 0 sinon
 239         """
 240         return self.actif
 241
 242     def verif_condition_bloc(self):
 243       """
 244           Evalue les conditions de tous les blocs fils possibles
 245           (en fonction du catalogue donc de la definition) de self et
 246           retourne deux listes :
 247             - la premiere contient les noms des blocs a rajouter
 248             - la seconde contient les noms des blocs a supprimer
 249       """
 250       return [],[]
 251
 252     def verif_condition_regles(self,liste_presents):
 253       """
 254           Retourne la liste des mots-cles a rajouter pour satisfaire les regles
 255           en fonction de la liste des mots-cles presents
 256       """
 257       return []
 258
 259     def reparent(self,parent):
 260       """
 261           Cette methode sert a reinitialiser la parente de l'objet
 262       """
 263       self.parent=parent
 264       self.jdc=parent.get_jdc_root()
 265       self.etape=self
 266
 267     def verif_existence_sd(self):
 268       """
 269          Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
 270          avant etape, sinon enleve la reference a ces concepts
 271          --> sans objet pour les commandes commentarisees
 272       """
 273       pass
 274
 275     def control_sdprods(self,d):
 276       """sans objet pour les commandes commentarisees"""
 277       pass
 278
 279     def close(self):
 280       pass
 281
 282     def reset_context(self):
 283       pass
 284