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