From abb07c9c48795d4374a99a90777c27022d4ecf16 Mon Sep 17 00:00:00 2001 From: Christian Caremoli <> Date: Wed, 24 May 2006 17:01:39 +0000 Subject: [PATCH] CCAR: adaptation nouveau mecanisme de validation --- Ihm/I_MCSIMP.py | 399 +++++++-------------------------------------- Ihm/I_VALIDATOR.py | 21 +++ 2 files changed, 84 insertions(+), 336 deletions(-) diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index 0723393f..4e84c2a9 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -47,8 +47,7 @@ from Extensions import parametre from Extensions import param2 import I_OBJECT import CONNECTOR - -#from I_VALIDATOR import ValidException +from I_VALIDATOR import ValError,listProto class MCSIMP(I_OBJECT.OBJECT): @@ -220,49 +219,53 @@ class MCSIMP(I_OBJECT.OBJECT): def isoblig(self): return self.definition.statut=='o' + def valid_val(self,valeur): + """ + Verifie que la valeur passee en argument (valeur) est valide + sans modifier la valeur courante + """ + lval=listProto.adapt(valeur) + if lval is None: + valid=0 + mess="None n'est pas une valeur autorisée" + else: + try: + for val in lval: + self.typeProto.adapt(val) + self.intoProto.adapt(val) + self.cardProto.adapt(lval) + if self.definition.validators: + self.definition.validators.convert(lval) + valid,mess=1,"" + except ValError,e: + mess=str(e) + valid=0 + return valid,mess + def valid_valeur(self,new_valeur): """ Verifie que la valeur passee en argument (new_valeur) est valide sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant) """ - old_valeur=self.valeur - old_val=self.val - self.valeur = new_valeur - self.val = new_valeur - self.state="modified" - validite=self.isvalid() - self.valeur = old_valeur - self.val = old_valeur - self.state="modified" - self.isvalid() + validite,mess=self.valid_val(new_valeur) return validite def valid_valeur_partielle(self,new_valeur): """ - Verifie que la valeur passee en argument (new_valeur) est partiellement valide - sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant) + Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide + sans modifier la valeur courante du mot cle """ - old_valeur=self.valeur - old_val=self.val - - self.valeur = new_valeur - self.val = new_valeur - self.state="modified" - validite=0 - if self.isvalid(): - validite=1 - elif self.definition.validators : - validite=self.definition.validators.valide_liste_partielle(new_valeur) - - if validite==0: - min,max=self.get_min_max() - if len(new_valeur) < min : - validite=1 - - self.valeur = old_valeur - self.val = old_valeur - self.state="modified" - self.isvalid() + validite=1 + try: + for val in new_valeur: + self.typeProto.adapt(val) + self.intoProto.adapt(val) + #on ne verifie pas la cardinalité + if self.definition.validators: + validite=self.definition.validators.valide_liste_partielle(new_valeur) + except ValError,e: + validite=0 + return validite def update_condition_bloc(self): @@ -536,313 +539,37 @@ class MCSIMP(I_OBJECT.OBJECT): if "VALE" in genea and "DEFI_FONCTION" in genea : return 2 return 0 + def valide_item(self,item): + """Valide un item isolé. Cet item est candidat à l'ajout à la liste existante""" + valid=1 + try: + #on verifie le type + self.typeProto.adapt(item) + #on verifie les choix possibles + self.intoProto.adapt(item) + #on ne verifie pas la cardinalité + if self.definition.validators: + valid=self.definition.validators.verif_item(item) + except ValError,e: + valid=0 + return valid + + def verif_type(self,item): + """Verifie le type d'un item de liste""" + try: + #on verifie le type + self.typeProto.adapt(item) + valid=1 + except ValError,e: + valid=0 + return valid + #-------------------------------------------------------------------------------- #ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation # Elles doivent etre reintegrees des que possible - def convert_card(self,valeur): - """ - Cette methode verifie que la cardinalite de valeur est correcte (comprise entre min et max) - Si c'est le cas elle retourne valeur eventuellement convertie - Si ce n'est pas le cas, elle leve une exception - """ - - adapt = getattr(valeur, '__adapt__', None) - if adapt is not None: - # l'objet valeur peut se verifier lui meme - return adapt(self.convert_card) - - min=self.definition.min - max=self.definition.max - - if type(valeur) == types.TupleType and valeur[0] in ('RI','MP'): - #il s'agit d'un complexe ancienne mode. La cardinalite vaut 1 - length=1 - elif valeur == None : - # pas de valeur affecte. La cardinalite vaut 0 - length=0 - elif type(valeur) == types.StringType : - #il s'agit d'une chaine. La cardinalite vaut 1 - length=1 - else: - try: - # si l'objet supporte len, on a la cardinalite - length=len(valeur) - except: - # sinon elle vaut 1 - length=1 - - if length < min or length >max: - raise ValidException("Nombre d'arguments de %s incorrect pour %s (min = %s, max = %s)" % (repr(valeur),self.nom,min,max) ) - - return valeur - - def verif_card(self,cr='non'): - """ - un mot-clé simple ne peut etre répété : - la cardinalité ici s'entend par la vérification que le nombre d'arguments de self.valeur - est bien compris entre self.min et self.max dans le cas où il s'agit d'une liste - """ - card = 1 - try: - self.convert_card(self.valeur) - except ValidException,e: - if cr == 'oui': self.cr.fatal(str(e)) - card = 0 - return card - - def convert_into(self,valeur): - """ - Cette methode verifie que valeur est dans la liste des valeurs possibles donnée - dans la definition (attribut into) ou dans un intervalle donné dans la definition (attributs - val_min, val_max) - Si c'est le cas elle retourne valeur eventuellement convertie - Si ce n'est pas le cas, elle leve une exception - """ - adapt = getattr(valeur, '__adapt__', None) - if adapt is not None: - # l'objet valeur peut se verifier lui meme - return adapt(self.convert_into) - - if type(valeur) == types.TupleType and not valeur[0] in ('RI','MP') or type(valeur) == types.ListType: - # Cas d'une liste de valeurs - # on s'arrete a la premiere erreur - for val in valeur: - self.convert_into(val) - return valeur - - # Cas d'un scalaire - if self.definition.into == None : - #on est dans le cas d'un ensemble continu de valeurs possibles (intervalle) - if type(valeur) in (types.IntType,types.FloatType,types.LongType) : - min = self.definition.val_min - max = self.definition.val_max - if min == '**': min = valeur -1 - if max == '**': max = valeur +1 - if valeur < min or valeur > max : - raise ValidException("La valeur : %s du mot-clé %s est en dehors du domaine de validité [ %s , %s ]" % (repr(valeur),self.nom,min,max) ) - return valeur - else : - # on est dans le cas d'un ensemble discret de valeurs possibles (into) - if valeur not in self.definition.into: - raise ValidException("La valeur : %s n'est pas permise pour le mot-clé : %s" % (repr(valeur),self.nom) ) - return valeur - - def verif_into(self,cr='non'): - """ - Vérifie si la valeur de self est bien dans l'ensemble discret de valeurs - donné dans le catalogue derrière l'attribut into ou vérifie que valeur est bien compris - entre val_min et val_max - """ - into = 1 - try: - self.convert_into(self.valeur) - except ValidException,e: - if cr == 'oui': self.cr.fatal(str(e)) - into = 0 - return into - - def convert_type(self,valeur): - """ - Cette methode verifie que valeur est du bon type - Si c'est le cas elle retourne valeur eventuellement convertie - Si ce n'est pas le cas, elle leve une exception - """ - if self.definition.type is None: return valeur - - if valeur == None : - raise ValidException("None n'est pas une valeur autorisée") - - adapt = getattr(valeur, '__adapt__', None) - if adapt is not None: - # l'objet valeur peut se verifier lui meme - return adapt(self.convert_type) - - if type(valeur) == types.TupleType and not valeur[0] in ('RI','MP') or type(valeur) == types.ListType: - # Cas d'une liste de valeurs - # on s'arrete a la premiere erreur - for val in valeur: - self.convert_type(val) - return valeur - - # Ici, valeur est un scalaire ...il faut tester sur tous les types ou les valeurs possibles - for type_permis in self.definition.type: - if self.check_type(valeur,type_permis) : return valeur - # si on sort de la boucle précédente par ici c'est que l'on n'a trouvé aucun type valable --> valeur refusée - raise ValidException("%s n'est pas d'un type autorisé" % repr(valeur)) - - def check_type(self,valeur,type_permis): - """ - Fonction booléenne qui retourne 1 si valeur est du type type_permis, 0 sinon - """ - if type_permis == 'R': - return self.is_reel(valeur) - elif type_permis == 'I': - return self.is_entier(valeur) - elif type_permis == 'C': - return self.is_complexe(valeur) - elif type_permis == 'TXM': - return type(valeur)==types.StringType - elif type(type_permis) == types.ClassType: - return self.is_object_from(valeur,type_permis) - elif type(type_permis) == types.InstanceType: - try: - return type_permis.__convert__(valeur) is not None - except: - return 0 - elif type_permis == 'shell': - return self.is_shell(valeur) - else: - print "Type non encore géré %s" %`type_permis` - print self.nom,self.parent.nom,self.jdc.fichier - return 0 - - def is_complexe(self,valeur): - """ Retourne 1 si valeur est un complexe, 0 sinon """ - if type(valeur) in (types.ComplexType,types.IntType,types.FloatType,types.LongType): - # Pour permettre l'utilisation de complexes Python - return 1 - elif type(valeur) != types.TupleType : - # On n'autorise pas les listes pour les complexes - return 0 - elif len(valeur) != 3:return 0 - else: - # Un complexe doit etre un tuple de longueur 3 avec 'RI' ou 'MP' comme premiere - # valeur suivie de 2 reels. - if string.strip(valeur[0]) in ('RI','MP'): - try: - v1=self.convert_reel(valeur[1]),self.convert_reel(valeur[2]) - return 1 - except: - return 0 - else: - return 0 - - def convert_reel(self,valeur): - try: - return float(valeur) - except: - adapt = getattr(valeur, '__adapt__', None) - if adapt is not None: - # l'objet valeur peut se verifier lui meme - return adapt(self.convert_reel) - raise ValidException("%s n'est pas un reel" % repr(valeur)) - - def is_reel(self,valeur): - """ - Retourne 1 si valeur est un reel, 0 sinon - """ - if type(valeur) not in (types.IntType,types.FloatType,types.LongType): - # ce n'est pas un réel - return 0 - else: - return 1 - - def is_entier(self,valeur): - """ Retourne 1 si valeur est un entier, 0 sinon """ - if type(valeur) not in (types.IntType,types.LongType): - # ce n'est pas un entier - return 0 - else: - return 1 - - def is_shell(self,valeur): - """ - Retourne 1 si valeur est un shell, 0 sinon - Pour l'instant aucune vérification n'est faite - On impose juste que valeur soit une string - """ - if type(valeur) != types.StringType: - return 0 - else: - return 1 - - def is_object_from(self,objet,classe): - """ - Retourne 1 si objet est une instance de la classe classe, 0 sinon - """ - convert = getattr(classe, '__convert__', None) - if convert is not None: - # classe verifie les valeurs - try: - v= convert(objet) - if v is None:return 0 - else:return 1 - except: - return 0 - if type(objet) != types.InstanceType : - return 0 - if isinstance(objet,classe) : - # On accepte les instances de la classe et des classes derivees - return 1 - - return 0 - - def verif_type(self,val=None,cr='non'): - """ - FONCTION : - Cette methode verifie que le type de l'argument val est en conformite avec celui - qui est declare dans la definition du mot cle simple. - Elle a plusieurs modes de fonctionnement liés à la valeur de cr. - Si cr vaut 'oui' : elle remplit le compte-rendu self.cr sinon elle ne le remplit pas. - PARAMETRE DE RETOUR : - Cette méthode retourne une valeur booléenne qui vaut 1 si le type de val est correct ou 0 sinon - - """ - try: - self.convert_type(val) - return 1 - except ValidException,e: - if cr == 'oui': self.cr.fatal(str(e)) - return 0 - - def isvalid_BAK(self,cr='non'): - """ - Cette méthode retourne un indicateur de validité de l'objet de type MCSIMP - - - 0 si l'objet est invalide - - 1 si l'objet est valide - - Le paramètre cr permet de paramétrer le traitement. Si cr == 'oui' - la méthode construit également un comte-rendu de validation - dans self.cr qui doit avoir été créé préalablement. - """ - if self.state == 'unchanged': - return self.valid - else: - valid = 1 - v=self.valeur - # verification presence - if self.isoblig() and v == None : - if cr == 'oui' : - self.cr.fatal(string.join(("Mot-clé : ",self.nom," obligatoire non valorisé"))) - valid = 0 - - if v is None: - valid=0 - if cr == 'oui' : - self.cr.fatal("None n'est pas une valeur autorisée") - else: - # type,into ... - valid = self.verif_type(val=v,cr=cr)*self.verif_into(cr=cr)*self.verif_card(cr=cr) - # - # On verifie les validateurs s'il y en a et si necessaire (valid == 1) - # - if valid and self.definition.validators: - try: - self.definition.validators.convert(self.valeur) - except ValidException,e: - if cr == 'oui' : - self.cr.fatal(string.join(("Mot-clé : ",self.nom,"devrait avoir ",self.definition.validators.info()))) - valid=0 - # fin des validateurs - # - self.set_valid(valid) - return self.valid - - def verif_typeihm(self,val,cr='non'): try : val.eval() diff --git a/Ihm/I_VALIDATOR.py b/Ihm/I_VALIDATOR.py index 1c94ece7..cd2f3b03 100644 --- a/Ihm/I_VALIDATOR.py +++ b/Ihm/I_VALIDATOR.py @@ -1 +1,22 @@ +# -*- coding: utf-8 -*- + from Noyau.N_VALIDATOR import * + +class Compulsory(Compulsory): + def has_into(self): + return 0 + def valide_liste_partielle(self,liste_courante=None): + return 1 + +class OrdList(OrdList): + def valide_liste_partielle(self,liste_courante=None): + """ + Méthode de validation de liste partielle pour le validateur OrdList + """ + try: + self.convert(liste_courante) + valid=1 + except: + valid=0 + return valid + -- 2.39.2