Ihm/I_MCCOMPO.py

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