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         if lval is None:
 104            valid=0
 105            if cr == 'oui' :
 106               self.cr.fatal(_(u"None n'est pas une valeur autorisée"))
 107         else:
 108            # type,into ...
 109            #typeProto=TypeProtocol("type",typ=self.definition.type)
 110            #intoProto=IntoProtocol("into",into=self.definition.into,val_min=self.definition.val_min,val_max=self.definition.val_max)
 111            #cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
 112            #typeProto=self.definition.typeProto
 113            #intoProto=self.definition.intoProto
 114            #cardProto=self.definition.cardProto
 115            typeProto=self.typeProto
 116            intoProto=self.intoProto
 117            cardProto=self.cardProto
 118            if cr == 'oui' :
 119                #un cr est demandé : on collecte tous les types d'erreur
 120                try:
 121                    for val in lval:
 122                        typeProto.adapt(val)
 123                except ValError,e:
 124                    valid=0
 125                    self.cr.fatal(*e)
 126                try:
 127                    for val in lval:
 128                        intoProto.adapt(val)
 129                except ValError,e:
 130                    valid=0
 131                    self.cr.fatal(*e)
 132                    #self.cr.fatal(unicode(e))
 133                try:
 134                    cardProto.adapt(lval)
 135                except ValError,e:
 136                    valid=0
 137                    self.cr.fatal(*e)
 138                    #self.cr.fatal(unicode(e))
 139                #
 140                # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
 141                #
 142                if valid and self.definition.validators:
 143                    try:
 144                        self.definition.validators.convert(lval)
 145                    except ValError,e:
 146                        self.cr.fatal(_(u"Mot-clé %s invalide : %s\nCritère de validité: %s"),
 147                             self.nom, str(e), self.definition.validators.info())
 148                        valid=0
 149            else:
 150                #si pas de cr demande, on sort a la toute premiere erreur
 151                try:
 152                    for val in lval:
 153                        typeProto.adapt(val)
 154                        intoProto.adapt(val)
 155                    cardProto.adapt(lval)
 156                    if self.definition.validators:
 157                        if hasattr(self.definition.validators,'set_MCSimp'):
 158                           self.definition.validators.set_MCSimp(self)
 159                        self.definition.validators.convert(lval)
 160                except ValError,e:
 161                    valid=0
 162
 163         self.set_valid(valid)
 164         return self.valid
 165
 166    def isoblig(self):
 167       """ indique si le mot-clé est obligatoire
 168       """
 169       return self.definition.statut=='o'
 170
 171    def init_modif_up(self):
 172       """
 173          Propage l'état modifié au parent s'il existe et n'est l'objet
 174          lui-meme
 175       """
 176       if self.parent and self.parent != self :
 177         self.parent.state = 'modified'
 178
 179    def report(self):
 180       """ génère le rapport de validation de self """
 181       self.cr=self.CR()
 182       self.cr.debut = u"Mot-clé simple : "+self.nom
 183       self.cr.fin = u"Fin Mot-clé simple : "+self.nom
 184       self.state = 'modified'
 185       try:
 186         self.isvalid(cr='oui')
 187       except AsException,e:
 188         if CONTEXT.debug : traceback.print_exc()
 189         self.cr.fatal(_(u"Mot-clé simple : %s %s"), self.nom, e)
 190       return self.cr
 191
 192
 193
 194
 195
 196