Validation/V_MCSIMP.py

   1 # coding=utf-8
   2 # person_in_charge: mathieu.courtois at edf.fr
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2015  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21
  22 """
  23    Ce module contient la classe mixin MCSIMP qui porte les méthodes
  24    nécessaires pour réaliser la validation d'un objet de type MCSIMP
  25    dérivé de OBJECT.
  26
  27    Une classe mixin porte principalement des traitements et est
  28    utilisée par héritage multiple pour composer les traitements.
  29 """
  30 # Modules Python
  31 import traceback
  32
  33 # Modules EFICAS
  34 from Noyau import N_CR
  35 from Noyau.N_Exception import AsException
  36 from Noyau.N_VALIDATOR import ValError, TypeProtocol, CardProtocol, IntoProtocol
  37 from Noyau.N_VALIDATOR import listProto
  38 from Noyau.strfunc import ufmt
  39 from Extensions.i18n import tr
  40
  41
  42 class MCSIMP:
  43
  44     """
  45        COMMENTAIRE CCAR:
  46        Cette classe est quasiment identique à la classe originale d'EFICAS
  47        a part quelques changements cosmétiques et des chagements pour la
  48        faire fonctionner de facon plus autonome par rapport à l'environnement
  49        EFICAS
  50
  51        A mon avis, il faudrait aller plus loin et réduire les dépendances
  52        amont au strict nécessaire.
  53
  54            - Est il indispensable de faire l'évaluation de la valeur dans le contexte
  55              du jdc dans cette classe.
  56
  57            - Ne pourrait on pas doter les objets en présence des méthodes suffisantes
  58              pour éviter les tests un peu particuliers sur GEOM, PARAMETRE et autres. J'ai
  59              d'ailleurs modifié la classe pour éviter l'import de GEOM
  60     """
  61
  62     CR = N_CR.CR
  63
  64     def __init__(self):
  65         self.state = 'undetermined'
  66         self.typeProto = TypeProtocol("type", typ=self.definition.type)
  67         self.intoProto = IntoProtocol(
  68             "into", into=self.definition.into, val_min=self.definition.val_min, val_max=self.definition.val_max)
  69         self.cardProto = CardProtocol(
  70             "card", min=self.definition.min, max=self.definition.max)
  71
  72     def get_valid(self):
  73         if hasattr(self, 'valid'):
  74             return self.valid
  75         else:
  76             self.valid = None
  77             return None
  78
  79     def set_valid(self, valid):
  80         old_valid = self.get_valid()
  81         self.valid = valid
  82         self.state = 'unchanged'
  83         if not old_valid or old_valid != self.valid:
  84             self.init_modif_up()
  85
  86     def isvalid(self, cr='non'):
  87         """
  88            Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP
  89
  90              - 0 si l'objet est invalide
  91              - 1 si l'objet est valide
  92
  93            Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui'
  94            la méthode construit également un comte-rendu de validation
  95            dans self.cr qui doit avoir été créé préalablement.
  96         """
  97         if self.state == 'unchanged':
  98             return self.valid
  99         else:
 100             valid = 1
 101             v = self.valeur
 102             #  verification presence
 103             if self.isoblig() and v == None:
 104                 if cr == 'oui':
 105                     self.cr.fatal(
 106                         _(u"Mandatory keyword : %s has no value"), tr(self.nom))
 107                         #_(u"Mot-clé : %s obligatoire non valorisé"), self.nom)
 108                 valid = 0
 109
 110             lval = listProto.adapt(v)
 111             # Ajout PN
 112             # Pour tenir compte des Tuples
 113             if hasattr(self.definition.type[0],'ntuple') :
 114                try :
 115                   if not (type(lval[0]) is tuple) : lval=(lval,)
 116                except :
 117                   pass
 118
 119             if lval is None:
 120                 valid = 0
 121                 if cr == 'oui':
 122                     self.cr.fatal(_(u"None is not a valid value"))
 123                     #self.cr.fatal(_(u"None n'est pas une valeur autorisée"))
 124             else:
 125                 # type,into ...
 126                 # typeProto=TypeProtocol("type",typ=self.definition.type)
 127                 # intoProto=IntoProtocol("into",into=self.definition.into,val_min=self.definition.val_min,val_max=self.definition.val_max)
 128                 # cardProto=CardProtocol("card",min=self.definition.min,max=self.definition.max)
 129                 # typeProto=self.definition.typeProto
 130                 # intoProto=self.definition.intoProto
 131                 # cardProto=self.definition.cardProto
 132                 typeProto = self.typeProto
 133                 intoProto = self.intoProto
 134                 cardProto = self.cardProto
 135                 if cr == 'oui':
 136                     # un cr est demandé : on collecte tous les types d'erreur
 137                     try:
 138                         for val in lval:
 139                             typeProto.adapt(val)
 140                     except ValError, e:
 141                         valid = 0
 142                         self.cr.fatal(*e)
 143                     try:
 144                         for val in lval:
 145                             intoProto.adapt(val)
 146                     except ValError, e:
 147                         valid = 0
 148                         self.cr.fatal(*e)
 149                     try:
 150                         cardProto.adapt(lval)
 151                     except ValError, e:
 152                         valid = 0
 153                         self.cr.fatal(*e)
 154                     #
 155                     # On verifie les validateurs s'il y en a et si necessaire (valid == 1)
 156                     #
 157                     if valid and self.definition.validators:
 158                         try:
 159                             self.definition.validators.convert(lval)
 160                         except ValError, e:
 161                             self.cr.fatal(
 162                                 #_(u"Mot-clé %s invalide : %s\nCritère de validité: %s"),
 163                                 _(u"invalid keyword %s  : %s\nCriteria : %s"),
 164                                 tr(self.nom), str(e), self.definition.validators.info())
 165                             valid = 0
 166                 else:
 167                     # si pas de cr demande, on sort a la toute premiere erreur
 168                     try:
 169                         for val in lval:
 170                             typeProto.adapt(val)
 171                             intoProto.adapt(val)
 172                         cardProto.adapt(lval)
 173                         if self.definition.validators:
 174                             if hasattr(self.definition.validators, 'set_MCSimp'):
 175                                 self.definition.validators.set_MCSimp(self)
 176                             self.definition.validators.convert(lval)
 177                     except ValError, e:
 178                         valid = 0
 179
 180             self.set_valid(valid)
 181             return self.valid
 182
 183     def isoblig(self):
 184         """ indique si le mot-clé est obligatoire
 185         """
 186         return self.definition.statut == 'o'
 187
 188     def init_modif_up(self):
 189         """
 190            Propage l'état modifié au parent s'il existe et n'est l'objet
 191            lui-meme
 192         """
 193         if self.parent and self.parent != self:
 194             self.parent.state = 'modified'
 195
 196     def report(self):
 197         """ génère le rapport de validation de self """
 198         self.cr = self.CR()
 199         #self.cr.debut = u"Mot-clé simple : " + self.nom
 200         self.cr.debut = u"Simple Keyword : " + tr(self.nom)
 201         #self.cr.fin = u"Fin Mot-clé simple : " + self.nom
 202         self.cr.fin = u"End Simple Keyword: " + tr(self.nom)
 203         self.state = 'modified'
 204         try:
 205             self.isvalid(cr='oui')
 206         except AsException, e:
 207             if CONTEXT.debug:
 208                 traceback.print_exc()
 209             #self.cr.fatal(_(u"Mot-clé simple : %s %s"), self.nom, e)
 210             self.cr.fatal(_(u"Simple Keyword  : %s %s"), tr(self.nom), e)
 211         return self.cr