InterfaceQT4/politiquesValidation.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 # Modules Python
  21 from __future__ import absolute_import
  22 try :
  23    from builtins import range
  24 except : pass
  25
  26 import types
  27 from Accas import PARAMETRE
  28 from Extensions.i18n import tr
  29
  30
  31 #------------------
  32 class Validation(object)  :
  33 #------------------
  34   def __init__(self,node,parent) :
  35          self.node=node
  36          self.parent=parent
  37
  38   def TesteUneValeur(self,valeurentree):
  39          commentaire = None
  40          valeur,validite=self.node.item.eval_valeur(valeurentree)
  41          if not validite :
  42                   commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
  43                   return valeur,validite,commentaire
  44          if self.node.item.wait_TXM() and not( type(valeur) == str) : valeur=str(valeur)
  45
  46          testtype,commentaire = self.node.item.object.verif_type(valeur)
  47          if not testtype :
  48                   return valeur,0,commentaire
  49
  50          valide=self.node.item.valide_item(valeur)
  51          if type(valide) == tuple:
  52                  validite,commentaire=valide
  53          else :
  54                  validite=valide
  55                  commentaire=" "
  56
  57          if not validite and commentaire is None:
  58                   commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
  59          return valeur, validite, commentaire
  60
  61 # ----------------------------------------------------------------------------------------
  62 #   Methodes utilisees pour la manipulation des items en notation scientifique
  63 #   a mettre au point
  64 # ----------------------------------------------------------------------------------------
  65   def SetValeurTexte(self,texteValeur) :
  66          try :
  67                   if "R" in self.node.item.object.definition.type:
  68                      if texteValeur[0] != "'":
  69                         clef=eval(texteValeur)
  70                         if str(clef) != str(texteValeur) :
  71                            self.node.item.object.init_modif()
  72                            clefobj=self.node.item.object.GetNomConcept()
  73                            if not clefobj in self.parent.appliEficas.dict_reels:
  74                               self.parent.appliEficas.dict_reels[clefobj] = {}
  75                            self.parent.appliEficas.dict_reels[clefobj][clef]=texteValeur
  76                            self.parent.appliEficas.dict_reels[clefobj]
  77                            if clefobj=="" :
  78                               if not self.node.item.object.etape in self.parent.appliEficas.dict_reels :
  79                                  self.parent.appliEficas.dict_reels[self.node.item.object.etape] = {}
  80                               self.parent.appliEficas.dict_reels[self.node.item.object.etape][clef]=texteValeur
  81                            self.node.item.object.fin_modif()
  82          except:
  83             pass
  84
  85   def GetValeurTexte(self,valeur) :
  86          valeurTexte=valeur
  87          if valeur == None : return valeur
  88          from decimal import Decimal
  89          if  isinstance(valeur,Decimal) :
  90              if self.node.wait_TXM() and not self.is_param(valeur) : return "'"+str(valeur)+"'"
  91              else : return(valeur)
  92          if "R" in self.node.item.object.definition.type:
  93                   clefobj=self.node.item.object.GetNomConcept()
  94                   if clefobj in self.parent.appliEficas.dict_reels:
  95                      if valeur in self.parent.appliEficas.dict_reels[clefobj] :
  96                         valeurTexte=self.parent.appliEficas.dict_reels[clefobj][valeur]
  97                   else :
  98                      if str(valeur).find('.') == -1 and str(valeur).find('e') == -1 and str(valeur).find('E'):
  99                      # aucun '.' n'a ete trouve dans valeur --> on en rajoute un a la fin
 100                         if (self.is_param(valeur)):
 101                            return valeur
 102                         else:
 103                           try :
 104                             val2=eval(str(valeur)+'.')
 105                           except :
 106                             pass
 107          return valeurTexte
 108
 109   def is_param(self,valeur) :
 110       for param in self.node.item.jdc.params:
 111           if ((repr(param) == repr(valeur)) or (str(param)==str(valeur))):
 112              return 1
 113       return 0
 114
 115   def AjoutDsDictReel(self,texteValeur):
 116          # le try except est necessaire pour saisir les parametres
 117          # on enleve l erreur de saisie 00 pour 0
 118          if str(texteValeur)== '00' : return
 119          try :
 120             if "R" in self.node.item.object.definition.type:
 121                 if str(texteValeur)[0] != "'":
 122                    clef=eval(texteValeur)
 123                    if str(clef) != str(texteValeur) :
 124                       clefobj=self.node.item.object.GetNomConcept()
 125                       if not clefobj in self.parent.appliEficas :
 126                           self.parent.appliEficas.dict_reels[clefobj] = {}
 127                       self.parent.appliEficas.dict_reels[clefobj][clef]=texteValeur
 128                       if clefobj=="" :
 129                          if not self.node.item.object.etape in self.parent.appliEficas.dict_reels :
 130                             self.parent.appliEficas.dict_reels[self.node.item.object.etape] = {}
 131                          self.parent.appliEficas.dict_reels[self.node.item.object.etape][clef]=texteValeur
 132
 133          except:
 134           pass
 135
 136   def AjoutDsDictReelEtape(self):
 137       try:
 138          if self.node.item.object in self.parent.appliEficas.dict_reels:
 139             self.parent.appliEficas.dict_reels[self.node.item.sdnom]=self.parent.appliEficas.dict_reels[self.node.item.object]
 140             del self.parent.appliEficas.dict_reels[self.node.item.object]
 141       except :
 142          pass
 143
 144
 145 #------------------------------------
 146 class PolitiqueUnique(Validation) :
 147 #------------------------------------
 148   """
 149   classe servant pour les entrees ne demandant qu un mot clef
 150   """
 151   def __init__(self,node,parent):
 152         Validation.__init__(self,node,parent)
 153
 154   def RecordValeur(self,valeurentree):
 155          if self.parent.modified == 'n' : self.parent.init_modif()
 156          ancienne_val = self.node.item.get_valeur()
 157          valeur,validite,commentaire =self.TesteUneValeur(valeurentree)
 158          if validite and ('R' in self.node.item.object.definition.type) and not(isinstance(valeur,PARAMETRE)) :
 159             s=valeurentree
 160             if (s.find('.')== -1 and s.find('e')== -1 and s.find('E')==-1) : s=s+'.'
 161             valeur,validite,commentaire =self.TesteUneValeur(s)
 162          if validite :
 163             validite=self.node.item.set_valeur(valeur)
 164             if self.node.item.isvalid():
 165                   commentaire = tr("Valeur du mot-cle enregistree")
 166                   #commentaire = "Valeur du mot-cle enregistree"
 167                   self.SetValeurTexte(str(valeurentree))
 168             else:
 169                   cr = self.node.item.get_cr()
 170                   commentaire =  tr("Valeur du mot-cle non autorisee ")+cr.get_mess_fatal()
 171                   self.node.item.set_valeur(ancienne_val)
 172          return validite, commentaire
 173
 174
 175 #--------------------------------------
 176 class PolitiquePlusieurs(Validation):
 177 #--------------------------------------
 178   """
 179   classe servant pour les entrees ne demandant qu un mot clef
 180   """
 181   def __init__(self,node,parent) :
 182          #print "ds PolitiquePlusieurs"
 183          self.node=node
 184          self.parent=parent
 185          #print self.node
 186          #print self.parent
 187
 188
 189   def AjoutValeurs(self,listevaleur,index,listecourante):
 190          listeRetour=[]
 191          commentaire="Nouvelle valeur acceptee"
 192          commentaire2=""
 193          valide=1
 194          if listevaleur==None: return
 195          if listevaleur=="": return
 196          if not( type(listevaleur)  in (list,tuple)) :
 197             listevaleur=tuple(listevaleur)
 198          # on verifie que la cardinalite max n a pas ete atteinte
 199          min,max = self.node.item.GetMinMax()
 200          if len(listecourante) + len(listevaleur) > max :
 201             commentaire="La liste atteint le nombre maximum d'elements : "+ str(max) +" ,ajout refuse"
 202             return False,commentaire,commentaire2,listeRetour
 203
 204          for valeur in listevaleur :
 205              # On teste le type de la valeur
 206              valeurScientifique=valeur
 207              valide=self.node.item.valide_item(valeur)
 208              if not valide :
 209                 try :
 210                    valeur,valide=self.node.item.eval_valeur(valeur)
 211                    valide,commentaire2 = self.node.item.object.verif_type(valeur)
 212                 except :
 213                    #return testtype,commentaire,"",listeRetour
 214                    pass
 215              if not valide:
 216                 if commentaire.find("On attend un chaine") > 1 :
 217                    commentaire="Valeur "+str(valeur)+ " incorrecte : ajout a la liste refuse: On attend une chaine de caracteres < 8"
 218                 else :
 219                    commentaire="Valeur "+str(valeur)+ " incorrecte : ajout a la liste refuse"
 220                 if commentaire2== "" :commentaire2=self.node.item.info_erreur_item()
 221                 return valide,commentaire,commentaire2,listeRetour
 222
 223              # On valide la liste obtenue
 224              encorevalide=self.node.item.valide_liste_partielle(valeur,listecourante)
 225              if not encorevalide :
 226                 commentaire2=self.node.item.info_erreur_liste()
 227                 # On traite le cas ou la liste n est pas valide pour un pb de cardinalite
 228                 min,max = self.node.item.GetMinMax()
 229                 if len(listecourante) + 1 >= max :
 230                    commentaire="La liste atteint le nombre maximum d'elements : "+ str(max) +" ,ajout refuse"
 231                    return valide,commentaire,commentaire2,listeRetour
 232                 if len(listecourante) + 1 > min :
 233                    commentaire=""
 234                    return valide,commentaire,commentaire2,listeRetour
 235              # On ajoute la valeur testee a la liste courante et a la liste acceptee
 236              self.AjoutDsDictReel(valeurScientifique)
 237              listecourante.insert(index,valeur)
 238              index=index+1
 239              listeRetour.append(valeur)
 240
 241          return valide,commentaire,commentaire2,listeRetour
 242
 243   def AjoutTuple(self,valeurTuple,listecourante):
 244          listeRetour=[]
 245          commentaire="Nouvelle valeur acceptee"
 246          commentaire2=""
 247          valide=1
 248          if valeurTuple==None: return
 249          if valeurTuple==['']: return
 250          # On teste le type de la valeur
 251          valide=self.node.item.valide_item(valeurTuple)
 252          if not valide :
 253             try :
 254                 valeur,valide=self.node.item.eval_valeur(valeurTuple)
 255                 valide = self.node.item.valide_item(valeur)
 256             except :
 257                 pass
 258          if not valide:
 259             commentaire="Valeur "+str(valeurTuple)+ " incorrecte : ajout a la liste refuse"
 260             commentaire2=self.node.item.info_erreur_item()
 261             return valide,commentaire,commentaire2,listeRetour
 262
 263          # On valide la liste obtenue
 264          encorevalide=self.node.item.valide_liste_partielle(valeurTuple,listecourante)
 265          if not encorevalide :
 266             commentaire2=self.node.item.info_erreur_liste()
 267             return valide,commentaire,commentaire2,listeRetour
 268          listeRetour.append(valeurTuple)
 269          return valide,commentaire,commentaire2,listeRetour