InterfaceQT4/politiquesValidation.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   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
  39     def testeUneValeur(self,valeurentree):
  40         commentaire = None
  41         #import traceback
  42         #traceback.print_stack()
  43         valeur,validite=self.node.item.evalValeur(valeurentree)
  44         if not validite :
  45             commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
  46             return valeur,validite,commentaire
  47         if self.node.item.waitTxm() and not( type(valeur) == str) : valeur=str(valeur)
  48
  49         testtype,commentaire = self.node.item.object.verifType(valeur)
  50         if not testtype :
  51             return valeur,0,commentaire
  52
  53         valide=self.node.item.valideItem(valeur)
  54         if type(valide) == tuple:
  55             validite,commentaire=valide
  56         else :
  57             validite=valide
  58             commentaire=" "
  59
  60         if not validite and commentaire is None:
  61             commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
  62         #print ('ds testeUneValeur', valeur, validite, commentaire)
  63         return valeur, validite, commentaire
  64
  65 # ----------------------------------------------------------------------------------------
  66 #   Methodes utilisees pour la manipulation des items en notation scientifique
  67 #   a mettre au point
  68 # ----------------------------------------------------------------------------------------
  69     def setValeurTexte(self,texteValeur) :
  70         try :
  71             if "R" in self.node.item.object.definition.type:
  72                 if texteValeur[0] != "'":
  73                     clef=eval(texteValeur)
  74                     if str(clef) != str(texteValeur) :
  75                         self.node.item.object.initModif()
  76                         clefobj=self.node.item.object.getNomConcept()
  77                         if not clefobj in self.parent.appliEficas.dict_reels:
  78                             self.parent.appliEficas.dict_reels[clefobj] = {}
  79                         self.parent.appliEficas.dict_reels[clefobj][clef]=texteValeur
  80                         self.parent.appliEficas.dict_reels[clefobj]
  81                         if clefobj=="" :
  82                             if not self.node.item.object.etape in self.parent.appliEficas.dict_reels :
  83                                 self.parent.appliEficas.dict_reels[self.node.item.object.etape] = {}
  84                             self.parent.appliEficas.dict_reels[self.node.item.object.etape][clef]=texteValeur
  85                         self.node.item.object.finModif()
  86         except:
  87             pass
  88
  89     def getValeurTexte(self,valeur) :
  90         valeurTexte=valeur
  91         if valeur == None : return valeur
  92         from decimal import Decimal
  93         if  isinstance(valeur,Decimal) :
  94             if self.node.waitTxm() and not self.isParam(valeur) : return "'"+str(valeur)+"'"
  95             else : return(valeur)
  96         if "R" in self.node.item.object.definition.type:
  97             clefobj=self.node.item.object.getNomConcept()
  98             if clefobj in self.parent.appliEficas.dict_reels:
  99                 if valeur in self.parent.appliEficas.dict_reels[clefobj] :
 100                     valeurTexte=self.parent.appliEficas.dict_reels[clefobj][valeur]
 101             else :
 102                 if str(valeur).find('.') == -1 and str(valeur).find('e') == -1 and str(valeur).find('E'):
 103                 # aucun '.' n'a ete trouve dans valeur --> on en rajoute un a la fin
 104                     if (self.isParam(valeur)):
 105                         return valeur
 106                     else:
 107                         try :
 108                             val2=eval(str(valeur)+'.')
 109                         except :
 110                             pass
 111         return valeurTexte
 112
 113     def isParam(self,valeur) :
 114         for param in self.node.item.jdc.params:
 115             if ((repr(param) == repr(valeur)) or (str(param)==str(valeur))):
 116                 return 1
 117         return 0
 118
 119     def ajoutDsDictReel(self,texteValeur):
 120         # le try except est necessaire pour saisir les parametres
 121         # on enleve l erreur de saisie 00 pour 0
 122         if str(texteValeur)== '00' : return
 123         try :
 124             if "R" in self.node.item.object.definition.type:
 125                 if str(texteValeur)[0] != "'":
 126                     clef=eval(texteValeur)
 127                     if str(clef) != str(texteValeur) :
 128                         clefobj=self.node.item.object.getNomConcept()
 129                         if not clefobj in self.parent.appliEficas :
 130                             self.parent.appliEficas.dict_reels[clefobj] = {}
 131                         self.parent.appliEficas.dict_reels[clefobj][clef]=texteValeur
 132                         if clefobj=="" :
 133                             if not self.node.item.object.etape in self.parent.appliEficas.dict_reels :
 134                                 self.parent.appliEficas.dict_reels[self.node.item.object.etape] = {}
 135                             self.parent.appliEficas.dict_reels[self.node.item.object.etape][clef]=texteValeur
 136
 137         except:
 138             pass
 139
 140     def ajoutDsDictReelEtape(self):
 141         try:
 142             if self.node.item.object in self.parent.appliEficas.dict_reels:
 143                 self.parent.appliEficas.dict_reels[self.node.item.sdnom]=self.parent.appliEficas.dict_reels[self.node.item.object]
 144                 del self.parent.appliEficas.dict_reels[self.node.item.object]
 145         except :
 146             pass
 147
 148
 149 #------------------------------------
 150 class PolitiqueUnique(Validation) :
 151 #------------------------------------
 152     """
 153     classe servant pour les entrees ne demandant qu un mot clef
 154     """
 155     def __init__(self,node,parent):
 156         Validation.__init__(self,node,parent)
 157
 158     def recordValeur(self,valeurentree):
 159         if self.parent.modified == 'n' : self.parent.initModif()
 160         ancienneVal = self.node.item.getValeur()
 161         valeur,validite,commentaire =self.testeUneValeur(valeurentree)
 162         if validite and ('R' in self.node.item.object.definition.type) and not(isinstance(valeur,PARAMETRE)) :
 163             s=valeurentree
 164             if (s.find('.')== -1 and s.find('e')== -1 and s.find('E')==-1) : s=s+'.'
 165             valeur,validite,commentaire =self.testeUneValeur(s)
 166         if validite :
 167             validite=self.node.item.setValeur(valeur)
 168             if self.node.item.isValid():
 169                 commentaire = tr("Valeur du mot-cle enregistree")
 170                 #commentaire = "Valeur du mot-cle enregistree"
 171                 self.setValeurTexte(str(valeurentree))
 172             else:
 173                 cr = self.node.item.getCr()
 174                 commentaire =  tr("Valeur du mot-cle non autorisee ")+cr.getMessFatal()
 175                 self.node.item.setValeur(ancienneVal)
 176         return validite, commentaire
 177
 178
 179 #--------------------------------------
 180 class PolitiquePlusieurs(Validation):
 181 #--------------------------------------
 182     """
 183     classe servant pour les entrees ne demandant qu un mot clef
 184     """
 185     def __init__(self,node,parent) :
 186         #print "ds PolitiquePlusieurs"
 187         self.node=node
 188         self.parent=parent
 189         #print self.node
 190         #print self.parent
 191
 192
 193     def ajoutValeurs(self,listevaleur,index,listecourante):
 194         listeRetour=[]
 195         commentaire="Nouvelle valeur acceptee"
 196         commentaire2=""
 197         valide=1
 198         if listevaleur==None: return
 199         if listevaleur=="": return
 200         if not( type(listevaleur)  in (list,tuple)) :
 201             listevaleur=tuple(listevaleur)
 202         # on verifie que la cardinalite max n a pas ete atteinte
 203         min,max = self.node.item.getMinMax()
 204         if len(listecourante) + len(listevaleur) > max :
 205             commentaire="La liste atteint le nombre maximum d'elements : "+ str(max) +" ,ajout refuse"
 206             return False,commentaire,commentaire2,listeRetour
 207
 208         for valeur in listevaleur :
 209                 # On teste le type de la valeur
 210             valeurScientifique=valeur
 211             valide=self.node.item.valideItem(valeur)
 212             if not valide :
 213                 try :
 214                     valeur,valide=self.node.item.evalValeur(valeur)
 215                     valide,commentaire2 = self.node.item.object.verifType(valeur)
 216                 except :
 217                     #return testtype,commentaire,"",listeRetour
 218                     pass
 219             if not valide:
 220                 if commentaire.find("On attend un chaine") > 1 :
 221                     commentaire="Valeur "+str(valeur)+ " incorrecte : ajout a la liste refuse: On attend une chaine de caracteres < 8"
 222                 else :
 223                     commentaire="Valeur "+str(valeur)+ " incorrecte : ajout a la liste refuse"
 224                 if commentaire2== "" :commentaire2=self.node.item.infoErreurItem()
 225                 return valide,commentaire,commentaire2,listeRetour
 226
 227             # On valide la liste obtenue
 228             encorevalide=self.node.item.valideListePartielle(valeur,listecourante)
 229             if not encorevalide :
 230                 commentaire2=self.node.item.infoErreurListe()
 231                 # On traite le cas ou la liste n est pas valide pour un pb de cardinalite
 232                 min,max = self.node.item.getMinMax()
 233                 if len(listecourante) + 1 >= max :
 234                     commentaire="La liste atteint le nombre maximum d'elements : "+ str(max) +" ,ajout refuse"
 235                     return valide,commentaire,commentaire2,listeRetour
 236                 if len(listecourante) + 1 > min :
 237                     commentaire=""
 238                     return valide,commentaire,commentaire2,listeRetour
 239             # On ajoute la valeur testee a la liste courante et a la liste acceptee
 240             self.ajoutDsDictReel(valeurScientifique)
 241             listecourante.insert(index,valeur)
 242             index=index+1
 243             listeRetour.append(valeur)
 244
 245         return valide,commentaire,commentaire2,listeRetour
 246
 247     def ajoutTuple(self,valeurTuple,listecourante):
 248         listeRetour=[]
 249         commentaire="Nouvelle valeur acceptee"
 250         commentaire2=""
 251         valide=1
 252         if valeurTuple==None: return
 253         if valeurTuple==['']: return
 254         # On teste le type de la valeur
 255         valide=self.node.item.valideItem(valeurTuple)
 256         if not valide :
 257             try :
 258                 valeur,valide=self.node.item.evalValeur(valeurTuple)
 259                 valide = self.node.item.valideItem(valeur)
 260             except :
 261                 pass
 262         if not valide:
 263             commentaire="Valeur "+str(valeurTuple)+ " incorrecte : ajout a la liste refuse"
 264             commentaire2=self.node.item.infoErreurItem()
 265             return valide,commentaire,commentaire2,listeRetour
 266
 267         # On valide la liste obtenue
 268         encorevalide=self.node.item.valideListePartielle(valeurTuple,listecourante)
 269         if not encorevalide :
 270             commentaire2=self.node.item.infoErreurListe()
 271             return valide,commentaire,commentaire2,listeRetour
 272         listeRetour.append(valeurTuple)
 273         return valide,commentaire,commentaire2,listeRetour
 274
 275     def ajoutNTuple(self,liste):
 276         commentaire="Nouvelles valeurs acceptee"
 277         commentaire2=""
 278         valide=self.node.item.valideListePartielle(None,liste)
 279         print ('uuuuuuuuuuu',valide)
 280         if not valide :
 281             commentaire2=self.node.item.infoErreurListe()
 282         return valide,commentaire,commentaire2
 283
 284     def recordValeur(self,liste,dejaValide=True):
 285         ancienneVal = self.node.item.getValeur()
 286         validite=self.node.item.setValeur(liste)
 287         if validite : self.node.item.initModif()
 288         if self.node.item.isValid():
 289             commentaire = tr("Valeur du mot-cle enregistree")
 290         else:
 291             cr = self.node.item.getCr()
 292             commentaire =  tr("Valeur du mot-cle non autorisee ")+cr.getMessFatal()
 293             self.node.item.setValeur(ancienneVal)
 294         return validite, commentaire