Editeur/definition_cata.py

   1 #@ MODIF definition_cata Accas  DATE 02/07/2001   AUTEUR D6BHHJP J.P.LEFEBVRE
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2001  EDF R&D                  WWW.CODE-ASTER.ORG
   5 #              SEE THE FILE "LICENSE.TERMS" FOR INFORMATION ON USAGE AND
   6 #              REDISTRIBUTION OF THIS FILE.
   7 # ======================================================================
   8 # Modules Python
   9 import types
  10
  11 # Modules Eficas
  12 import Accas
  13 from Noyau.N_CR import CR
  14
  15 class CATALOGUE:
  16     def __init__(self,modules_cata):
  17         self.modules_cata = modules_cata # tuple de modules...
  18         self.cr = CR()
  19         self.state='undetermined'
  20         self.entites_attributs = {}
  21         self.entites_fils = []
  22         self.build_entites_attributs()
  23         self.build_entites_fils()
  24
  25     def build_entites_attributs(self):
  26         pass
  27
  28     def build_entites_fils(self):
  29         niv_types = Accas.NIVEAU(nom="types",label="Liste des types")
  30         niv_commandes = Accas.NIVEAU(nom="commandes",label="Liste des commandes")
  31         self.entites_fils.append(make_commande_cata(niv_types,self))
  32         self.entites_fils.append(make_commande_cata(niv_commandes,self))
  33         for module_cata in self.modules_cata:
  34             for e in dir(module_cata):
  35                 obj = getattr(module_cata,e)
  36                 if isCMD(obj):
  37                     self.entites_fils[1].register(make_commande_cata(obj,self.entites_fils[1]))
  38                 elif type(obj) == types.ClassType:
  39                     if issubclass(obj,Accas.ASSD):
  40                         self.entites_fils[0].register(TYPE_CATA(obj))
  41
  42     def init_modif(self):
  43         self.state = 'modified'
  44
  45     def report(self):
  46       """ Classe CATALOGUE
  47           Methode pour generation d un rapport de validite
  48       """
  49       self.cr.purge()
  50       self.cr.debut="DEBUT CR validation : "
  51       self.cr.fin="FIN CR validation :"
  52       self.state = 'modified'
  53       self.isvalid(cr='oui')
  54       for fils in self.entites_fils[1].entites :
  55         self.cr.add(fils.report())
  56       return self.cr
  57
  58     def isvalid(self,cr='non'):
  59         if self.state != 'unchanged':
  60             valid=1
  61             for fils in self.entites_fils[1].entites_fils:
  62                 if not fils.isvalid():
  63                     valid=0
  64                     break
  65             self.valid = valid
  66             self.state='unchanged'
  67         return self.valid
  68
  69 def make_commande_cata(objet,pere):
  70     if isinstance(objet,Accas.OPER):
  71         return OPER_CATA(objet,pere,objet.nom)
  72     elif isinstance(objet,Accas.PROC):
  73         return PROC_CATA(objet,pere,objet.nom)
  74     elif isinstance(objet,Accas.MACRO):
  75         return MACRO_CATA(objet,pere,objet.nom)
  76     elif isinstance(objet,Accas.FORM):
  77         return MACRO_CATA(objet,pere,objet.nom)
  78     elif isinstance(objet,Accas.NIVEAU):
  79         return NIVEAU_CATA(objet,pere,objet.nom)
  80     else:
  81         print "Erreur dans make_commande_cata : on cherche à évaluer un objet non référencé ",objet
  82
  83 def make_mc_cata(objet,pere,nom=''):
  84     if isinstance(objet,Accas.BLOC):
  85         return BLOC_CATA(objet,pere,nom)
  86     elif isinstance(objet,Accas.FACT):
  87         return FACT_CATA(objet,pere,nom)
  88     elif isinstance(objet,Accas.SIMP):
  89         return SIMP_CATA(objet,pere,nom)
  90     else:
  91         print "Erreur dans make_mc_cata : on cherche à évaluer un objet non référencé ",objet
  92
  93 class TYPE_CATA:
  94     def __init__(self,objet):
  95         self.objet = objet
  96         self.nom = objet.__name__
  97
  98     def isvalid(self,cr='non'):
  99         return 1
 100
 101     def get_valeur_attribut(self,nom_attr):
 102         if nom_attr == 'nom':return self.nom
 103         return None
 104
 105 class OBJET_CATA:
 106     attributs=[]
 107     attributs_defauts={}
 108     def __init__(self,objet,pere,nom):
 109         self.objet = objet
 110         self.nom = nom
 111         self.pere = pere
 112         self.cr = CR()
 113         self.state='undetermined'
 114         self.entites_fils = []
 115         self.entites_attributs = {}
 116         self.build_entites_attributs()
 117         self.build_entites_fils()
 118
 119     def __str__(self):
 120         s=''
 121         s=self.__class__.__name__+' : '+self.nom
 122         return s
 123
 124     def build_entites_attributs(self):
 125         for attribut in self.attributs:
 126             if hasattr(self.objet,attribut):
 127                 self.entites_attributs[attribut]=ATTR_CATA(attribut,getattr(self.objet,attribut))
 128             else:
 129                 if self.attributs_defauts.has_key(attribut):
 130                     self.entites_attributs[attribut]=ATTR_CATA(attribut,self.attributs_defauts[attribut])
 131                 else:
 132                     self.entites_attributs[attribut]=ATTR_CATA(attribut,None)
 133
 134     def build_entites_fils(self):
 135         for k,v in self.objet.entites.items():
 136             self.entites_fils.append(make_mc_cata(v,self,nom=k))
 137
 138     def get_valeur_attribut(self,nom_attr):
 139         if nom_attr in self.entites_attributs.keys():
 140             return self.entites_attributs[nom_attr].valeur
 141         elif nom_attr in self.attributs_defauts.keys():
 142             return self.attributs_defauts[nom_attr]
 143         elif nom_attr == 'domaine_validité':
 144             if self.entites_attributs['into'].valeur != None :
 145                 return 'discret'
 146             else:
 147                 return 'continu'
 148
 149     def isvalid(self,cr='non'):
 150         if self.state =='unchanged':
 151             return self.valid
 152         else:
 153             valid = 1
 154             if hasattr(self,'valid'):
 155                 old_valid = self.valid
 156             else:
 157                 old_valid = None
 158             # on teste self lui-meme
 159             if self.nom == '' or self.nom == None : valid=0
 160             # on teste les attributs
 161             for attribut in self.entites_attributs.values():
 162                 if not attribut.isvalid() : valid =0
 163                 break
 164             # on teste les fils
 165             for fils in self.entites_fils:
 166                 if not fils.isvalid(): valid = 0
 167                 break
 168         self.valid = valid
 169         self.state = 'unchanged'
 170         if old_valid:
 171             if old_valid != self.valid : self.init_modif_up()
 172         return self.valid
 173
 174     def init_modif_up(self):
 175         self.pere.state='modified'
 176
 177     def report(self):
 178         self.cr.purge()
 179         self.cr.debut="Debut "+self.__class__.__name__+' : '+self.nom
 180         self.cr.fin = "Fin "+self.__class__.__name__+' : '+self.nom
 181         self.isvalid(cr='oui')
 182         for attribut in self.entites_attributs.values():
 183             self.cr.add(attribut.report())
 184         for fils in self.entites_fils :
 185             self.cr.add(fils.report())
 186         return self.cr
 187
 188     def set_valeur_attribut(self,nom_attr,valeur):
 189         """
 190         Affecte la valeur 'valeur' à l'attribut de nom 'nom-attr'
 191         """
 192         # il faudra être prudent sur les changements de nom : interdire de changer
 193         # le nom d'un mot-clé qui serait utilisé dans une règle ???
 194         self.entites_attributs[nom_attr].valeur = valeur
 195
 196     def addentite(self,name,pos):
 197         """
 198         Permet d'ajouter un nouveau fils a self
 199         """
 200         self.init_modif()
 201         if name == 'new_simp':
 202             objet = Accas.SIMP(typ=('bidon',))
 203         objet_cata = make_mc_cata(objet,self)
 204         self.entites_fils.insert(pos,objet_cata)
 205         return objet_cata
 206
 207     def init_modif(self):
 208         self.state = 'modified'
 209         if hasattr(self,'pere'):
 210             self.pere.init_modif()
 211
 212     def verif_nom(self,cr='non'):
 213         """
 214         Méthode appelée par EFICAS et ACCAS
 215         Booléenne : retourne 1 si l'attribut nom est valide, 0 sinon
 216         """
 217         if self.entites_attributs['nom'].valeur == '':
 218             if cr == 'oui' : self.cr.fatal("L'objet de type %s n'est pas nommé" %self.__class__.__name__)
 219             return 0
 220         return 1
 221
 222     def verif_defaut(self,cr='non'):
 223         """
 224         Méthode de vérification de validité du défaut
 225         """
 226         defaut = self.get_valeur_attribut('defaut')
 227         if self.get_valeur_attribut('domaine_validite') == 'discret' :
 228             if defaut not in self.get_valeur_attribut('into'):
 229                 if cr == 'oui' : self.cr.fatal("La valeur %s n'est pas autorisée" %str(defaut))
 230                 return 0
 231             return 1
 232         else:
 233             if defaut == None : return 1
 234             typ = self.get_valeur_attribut('type')
 235             # on attend un TXM ?
 236             if 'TXM' in typ :
 237                 if type(defaut) == types.StringType : return 1
 238             val_min = self.get_valeur_attribut('val_min')
 239             val_max = self.get_valeur_attribut('val_max')
 240             # on attend un reel ?
 241             if 'R' in typ :
 242                 if type(defaut) == types.StringType:
 243                     try :
 244                         nb = string.atof(defaut)
 245                     except:
 246                         nb=None
 247                 else:
 248                     nb = defaut
 249                 if nb != None :
 250                     test = 1
 251                     if val_min != '**' : test = (nb >= val_min)
 252                     if val_max != '**' : test = test*(nb <= val_max)
 253                     if test : return 1
 254             # on attend un entier ?
 255             if 'I' in typ :
 256                 if type(defaut)==types.StringType:
 257                     try:
 258                         nb = string.atoi(defaut)
 259                     except:
 260                         pass
 261                 else:
 262                     nb = defaut
 263                 if nb != None :
 264                     test = 1
 265                     if val_min != '**' : test = (nb >= val_min)
 266                     if val_max != '**' : test = test*(nb <= val_max)
 267                     if test : return 1
 268             # si on passe par là, c'est que l'on n'a pas su évaluer defaut
 269             if cr == 'oui' : self.cr.fatal("La valeur %s n'est pas une valeur permise" %str(defaut))
 270             return 0
 271
 272     def verif_val_min(self,cr='non'):
 273         """
 274         Méthode de vérification de val_min.
 275         Booléenne : retourne 1 si val_min est valide, 0 sinon
 276         """
 277         val_min = self.get_valeur_attribut('val_min')
 278         if not val_min :
 279             if cr == 'oui' : self.cr.fatal('val_min ne peut valoir None')
 280             return 0
 281         if val_min == '**': return 1
 282         # val_min doit à ce stade être :
 283         # - soit un entier ou un réel
 284         # - soit une chaîne de caractères représentant un entier ou un réel (provient d'EFICAS)
 285         if type(val_min) == types.StringType :
 286             try :
 287                 val_min = string.atoi(val_min)
 288             except:
 289                 try:
 290                     val_min = string.atof(val_min)
 291                 except:
 292                     if cr == 'oui' : self.cr.fatal("%s n'est ni un entier ni un réel" %str(val_min))
 293                     return 0
 294         # A ce stade, val_min doit être un entier ou un réel : on vérifie ...
 295         if type(val_min) not in (types.IntType,types.FloatType) :
 296             if cr == 'oui' : self.cr.fatal("%s n'est pas d'un type autorisé" %str(val_min))
 297             return 0
 298         # A ce stade valeur est un entier ou un réel : on peut comparer à val_max
 299         val_max = self.get_valeur_attribut('val_max')
 300         if val_max == '**' or val_min < val_max : return 1
 301         # erreur : val_min est supérieur à val_max !!!
 302         if cr == 'oui' : self.cr.fatal("%s n'est pas inférieur à %s" %(str(val_min),str(val_max)))
 303         return 0
 304
 305     def verif_val_max(self,cr='non'):
 306         """
 307         Méthode de vérification de val_max.
 308         Booléenne : retourne 1 si val_max est valide, 0 sinon
 309         """
 310         val_max = self.get_valeur_attribut('val_max')
 311         if not val_max :
 312             if cr == 'oui' : self.cr.fatal('val_max ne peut valoir None')
 313             return 0
 314         if val_max == '**': return 1
 315         # val_max doit à ce stade être :
 316         # - soit un entier ou un réel
 317         # - soit une chaîne de caractères représentant un entier ou un réel (provient d'EFICAS)
 318         if type(val_max) == types.StringType :
 319             try :
 320                 val_max = string.atoi(val_max)
 321             except:
 322                 try:
 323                     val_max = string.atof(val_max)
 324                 except:
 325                     if cr == 'oui' : self.cr.fatal("%s n'est ni un entier ni un réel" %str(val_max))
 326                     return 0
 327         # A ce stade, val_max doit être un entier ou un réel : on vérifie ...
 328         if type(val_max) not in (types.IntType,types.FloatType) :
 329             if cr == 'oui' : self.cr.fatal("%s n'est pas d'un type autorisé" %str(val_max))
 330             return 0
 331         # A ce stade valeur est un entier ou un réel : on peut comparer à val_max
 332         val_min = self.get_valeur_attribut('val_min')
 333         if val_min == '**' or val_min < val_max : return 1
 334         # erreur : val_min est supérieur à val_max !!!
 335         if cr == 'oui' : self.cr.fatal("%s n'est pas supérieur à %s" %(str(val_max),str(val_min)))
 336         return 0
 337
 338 class OPER_CATA(OBJET_CATA):
 339     attributs = ['ang','docu','fr','niveau','nom','op','op_init','reentrant','regles','repetable','sd_prod']
 340
 341 class PROC_CATA(OBJET_CATA):
 342     attributs = ['ang','docu','fr','niveau','nom','op','op_init','regles','repetable']
 343
 344 class MACRO_CATA(OBJET_CATA):
 345     attributs = ['ang','docu','fr','niveau','nom','op','op_init','reentrant','regles','repetable','sd_prod']
 346
 347 class BLOC_CATA(OBJET_CATA):
 348     attributs = ['ang','condition','docu','fr','nom','regles']
 349
 350 class FACT_CATA(OBJET_CATA):
 351     attributs=['ang','defaut','docu','fr','max','min','nom','regles','statut']
 352
 353 class SIMP_CATA(OBJET_CATA):
 354     attributs=['ang','defaut','docu','fr','homo','into','max','min','nom','position','statut','type','val_min','val_max']
 355     attributs_defauts={'ang':'','defaut':None,'fr':'','homo':1,'into':None,'max':1,'min':1,'nom' : '','position':'local',
 356                        'regles':None,'statut':'f','type':None,'val_min':'**','val_max':'**','docu':''}
 357
 358     def build_entites_fils(self):
 359         pass
 360
 361     def isvalid(self,cr='non'):
 362         """
 363         Mde appelpar l'externe (EFICAS et ACCAS).
 364         Boolne : retourne 1 si l'objet est valide, 0 sinon
 365         """
 366         if self.state == 'unchanged':
 367             return self.valid
 368         else:
 369             valid = 1
 370             valid = valid*self.verif_nom(cr=cr)
 371             valid = valid*self.verif_defaut(cr=cr)
 372             valid = valid*self.verif_val_min(cr=cr)*self.verif_val_max(cr=cr)
 373             if hasattr(self,'valid'):
 374                 old_valid = self.valid
 375             else:
 376                 old_valid = None
 377             self.valid = valid
 378             self.state='unchanged'
 379             if old_valid :
 380                 if old_valid != self.valid : self.init_modif_up()
 381             return self.valid
 382
 383 class NIVEAU_CATA(OBJET_CATA):
 384   def __init__(self,objet,pere,nom):
 385     self.pere = pere
 386     self.nom = nom
 387     self.state = 'undetermined'
 388     self.cr = CR()
 389     self.objet = objet
 390     self.entites_fils=[]
 391     self.entites_attributs = {}
 392
 393   def register(self,fils):
 394     """
 395         Enregistre la commande 굡pe :
 396          - si editmode = 0 : on est en mode relecture d'un fichier de commandes
 397          auquel cas on ajoute etape ࡬a fin de la liste self.etapes
 398          - si editmode = 1 : on est en mode ajout d'굡pe depuis eficas auquel cas
 399          cette mode ne fait rien, c'est addentité enregistre etape à¡¬a bonne place
 400          dans self.etapes
 401     """
 402     self.entites_fils.append(fils)
 403
 404   def unregister(self,etape):
 405     self.entites_fils.remove(etape)
 406
 407   def isvalid(self,cr='non'):
 408     """ Mode boolne qui retourne 0 si le niveau est invalide, 1 sinon """
 409     if self.state == 'unchanged':
 410         return self.valid
 411     else:
 412         valid = 1
 413         if len(self.entites_fils) == 0:
 414             #valid = self.Accas.valide_vide
 415             valid = 1
 416         else:
 417             for commande in self.entites_fils :
 418                 if hasattr(commande,'isvalid'):
 419                     if not commande.isvalid() :
 420                         valid = 0
 421                         break
 422                 else:
 423                     print str(commande)," n'a pas de methode isvalid"
 424         if hasattr(self,'valid'):
 425             old_valid = self.valid
 426         else:
 427             old_valid = None
 428         self.valid = valid
 429         self.state='unchanged'
 430         if old_valid:
 431             if old_valid != self.valid : self.init_modif_up()
 432         return self.valid
 433
 434
 435 class ATTR_CATA(OBJET_CATA):
 436     def __init__(self,nom,valeur=None):
 437         self.nom = nom
 438         self.valeur = valeur
 439         self.cr = CR()
 440         self.state='undetermined'
 441         self.entites_attributs={}
 442         self.entites_fils=()
 443
 444     def isvalid(self,cr='non'):
 445         return 1
 446
 447 def isCMD(cmd):
 448    return isinstance(cmd,Accas.OPER) or isinstance(cmd,Accas.PROC) or isinstance(cmd,Accas.MACRO) or isinstance(cmd,Accas.FORM)
 449