Changeset - 81fdf2f62ef2
Parent rev.
Child rev.
[Not reviewed]
default
0 1 0
Thomas De Schampheleire - 9 years ago 2016-12-04 20:22:23
thomas.de.schampheleire@gmail.com
validators: remove unneeded M/StateObj classes

The M class is actually a wrapper around formencode.api.Validator.message,
inserting a translator into the 'state' object. Setting a translator into
the state object is indeed what is mentioned in the formencode docs.

But, if you work this way, the custom state should be set both for custom
validators, as well as for validators that are simple wrappers around
formencode's default validators (for example wrappers that just set a custom
message string). And the latter is what Kallithea is currently _not_ doing.

Also, when using formencode.api.Validator.message correctly, you should not
use the translator function _ on your validator strings manually.

Remove the inconsistency in Kallithea validators as follows:
- remove M and StateObj classes
- replace the usage of M by direct calls to self.message (which is now no
longer in charge of translating but simply of mapping a keyword onto the
right message)
- translation will be done by explicit _ calls at Kallithea side, so that
formencode directly receives translated strings.
1 file changed with 30 insertions and 54 deletions:
kallithea/model/validators.py
30
54
0 comments (0 inline, 0 general)
kallithea/model/validators.py
➞
Show inline comments
 
@@ -41,36 +41,12 @@ from kallithea.lib.auth import HasRepoGr
 
UnicodeString, OneOf, Int, Number, Regex, Email, Bool, StringBoolean, Set, \
 
    NotEmpty, IPAddress, CIDR, String, FancyValidator
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class StateObj(object):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    this is needed to translate the messages using _() in validators

			




	
	
	
		
 
    """

			




	
	
	
		
 
    _ = staticmethod(_)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def M(self, key, state=None, **kwargs):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    returns string from self.message based on given key,

			




	
	
	
		
 
    passed kw params are used to substitute %(named)s params inside

			




	
	
	
		
 
    translated strings

			




	
	
	
		
 

			




	
	
	
		
 
    :param msg:

			




	
	
	
		
 
    :param state:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    if state is None:

			




	
	
	
		
 
        state = StateObj()

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        state._ = staticmethod(_)

			




	
	
	
		
 
    #inject validator into state object

			




	
	
	
		
 
    return self.message(key, state, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def UniqueListFromString():

			




	
	
	
		
 
    class _UniqueListFromString(formencode.FancyValidator):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Split value on ',' and make unique while preserving order

			




	
	
	
		
 
        """

			




	
	
	
		
 
        messages = dict(

			




	
	
		
 
@@ -101,26 +77,26 @@ def ValidUsername(edit=False, old_data=N

			




	
	
	
		
 
                  'underscores, periods or dashes and must begin with an '

			




	
	
	
		
 
                  'alphanumeric character or underscore')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            if value in ['default', 'new_user']:

			




	
	
	
		
 
                msg = M(self, 'system_invalid_username', state, username=value)

			




	
	
	
		
 
                msg = self.message('system_invalid_username', state, username=value)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state)

			




	
	
	
		
 
            #check if user is unique

			




	
	
	
		
 
            old_un = None

			




	
	
	
		
 
            if edit:

			




	
	
	
		
 
                old_un = User.get(old_data.get('user_id')).username

			




	
	
	
		
 

			




	
	
	
		
 
            if old_un != value or not edit:

			




	
	
	
		
 
                if User.get_by_username(value, case_insensitive=True):

			




	
	
	
		
 
                    msg = M(self, 'username_exists', state, username=value)

			




	
	
	
		
 
                    msg = self.message('username_exists', state, username=value)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state)

			




	
	
	
		
 

			




	
	
	
		
 
            if re.match(r'^[a-zA-Z0-9\_]{1}[a-zA-Z0-9\-\_\.]*$', value) is None:

			




	
	
	
		
 
                msg = M(self, 'invalid_username', state)

			




	
	
	
		
 
                msg = self.message('invalid_username', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state)

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidRegex(msg=None):

			




	
	
	
		
 
    class _validator(formencode.validators.Regex):

			




	
	
		
 
