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