Editeur/definition_cata.py

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