@@ -136,13 +112,13 @@ def ValidRepoUser():

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                User.query().filter(User.active == True) \

			




	
	
	
		
 
                    .filter(User.username == value).one()

			




	
	
	
		
 
            except sqlalchemy.exc.InvalidRequestError: # NoResultFound/MultipleResultsFound

			




	
	
	
		
 
                msg = M(self, 'invalid_username', state, username=value)

			




	
	
	
		
 
                msg = self.message('invalid_username', state, username=value)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(username=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
		
 
@@ -158,13 +134,13 @@ def ValidUserGroup(edit=False, old_data=

			




	
	
	
		
 
                  'characters underscores, periods or dashes and must begin '

			




	
	
	
		
 
                  'with alphanumeric character')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            if value in ['default']:

			




	
	
	
		
 
                msg = M(self, 'invalid_group', state)

			




	
	
	
		
 
                msg = self.message('invalid_group', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(users_group_name=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 
            #check if group is unique

			




	
	
	
		
 
            old_ugname = None

			




	
	
	
		
 
            if edit:

			




	
	
		
 
@@ -172,19 +148,19 @@ def ValidUserGroup(edit=False, old_data=

			




	
	
	
		
 
                old_ugname = UserGroup.get(old_id).users_group_name

			




	
	
	
		
 

			




	
	
	
		
 
            if old_ugname != value or not edit:

			




	
	
	
		
 
                is_existing_group = UserGroup.get_by_group_name(value,

			




	
	
	
		
 
                                                        case_insensitive=True)

			




	
	
	
		
 
                if is_existing_group:

			




	
	
	
		
 
                    msg = M(self, 'group_exist', state, usergroup=value)

			




	
	
	
		
 
                    msg = self.message('group_exist', state, usergroup=value)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(users_group_name=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 

			




	
	
	
		
 
            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

			




	
	
	
		
 
                msg = M(self, 'invalid_usergroup_name', state)

			




	
	
	
		
 
                msg = self.message('invalid_usergroup_name', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(users_group_name=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
		
 
@@ -211,13 +187,13 @@ def ValidRepoGroup(edit=False, old_data=

			




	
	
	
		
 
            # check for parent of self

			




	
	
	
		
 
            parent_of_self = lambda: (

			




	
	
	
		
 
                old_data['group_id'] == parent_group_id

			




	
	
	
		
 
                if parent_group_id else False

			




	
	
	
		
 
            )

			




	
	
	
		
 
            if edit and parent_of_self():

			




	
	
	
		
 
                msg = M(self, 'parent_group_id', state)

			




	
	
	
		
 
                msg = self.message('parent_group_id', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(parent_group_id=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 

			




	
	
	
		
 
            old_gname = None

			




	
	
	
		
 
            if edit:

			




	
	
		
 
@@ -229,24 +205,24 @@ def ValidRepoGroup(edit=False, old_data=

			




	
	
	
		
 
                gr = RepoGroup.query() \

			




	
	
	
		
 
                      .filter(RepoGroup.group_name == slug) \

			




	
	
	
		
 
                      .filter(RepoGroup.parent_group_id == parent_group_id) \

			




	
	
	
		
 
                      .scalar()

			




	
	
	
		
 

			




	
	
	
		
 
                if gr is not None:

			




	
	
	
		
 
                    msg = M(self, 'group_exists', state, group_name=slug)

			




	
	
	
		
 
                    msg = self.message('group_exists', state, group_name=slug)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                            error_dict=dict(group_name=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 

			




	
	
	
		
 
                # check for same repo

			




	
	
	
		
 
                repo = Repository.query() \

			




	
	
	
		
 
                      .filter(Repository.repo_name == slug) \

			




	
	
	
		
 
                      .scalar()

			




	
	
	
		
 

			




	
	
	
		
 
                if repo is not None:

			




	
	
	
		
 
                    msg = M(self, 'repo_exists', state, group_name=slug)

			




	
	
	
		
 
                    msg = self.message('repo_exists', state, group_name=slug)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                            error_dict=dict(group_name=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
		
 
@@ -259,13 +235,13 @@ def ValidPassword():

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                (value or '').decode('ascii')

			




	
	
	
		
 
            except UnicodeError:

			




	
	
	
		
 
                msg = M(self, 'invalid_password', state)

			




	
	
	
		
 
                msg = self.message('invalid_password', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,)

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidOldPassword(username):

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
		
 
@@ -273,13 +249,13 @@ def ValidOldPassword(username):

			




	
	
	
		
 
            'invalid_password': _('Invalid old password')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            from kallithea.lib import auth_modules

			




	
	
	
		
 
            if auth_modules.authenticate(username, value, '') is None:

			




	
	
	
		
 
                msg = M(self, 'invalid_password', state)

			




	
	
	
		
 
                msg = self.message('invalid_password', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(current_password=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -288,13 +264,13 @@ def ValidPasswordsMatch(password_field, 

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'password_mismatch': _('Passwords do not match'),

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            if value.get(password_field) != value[password_confirmation_field]:

			




	
	
	
		
 
                msg = M(self, 'password_mismatch', state)

			




	
	
	
		
 
                msg = self.message('password_mismatch', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                     error_dict={password_field:msg, password_confirmation_field: msg}

			




	
	
	
		
 
                )

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -313,19 +289,19 @@ def ValidAuth():

			




	
	
	
		
 
            # authenticate returns unused dict but has called

			




	
	
	
		
 
            # plugin._authenticate which has create_or_update'ed the username user in db

			




	
	
	
		
 
            if auth_modules.authenticate(username, password) is None:

			




	
	
	
		
 
                user = User.get_by_username_or_email(username)

			




	
	
	
		
 
                if user and not user.active:

			




	
	
	
		
 
                    log.warning('user %s is disabled', username)

			




	
	
	
		
 
                    msg = M(self, 'invalid_auth', state)

			




	
	
	
		
 
                    msg = self.message('invalid_auth', state)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(username=' ', password=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    log.warning('user %s failed to authenticate', username)

			




	
	
	
		
 
                    msg = M(self, 'invalid_auth', state)

			




	
	
	
		
 
                    msg = self.message('invalid_auth', state)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(username=' ', password=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -334,13 +310,13 @@ def ValidAuthToken():

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_token': _('Token mismatch')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            if value != authentication_token():

			




	
	
	
		
 
                msg = M(self, 'invalid_token', state)

			




	
	
	
		
 
                msg = self.message('invalid_token', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state)

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidRepoName(edit=False, old_data=None):

			




	
	
	
		
 
    old_data = old_data or {}

			




	
	
		
 
@@ -382,37 +358,37 @@ def ValidRepoName(edit=False, old_data=N

			




	
	
	
		
 
            repo_name = value.get('repo_name')

			




	
	
	
		
 
            repo_name_full = value.get('repo_name_full')

			




	
	
	
		
 
            group_path = value.get('group_path')

			




	
	
	
		
 
            group_name = value.get('group_name')

			




	
	
	
		
 

			




	
	
	
		
 
            if repo_name in [ADMIN_PREFIX, '']:

			




	
	
	
		
 
                msg = M(self, 'invalid_repo_name', state, repo=repo_name)

			




	
	
	
		
 
                msg = self.message('invalid_repo_name', state, repo=repo_name)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(repo_name=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 

			




	
	
	
		
 
            rename = old_data.get('repo_name') != repo_name_full

			




	
	
	
		
 
            create = not edit

			




	
	
	
		
 
            if rename or create:

			




	
	
	
		
 

			




	
	
	
		
 
                if group_path != '':

			




	
	
	
		
 
                    if Repository.get_by_repo_name(repo_name_full):

			




	
	
	
		
 
                        msg = M(self, 'repository_in_group_exists', state,

			




	
	
	
		
 
                        msg = self.message('repository_in_group_exists', state,

			




	
	
	
		
 
                                repo=repo_name, group=group_name)

			




	
	
	
		
 
                        raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                            error_dict=dict(repo_name=msg)

			




	
	
	
		
 
                        )

			




	
	
	
		
 
                elif RepoGroup.get_by_group_name(repo_name_full):

			




	
	
	
		
 
                        msg = M(self, 'same_group_exists', state,

			




	
	
	
		
 
                        msg = self.message('same_group_exists', state,

			




	
	
	
		
 
                                repo=repo_name)

			




	
	
	
		
 
                        raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                            error_dict=dict(repo_name=msg)

			




	
	
	
		
 
                        )

			




	
	
	
		
 

			




	
	
	
		
 
                elif Repository.get_by_repo_name(repo_name_full):

			




	
	
	
		
 
                        msg = M(self, 'repository_exists', state,

			




	
	
	
		
 
                        msg = self.message('repository_exists', state,

			




	
	
	
		
 
                                repo=repo_name)

			




	
	
	
		
 
                        raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                            error_dict=dict(repo_name=msg)

			




	
	
	
		
 
                        )

			




	
	
	
		
 
            return value

			




	
	
	
		
 
    return _validator

			




	
	
		
 
@@ -478,13 +454,13 @@ def ValidCloneUri():

			




	
	
	
		
 

			




	
	
	
		
 
            if url and url != value.get('clone_uri_hidden'):

			




	
	
	
		
 
                try:

			




	
	
	
		
 
                    url_handler(repo_type, url, make_ui('db', clear_session=False))

			




	
	
	
		
 
                except Exception:

			




	
	
	
		
 
                    log.exception('URL validation failed')

			




	
	
	
		
 
                    msg = M(self, 'clone_uri')

			




	
	
	
		
 
                    msg = self.message('clone_uri', state)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(clone_uri=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -495,13 +471,13 @@ def ValidForkType(old_data=None):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_fork_type': _('Fork has to be the same type as parent')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            if old_data['repo_type'] != value:

			




	
	
	
		
 
                msg = M(self, 'invalid_fork_type', state)

			




	
	
	
		
 
                msg = self.message('invalid_fork_type', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(repo_type=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -540,19 +516,19 @@ def CanWriteGroup(old_data=None):

			




	
	
	
		
 
            # revoked write permissions to a repository, he still created, we

			




	
	
	
		
 
            # don't need to check permission if he didn't change the value of

			




	
	
	
		
 
            # groups in form box

			




	
	
	
		
 
            if value_changed or new:

			




	
	
	
		
 
                #parent group need to be existing

			




	
	
	
		
 
                if gr and forbidden:

			




	
	
	
		
 
                    msg = M(self, 'permission_denied', state)

			




	
	
	
		
 
                    msg = self.message('permission_denied', state)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(repo_type=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 
                ## check if we can write to root location !

			




	
	
	
		
 
                elif gr is None and not can_create_repos():

			




	
	
	
		
 
                    msg = M(self, 'permission_denied_root', state)

			




	
	
	
		
 
                    msg = self.message('permission_denied_root', state)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(repo_type=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
		
 
@@ -579,13 +555,13 @@ def CanCreateGroup(can_create_in_root=Fa

			




	
	
	
		
 
                return

			




	
	
	
		
 

			




	
	
	
		
 
            forbidden_in_root = gr is None and not can_create_in_root

			




	
	
	
		
 
            val = HasRepoGroupPermissionAny('group.admin')

			




	
	
	
		
 
            forbidden = not val(gr_name, 'can create group validator')

			




	
	
	
		
 
            if forbidden_in_root or forbidden:

			




	
	
	
		
 
                msg = M(self, 'permission_denied', state)

			




	
	
	
		
 
                msg = self.message('permission_denied', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(parent_group_id=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
		
 
@@ -658,13 +634,13 @@ def ValidPerms(type_='repo'):

			




	
	
	
		
 
                        self.user_db = UserGroup.query() \

			




	
	
	
		
 
                            .filter(UserGroup.users_group_active == True) \

			




	
	
	
		
 
                            .filter(UserGroup.users_group_name == k).one()

			




	
	
	
		
 

			




	
	
	
		
 
                except Exception:

			




	
	
	
		
 
                    log.exception('Updated permission failed')

			




	
	
	
		
 
                    msg = M(self, 'perm_new_member_type', state)

			




	
	
	
		
 
                    msg = self.message('perm_new_member_type', state)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(perm_new_member_name=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 
            return value

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
		
 
@@ -696,13 +672,13 @@ def ValidPath():

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_path': _('This is not a valid path')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            if not os.path.isdir(value):

			




	
	
	
		
 
                msg = M(self, 'invalid_path', state)

			




	
	
	
		
 
                msg = self.message('invalid_path', state)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(paths_root_path=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -718,13 +694,13 @@ def UniqSystemEmail(old_data=None):

			




	
	
	
		
 
            return value.lower()

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            if (old_data.get('email') or '').lower() != value:

			




	
	
	
		
 
                user = User.get_by_email(value)

			




	
	
	
		
 
                if user is not None:

			




	
	
	
		
 
                    msg = M(self, 'email_taken', state)

			




	
	
	
		
 
                    msg = self.message('email_taken', state)

			




	
	
	
		
 
                    raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                        error_dict=dict(email=msg)

			




	
	
	
		
 
                    )

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -737,13 +713,13 @@ def ValidSystemEmail():

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
            return value.lower()

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            user = User.get_by_email(value)

			




	
	
	
		
 
            if user is None:

			




	
	
	
		
 
                msg = M(self, 'non_existing_email', state, email=value)

			




	
	
	
		
 
                msg = self.message('non_existing_email', state, email=value)

			




	
	
	
		
 
                raise formencode.Invalid(msg, value, state,

			




	
	
	
		
 
                    error_dict=dict(email=msg)

			




	
	
	
		
 
                )

			




	
	
	
		
 

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
		
 
@@ -857,13 +833,13 @@ def ValidAuthPlugins():

			




	
	
	
		
 
            unique_names = {}

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                for module in module_list:

			




	
	
	
		
 
                    plugin = auth_modules.loadplugin(module)

			




	
	
	
		
 
                    plugin_name = plugin.name

			




	
	
	
		
 
                    if plugin_name in unique_names:

			




	
	
	
		
 
                        msg = M(self, 'import_duplicate', state,

			




	
	
	
		
 
                        msg = self.message('import_duplicate', state,

			




	
	
	
		
 
                                loaded=unique_names[plugin_name],

			




	
	
	
		
 
                                next_to_load=plugin_name)

			




	
	
	
		
 
                        raise formencode.Invalid(msg, value, state)

			




	
	
	
		
 
                    unique_names[plugin_name] = plugin

			




	
	
	
		
 
            except (ImportError, AttributeError, TypeError) as e:

			




	
	
	
		
 
                raise formencode.Invalid(str(e), value, state)

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.