Validation/V_MCSIMP.py

   1 # -*- coding: iso-8859-1 -*-
   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
  21 """
  22    Ce module contient la classe mixin MCSIMP qui porte les méthodes
  23    nécessaires pour réaliser la validation d'un objet de type MCSIMP
  24    dérivé de OBJECT.
  25
  26    Une classe mixin porte principalement des traitements et est
  27    utilisée par héritage multiple pour composer les traitements.
  28 """
  29 # Modules Python
  30 import traceback
  31
  32 # Modules EFICAS
  33 from Noyau import N_CR
  34 from Noyau.N_Exception import AsException
  35 from Noyau.N_VALIDATOR import ValError,TypeProtocol,CardProtocol,IntoProtocol
  36 from Noyau.N_VALIDATOR import listProto
  37 from Noyau.strfunc import ufmt
  38
  39 class MCSIMP:
  40    """
  41       COMMENTAIRE CCAR:
  42       Cette classe est quasiment identique à la classe originale d'EFICAS
  43       a part quelques changements cosmétiques et des chagements pour la
  44       faire fonctionner de facon plus autonome par rapport à l'environnement
  45       EFICAS
  46
  47       A mon avis, il faudrait aller plus loin et réduire les dépendances
  48       amont au strict nécessaire.
  49
  50           - Est il indispensable de faire l'évaluation de la valeur dans le contexte
  51             du jdc dans cette classe.
  52
  53           - Ne pourrait on pas doter les objets en présence des méthodes suffisantes
  54             pour éviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
  55             d'ailleurs modifié la classe pour éviter l'import de GEOM
  56    """
  57
  58    CR=N_CR.CR
  59
  60    def __init__(self):
  61       self.state='undetermined'
  62       self.typeProto=TypeProtocol("type",typ=self.definition.type)
  63       self.intoProto=IntoProtocol("into",into=self.definition.into,val_min=self.definition.val_min,val_max=self.definition.val_max)
  64       self.cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
  65
  66    def get_valid(self):
  67        if hasattr(self,'valid'):
  68           return self.valid
  69        else:
  70           self.valid=None
  71           return None
  72
  73    def set_valid(self,valid):
  74        old_valid=self.get_valid()
  75        self.valid = valid
  76        self.state = 'unchanged'
  77        if not old_valid or old_valid != self.valid :
  78            self.init_modif_up()
  79
  80    def isvalid(self,cr='non'):
  81       """
  82          Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
  83
  84            - 0 si l'objet est invalide
  85            - 1 si l'objet est valide
  86
  87          Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
  88          la méthode construit également un comte-rendu de validation
  89          dans self.cr qui doit avoir été créé préalablement.
  90       """
  91       if self.state == 'unchanged':
  92         return self.valid
  93       else:
  94         valid = 1
  95         v=self.valeur
  96         #  verification presence
  97         if self.isoblig() and v == None :
  98           if cr == 'oui' :
  99             self.cr.fatal(_(u"Mot-clé : %s obligatoire non valorisé"), self.nom)
 100           valid = 0
 101
 102         lval=listProto.adapt(v)
 103         #Pour tenir compte des Tuples
 104         if hasattr(self.definition.type[0],'ntuple') :
 105            try :
 106               if not (type(lval[0]) is tuple) : lval=(lval,)
 107            except :
 108               pass
 109         if lval is None:
 110            valid=0
 111            if cr == 'oui' :
 112               self.cr.fatal(_(u"None n'est pas une valeur autorisée"))
 113         else:
 114            # type,into ...
 115            #typeProto=TypeProtocol("type",typ=self.definition.type)
 116            #intoProto=IntoProtocol("into",into=self.definition.into,val_min=self.definition.val_min,val_max=self.definition.val_max)
 117            #cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
 118            #typeProto=self.definition.typeProto
 119            #intoProto=self.definition.intoProto
 120            #cardProto=self.definition.cardProto
 121            typeProto=self.typeProto
 122            intoProto=self.intoProto
 123            cardProto=self.cardProto
 124            if cr == 'oui' :
 125                #un cr est demandé : on collecte tous les types d'erreur
 126                try:
 127                    for val in lval:
 128                        typeProto.adapt(val)
 129                except ValError,e:
 130                    valid=0
 131                    self.cr.fatal(*e)
 132                try:
 133                    for val in lval:
 134                        intoProto.adapt(val)
 135                except ValError,e:
 136                    valid=0
 137                    self.cr.fatal(*e)
 138                    #self.cr.fatal(unicode(e))
 139                try:
 140                    cardProto.adapt(lval)
 141                except ValError,e:
 142                    valid=0
 143                    self.cr.fatal(*e)
 144                    #self.cr.fatal(unicode(e))
 145                #
 146                # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
 147                #
 148                if valid and self.definition.validators:
 149                    try:
 150                        self.definition.validators.convert(lval)
 151                    except ValError,e:
 152                        self.cr.fatal(_(u"Mot-clé %s invalide : %s\nCritère de validité: %s"),
 153                             self.nom, str(e), self.definition.validators.info())
 154                        valid=0
 155            else:
 156                #si pas de cr demande, on sort a la toute premiere erreur
 157                try:
 158                    for val in lval:
 159                        typeProto.adapt(val)
 160                        intoProto.adapt(val)
 161                    cardProto.adapt(lval)
 162                    if self.definition.validators:
 163                        if hasattr(self.definition.validators,'set_MCSimp'):
 164                           self.definition.validators.set_MCSimp(self)
 165                        self.definition.validators.convert(lval)
 166                except ValError,e:
 167                    valid=0
 168
 169         self.set_valid(valid)
 170         return self.valid
 171
 172    def isoblig(self):
 173       """ indique si le mot-clé est obligatoire
 174       """
 175       return self.definition.statut=='o'
 176
 177    def init_modif_up(self):
 178       """
 179          Propage l'état modifié au parent s'il existe et n'est l'objet
 180          lui-meme
 181       """
 182       if self.parent and self.parent != self :
 183         self.parent.state = 'modified'
 184
 185    def report(self):
 186       """ génère le rapport de validation de self """
 187       self.cr=self.CR()
 188       self.cr.debut = u"Mot-clé simple : "+self.nom
 189       self.cr.fin = u"Fin Mot-clé simple : "+self.nom
 190       self.state = 'modified'
 191       try:
 192         self.isvalid(cr='oui')
 193       except AsException,e:
 194         if CONTEXT.debug : traceback.print_exc()
 195         self.cr.fatal(_(u"Mot-clé simple : %s %s"), self.nom, e)
 196       return self.cr
 197
 198
 199
 200
 201
 202