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
 
@@ -35,48 +35,24 @@ from kallithea.lib.utils2 import str2boo
 
from kallithea.model.db import RepoGroup, Repository, UserGroup, User
 
from kallithea.lib.exceptions import LdapImportError
 
from kallithea.config.routing import ADMIN_PREFIX
 
from kallithea.lib.auth import HasRepoGroupPermissionAny, HasPermissionAny
 

			




	
	
	
		
 
# silence warnings and pylint

			




	
	
	
		
 
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(

			




	
	
	
		
 
            empty=_('Value cannot be an empty list'),

			




	
	
	
		
 
            missing_value=_('Value cannot be an empty list'),

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
            value = aslist(value, ',')

			




	
	
		
 
@@ -95,102 +71,102 @@ def ValidUsername(edit=False, old_data=N

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'username_exists': _('Username "%(username)s" already exists'),

			




	
	
	
		
 
            'system_invalid_username':

			




	
	
	
		
 
                _('Username "%(username)s" cannot be used'),

			




	
	
	
		
 
            'invalid_username':

			




	
	
	
		
 
                _('Username may only contain alphanumeric characters '

			




	
	
	
		
 
                  '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):

			




	
	
	
		
 
        messages = dict(invalid=msg or _('The input is not valid'))

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidRepoUser():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_username': _('Username %(username)s is not valid')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    old_data = old_data or {}

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_group': _('Invalid user group name'),

			




	
	
	
		
 
            'group_exist': _('User group "%(usergroup)s" already exists'),

			




	
	
	
		
 
            'invalid_usergroup_name':

			




	
	
	
		
 
                _('user group name may only contain alphanumeric '

			




	
	
	
		
 
                  '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:

			




	
	
	
		
 
                old_id = old_data.get('users_group_id')

			




	
	
	
		
 
                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

			




	
	
	
		
 

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    old_data = old_data or {}

			




	
	
	
		
 

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
		
 
@@ -205,148 +181,148 @@ def ValidRepoGroup(edit=False, old_data=

			




	
	
	
		
 
            group_name = value.get('group_name')

			




	
	
	
		
 
            parent_group_id = value.get('parent_group_id')

			




	
	
	
		
 

			




	
	
	
		
 
            # slugify repo group just in case :)

			




	
	
	
		
 
            slug = repo_name_slug(group_name)

			




	
	
	
		
 

			




	
	
	
		
 
            # 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:

			




	
	
	
		
 
                old_gname = RepoGroup.get(old_data.get('group_id')).group_name

			




	
	
	
		
 

			




	
	
	
		
 
            if old_gname != group_name or not edit:

			




	
	
	
		
 

			




	
	
	
		
 
                # check group

			




	
	
	
		
 
                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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidPassword():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_password':

			




	
	
	
		
 
                _('Invalid characters (non-ascii) in password')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        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):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            '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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidPasswordsMatch(password_field, password_confirmation_field):

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidAuth():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_auth': _(u'Invalid username or password'),

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            from kallithea.lib import auth_modules

			




	
	
	
		
 

			




	
	
	
		
 
            password = value['password']

			




	
	
	
		
 
            username = value['username']

			




	
	
	
		
 

			




	
	
	
		
 
            # 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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidAuthToken():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        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 {}

			




	
	
	
		
 

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'invalid_repo_name':

			




	
	
	
		
 
                _('Repository name %(repo)s is not allowed'),

			




	
	
	
		
 
            'repository_exists':

			




	
	
		
 
@@ -376,49 +352,49 @@ def ValidRepoName(edit=False, old_data=N

			




	
	
	
		
 
            value['repo_name_full'] = repo_name_full

			




	
	
	
		
 
            value['group_path'] = group_path

			




	
	
	
		
 
            value['group_name'] = group_name

			




	
	
	
		
 
            return value

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidForkName(*args, **kwargs):

			




	
	
	
		
 
    return ValidRepoName(*args, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
		
 
@@ -472,42 +448,42 @@ def ValidCloneUri():

			




	
	
	
		
 
                                   'valid http, https, ssh, svn+http or svn+https URL'),

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            repo_type = value.get('repo_type')

			




	
	
	
		
 
            url = value.get('clone_uri')

			




	
	
	
		
 

			




	
	
	
		
 
            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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidForkType(old_data=None):

			




	
	
	
		
 
    old_data = old_data or {}

			




	
	
	
		
 

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def CanWriteGroup(old_data=None):

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'permission_denied': _("You don't have permissions "

			




	
	
	
		
 
                                   "to create repository in this group"),

			




	
	
	
		
 
            'permission_denied_root': _("no permission to create repository "

			




	
	
		
 
@@ -534,31 +510,31 @@ def CanWriteGroup(old_data=None):

			




	
	
	
		
 
            can_create_repos = HasPermissionAny('hg.admin', 'hg.create.repository')

			




	
	
	
		
 
            gid = (old_data['repo_group'].get('group_id')

			




	
	
	
		
 
                   if (old_data and 'repo_group' in old_data) else None)

			




	
	
	
		
 
            value_changed = gid != value

			




	
	
	
		
 
            new = not old_data

			




	
	
	
		
 
            # do check if we changed the value, there's a case that someone got

			




	
	
	
		
 
            # 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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def CanCreateGroup(can_create_in_root=False):

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'permission_denied': _("You don't have permissions "

			




	
	
	
		
 
                                   "to create a group in this location")

			




	
	
		
 
@@ -573,25 +549,25 @@ def CanCreateGroup(can_create_in_root=Fa

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            gr = RepoGroup.get(value)

			




	
	
	
		
 
            gr_name = gr.group_name if gr is not None else None # None means ROOT location

			




	
	
	
		
 

			




	
	
	
		
 
            if can_create_in_root and gr is None:

			




	
	
	
		
 
                #we can create in root, we're fine no validations required

			




	
	
	
		
 
                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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidPerms(type_='repo'):

			




	
	
	
		
 
    if type_ == 'repo_group':

			




	
	
	
		
 
        EMPTY_PERM = 'group.none'

			




	
	
	
		
 
    elif type_ == 'repo':

			




	
	
	
		
 
        EMPTY_PERM = 'repository.none'

			




	
	
		
 
@@ -652,25 +628,25 @@ def ValidPerms(type_='repo'):

			




	
	
	
		
 
                try:

			




	
	
	
		
 
                    if t is 'user':

			




	
	
	
		
 
                        self.user_db = User.query() \

			




	
	
	
		
 
                            .filter(User.active == True) \

			




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

			




	
	
	
		
 
                    if t is 'users_group':

			




	
	
	
		
 
                        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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidSettings():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
            # settings  form for users that are not admin

			




	
	
	
		
 
            # can't edit certain parameters, it's extra backup if they mangle

			




	
	
		
 
@@ -690,66 +666,66 @@ def ValidSettings():

			




	
	
	
		
 
            pass

			




	
	
	
		
 
    return _validator

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidPath():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def UniqSystemEmail(old_data=None):

			




	
	
	
		
 
    old_data = old_data or {}

			




	
	
	
		
 

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'email_taken': _('This email address is already in use')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        def _to_python(self, value, state):

			




	
	
	
		
 
            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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def ValidSystemEmail():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 
            'non_existing_email': _('Email address "%(email)s" not found')

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        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

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def LdapLibValidator():

			




	
	
	
		
 
    class _validator(formencode.validators.FancyValidator):

			




	
	
	
		
 
        messages = {

			




	
	
	
		
 

			




	
	
	
		
 
        }

			




	
	
		
 
@@ -851,21 +827,21 @@ def ValidAuthPlugins():

			




	
	
	
		
 
            # filter empty values

			




	
	
	
		
 
            return filter(lambda s: s not in [None, ''], value)

			




	
	
	
		
 

			




	
	
	
		
 
        def validate_python(self, value, state):

			




	
	
	
		
 
            from kallithea.lib import auth_modules

			




	
	
	
		
 
            module_list = value

			




	
	
	
		
 
            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)

			




	
	
	
		
 

			




	
	
	
		
 
    return _validator

			




        

    



    


    



    



      

      





    
    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.