Ihm/I_MCCOMPO.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 """
  22 """
  23 import string,types
  24 from copy import copy
  25
  26 from Noyau.N_MCLIST import MCList
  27 from Noyau.N_MCSIMP import MCSIMP
  28 from Noyau.N_MCFACT import MCFACT
  29 from Noyau.N_MCBLOC import MCBLOC
  30 import I_OBJECT
  31
  32 class MCCOMPO(I_OBJECT.OBJECT):
  33   def getlabeltext(self):
  34     """
  35        Retourne le label de self suivant qu'il s'agit d'un MCFACT,
  36        d'un MCBLOC ou d'un MCFACT appartenant à une MCList :
  37        utilisée pour l'affichage dans l'arbre
  38     """
  39     objet = self.parent.get_child(self.nom)
  40     # objet peut-être self ou une MCList qui contient self ...
  41     if isinstance(objet,MCList) :
  42       index = objet.get_index(self)+1 # + 1 à cause de la numérotation qui commence à 0
  43       label = self.nom +'_'+`index`+':'
  44       return label
  45     else:
  46       return self.nom
  47
  48   def get_liste_mc_ordonnee(self,liste,dico):
  49     """
  50        Retourne la liste ordonnée (suivant le catalogue) des mots-clés
  51        d'une entité composée dont le chemin complet est donné sous forme
  52        d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
  53        il faut encore réarranger cette liste (certains mots-clés déjà
  54        présents ne doivent plus être proposés, règles ...)
  55     """
  56     return self.filtre_liste_mc(self.get_liste_mc_ordonnee_brute(liste,dico))
  57
  58   def get_liste_mc_ordonnee_brute(self,liste,dico):
  59     """
  60        Retourne la liste ordonnée (suivant le catalogue) BRUTE des mots-clés
  61        d'une entité composée dont le chemin complet est donné sous forme
  62        d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
  63     """
  64     for arg in liste:
  65         objet_cata = dico[arg]
  66         dico=objet_cata.entites
  67     return objet_cata.ordre_mc
  68
  69   def filtre_liste_mc(self,liste_brute):
  70     """
  71        Cette méthode est appelée par EFICAS afin de présenter à
  72        l'utilisateur la liste des enfants possibles de self actualisée
  73        en fonction du contexte de self. En clair, sont supprimés de la
  74        liste des possibles (fournie par la définition), les mots-clés
  75        exclus par les règles de self et les mots-clés ne pouvant plus
  76        être répétés
  77     """
  78     liste = copy(liste_brute)
  79     liste_mc_presents = self.liste_mc_presents()
  80     # on enlève les mots-clés non permis par les règles
  81     for regle in self.definition.regles:
  82        # la méthode purge_liste est à développer pour chaque règle qui
  83        # influe sur la liste de choix à proposer à l'utilisateur
  84        # --> EXCLUS,UN_PARMI,PRESENT_ABSENT
  85        liste = regle.purge_liste(liste,liste_mc_presents)
  86     # on enlève les mots-clés dont l'occurrence est déjà atteinte
  87     liste_copy = copy(liste)
  88     for k in liste_copy:
  89       objet = self.get_child(k,restreint = 'oui')
  90       if objet != None :
  91         # l'objet est déjà présent : il faut distinguer plusieurs cas
  92         if isinstance(objet,MCSIMP):
  93           # un mot-clé simple ne peut pas être répété
  94           liste.remove(k)
  95         elif isinstance(objet,MCBLOC):
  96           # un bloc conditionnel ne doit pas apparaître dans la liste de choix
  97           liste.remove(k)
  98         elif isinstance(objet,MCFACT):
  99           # un mot-clé facteur ne peut pas être répété plus de self.max fois
 100           if objet.definition.max == 1:
 101             liste.remove(k)
 102         elif isinstance(objet,MCList):
 103           try :
 104             nb_occur_maxi = objet[0].definition.max
 105             if len(objet) >= nb_occur_maxi:
 106               liste.remove(k)
 107           except:
 108             pass
 109         else :
 110           #XXX CCAR : les MCNUPLET ne sont pas traités
 111           if CONTEXT.debug : print '   ',k,' est un objet de type inconnu :',type(objet)
 112       else :
 113         # l'objet est absent : on enlève de la liste les blocs
 114         if self.definition.entites[k].statut=='c' :
 115           liste.remove(k)
 116         if self.definition.entites[k].label=='BLOC':
 117           liste.remove(k)
 118     # Pour corriger les exces qui pourraient etre commis dans la methode purge_liste
 119     # des regles, on essaie de compenser comme suit :
 120     # on ajoute les mots cles facteurs presents dont l'occurence n'est pas atteinte
 121     for k in liste_mc_presents:
 122       if k in liste:continue
 123       objet = self.get_child(k,restreint = 'oui')
 124       if isinstance(objet,MCFACT):
 125           # un mot-clé facteur ne peut pas être répété plus de self.max fois
 126           if objet.definition.max > 1:
 127              liste.append(k)
 128       elif isinstance(objet,MCList):
 129           nb_occur_maxi = objet[0].definition.max
 130           if len(objet) < nb_occur_maxi:
 131               liste.append(k)
 132     return liste
 133
 134   def liste_mc_presents(self):
 135     """
 136        Retourne la liste des noms des mots-clés fils de self présents construite
 137        à partir de self.mc_liste
 138     """
 139     l=[]
 140     for v in self.mc_liste:
 141       k=v.nom
 142       l.append(k)
 143     return l
 144
 145   def ordonne_liste_mc(self,liste_mc_a_ordonner,liste_noms_mc_ordonnee):
 146     """
 147         Retourne liste_mc_a_ordonner ordonnée suivant l'ordre
 148         donné par liste_noms_mc_ordonnee
 149     """
 150     liste = []
 151     # on transforme liste_a_ordonner en un dictionnaire (plus facile à consulter)
 152     d_mc = {}
 153     for mc in liste_mc_a_ordonner:
 154       d_mc[mc.nom]=mc
 155     # on construit la liste des objets ordonnés
 156     for nom_mc in liste_noms_mc_ordonnee:
 157       if d_mc.has_key(nom_mc):
 158         liste.append(d_mc.get(nom_mc))
 159     # on la retourne
 160     return liste
 161
 162   def suppentite(self,objet) :
 163     """
 164         Supprime le fils 'objet' de self :
 165         Retourne 1 si la suppression a pu être effectuée,
 166         Retourne 0 dans le cas contraire
 167     """
 168     self.init_modif()
 169     if not objet in self.mc_liste:
 170        # Impossible de supprimer objet. Il n'est pas dans mc_liste
 171        self.fin_modif()
 172        return 0
 173
 174     try :
 175       if hasattr(objet.definition,'position'):
 176           if objet.definition.position == 'global' :
 177             self.delete_mc_global(objet)
 178           elif objet.definition.position == 'global_jdc' :
 179             self.delete_mc_global_jdc(objet)
 180       self.mc_liste.remove(objet)
 181       self.fin_modif()
 182       return 1
 183     except:
 184       self.fin_modif()
 185       return 0
 186
 187   def isoblig(self):
 188       return 0
 189
 190   def addentite(self,name,pos=None):
 191       """
 192           Ajoute le mot-cle name à la liste des mots-cles de
 193           l'objet MCCOMPOSE
 194       """
 195       self.init_modif()
 196       if type(name)==types.StringType :
 197         # on est en mode création d'un motcle
 198         if self.ispermis(name) == 0 : return 0
 199         objet=self.definition.entites[name](val=None,nom=name,parent=self)
 200         if hasattr(objet.definition,'position'):
 201           if objet.definition.position == 'global' :
 202             self.append_mc_global(objet)
 203           elif objet.definition.position == 'global_jdc' :
 204             self.append_mc_global_jdc(objet)
 205       else :
 206         # dans ce cas on est en mode copie d'un motcle
 207         objet = name
 208         objet.verif_existence_sd()
 209       # si un objet de même nom est déjà présent dans la liste
 210       # et si l'objet est répétable
 211       # il faut créer une MCList et remplacer l'objet de la liste
 212       # par la MCList
 213       test1 = objet.isrepetable()
 214       old_obj = self.get_child(objet.nom,restreint = 'oui')
 215       test2 = self.ispermis(objet)
 216       #print "test1,test2=",test1,test2
 217       if test1 == 0 and old_obj :
 218         self.jdc.send_message("L'objet %s ne peut pas être répété" %objet.nom)
 219         self.fin_modif()
 220         return 0
 221       if test2 == 0:
 222         self.jdc.send_message("L'objet %s ne peut être un fils de %s" %(objet.nom,self.nom))
 223         self.fin_modif()
 224         return 0
 225       if test1 :
 226         if old_obj :
 227           #if not isinstance(old_obj,MCList):
 228           if not old_obj.isMCList():
 229             # un objet de même nom existe déjà mais ce n'est pas une MCList
 230             # Il faut en créer une
 231             # L'objet existant (old_obj) est certainement un MCFACT
 232             # qui pointe vers un constructeur
 233             # de MCList : definition.liste_instance
 234             #print "un objet de même type existe déjà"
 235             index = self.mc_liste.index(old_obj)
 236             #XXX remplacé par definition.list_instance : new_obj = MCList()
 237             new_obj = old_obj.definition.list_instance()
 238             new_obj.init(objet.nom,self)
 239             new_obj.append(old_obj)
 240             new_obj.append(objet)
 241             # Il ne faut pas oublier de reaffecter le parent d'obj
 242             objet.reparent(self)
 243             self.mc_liste.remove(old_obj)
 244             self.mc_liste.insert(index,new_obj)
 245             self.fin_modif()
 246             return new_obj
 247           else :
 248             # une liste d'objets de même type existe déjà
 249             #print "une liste d'objets de même type existe déjà"
 250             old_obj.append(objet)
 251             # Il ne faut pas oublier de reaffecter le parent d'obj
 252             objet.reparent(self)
 253             self.fin_modif()
 254             return old_obj
 255       if pos == None :
 256         self.mc_liste.append(objet)
 257       else :
 258         self.mc_liste.insert(pos,objet)
 259       # Il ne faut pas oublier de reaffecter le parent d'obj (si copie)
 260       objet.reparent(self)
 261       self.fin_modif()
 262       return objet
 263
 264   def ispermis(self,fils):
 265     """
 266         Retourne 1 si l'objet de nom nom_fils
 267         est bien permis, cad peut bien être un fils de self,
 268         Retourne 0 sinon
 269     """
 270     if type(fils) == types.StringType :
 271       # on veut juste savoir si self peut avoir un fils de nom 'fils'
 272       if self.definition.entites.has_key(fils):
 273         return 1
 274       else :
 275         return 0
 276     elif type(fils) == types.InstanceType:
 277       # fils est un objet (commande,mcf,mclist)
 278       # on est dans le cas d'une tentative de copie de l'objet
 279       # on veut savoir si l'objet peut bien être un fils de self :
 280       # la vérification du nom de suffit pas (plusieurs commandes
 281       # ont le même mot-clé facteur AFFE ... et c'est l'utilisateur
 282       # qui choisit le père d'où un risque d'erreur)
 283       if not self.definition.entites.has_key(fils.nom):
 284         return 0
 285       else:
 286         if fils.parent.nom != self.nom : return 0
 287       return 1
 288
 289   def liste_mc_presents(self):
 290     """
 291          Retourne la liste des noms des mots-clés fils de self présents
 292          construite à partir de self.mc_liste
 293     """
 294     l=[]
 295     for v in self.mc_liste:
 296       k=v.nom
 297       l.append(k)
 298     return l
 299
 300   def delete_concept(self,sd):
 301     """
 302         Inputs :
 303            - sd=concept detruit
 304         Fonction :
 305         Mettre a jour les fils de l objet suite à la disparition du
 306         concept sd
 307         Seuls les mots cles simples MCSIMP font un traitement autre que
 308         de transmettre aux fils
 309     """
 310     for child in self.mc_liste :
 311       child.delete_concept(sd)
 312
 313   def replace_concept(self,old_sd,sd):
 314     """
 315         Inputs :
 316            - old_sd=concept remplace
 317            - sd = nouveau concept
 318         Fonction :
 319         Mettre a jour les fils de l objet suite au remplacement  du
 320         concept old_sd
 321     """
 322     for child in self.mc_liste :
 323       child.replace_concept(old_sd,sd)
 324
 325   def delete_mc_global(self,mc):
 326     """
 327         Supprime le mot-clé mc de la liste des mots-clés globaux de l'étape
 328     """
 329     etape = self.get_etape()
 330     if etape :
 331       nom = mc.nom
 332       del etape.mc_globaux[nom]
 333
 334   def delete_mc_global_jdc(self,mc):
 335     """
 336         Supprime le mot-clé mc de la liste des mots-clés globaux du jdc
 337     """
 338     nom = mc.nom
 339     del self.jdc.mc_globaux[nom]
 340
 341   def get_liste_mc_inconnus(self):
 342      """
 343      Retourne la liste des mots-clés inconnus dans self
 344      """
 345      l_mc = []
 346      if self.reste_val != {}:
 347         for k,v in self.reste_val.items() :
 348             l_mc.append([self,k,v])
 349      for child in self.mc_liste :
 350         if child.isvalid() : continue
 351         l_child = child.get_liste_mc_inconnus()
 352         for mc in l_child:
 353            l = [self]
 354            l.extend(mc)
 355            l_mc.append(l)
 356      return l_mc
 357
 358   def verif_condition_bloc(self):
 359     """
 360         Evalue les conditions de tous les blocs fils possibles
 361         (en fonction du catalogue donc de la définition) de self
 362         et retourne deux listes :
 363           - la première contient les noms des blocs à rajouter
 364           - la seconde contient les noms des blocs à supprimer
 365     """
 366     liste_ajouts = []
 367     liste_retraits = []
 368     dict = self.cree_dict_condition(self.mc_liste)
 369     for k,v in self.definition.entites.items():
 370       if v.label=='BLOC' :
 371         globs= self.jdc and self.jdc.condition_context or {}
 372         if v.verif_presence(dict,globs):
 373           # le bloc doit être présent
 374           if not self.get_child(k,restreint = 'oui'):
 375             # le bloc n'est pas présent et il doit être créé
 376             liste_ajouts.append(k)
 377         else :
 378           # le bloc doit être absent
 379           if self.get_child(k,restreint = 'oui'):
 380             # le bloc est présent : il faut l'enlever
 381             liste_retraits.append(k)
 382     return liste_ajouts,liste_retraits
 383
 384   def verif_existence_sd(self):
 385      """
 386         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 387         avant étape, sinon enlève la référence à ces concepts
 388      """
 389      for motcle in self.mc_liste :
 390          motcle.verif_existence_sd()