kallithea: rhodecode/model/forms.py comparison

comparison rhodecode/model/forms.py @ 2031:82a88013a3fd

merge 1.3 into stable

author	Marcin Kuzminski <marcin@python-works.com>
date	Sun, 26 Feb 2012 17:25:09 +0200
parents	0f463fa8b260 7e979933ffec
children	9ab21c5ddb84

comparison

equal deleted inserted replaced

-:ab0e122b38a7
+:82a88013a3fd
 from rhodecode.config.routing import ADMIN_PREFIX
 from rhodecode.lib.utils import repo_name_slug
 from rhodecode.lib.auth import authenticate, get_crypt_password
 from rhodecode.lib.exceptions import LdapImportError
-from rhodecode.model.user import UserModel
+from rhodecode.model.db import User, UsersGroup, RepoGroup, Repository
-from rhodecode.model.repo import RepoModel
-from rhodecode.model.db import User, UsersGroup, Group, Repository
 from rhodecode import BACKENDS
 log = logging.getLogger(__name__)
 #this is needed to translate the messages using _() in validators
 class State_obj(object):
 _ = staticmethod(_)
 #==============================================================================
 # VALIDATORS
 #==============================================================================
 class ValidAuthToken(formencode.validators.FancyValidator):
-messages = {'invalid_token':_('Token mismatch')}
+messages = {'invalid_token': _('Token mismatch')}
 def validate_python(self, value, state):
 if value != authentication_token():
-raise formencode.Invalid(self.message('invalid_token', state,
+raise formencode.Invalid(
-search_number=value), value, state)
+self.message('invalid_token',
+state, search_number=value),
+value,
+state
+)
 def ValidUsername(edit, old_data):
 class _ValidUsername(formencode.validators.FancyValidator):
 def validate_python(self, value, state):
 if value in ['default', 'new_user']:
 raise formencode.Invalid(_('Invalid username'), value, state)
 #check if user is unique
 old_un = None
 if edit:
-old_un = UserModel().get(old_data.get('user_id')).username
+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):
 raise formencode.Invalid(_('This username already '
 'exists') , value, state)
 if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:
-raise formencode.Invalid(_('Username may only contain '
+raise formencode.Invalid(
-'alphanumeric characters '
+_('Username may only contain alphanumeric characters '
-'underscores, periods or dashes '
+'underscores, periods or dashes and must begin with '
-'and must begin with alphanumeric '
+'alphanumeric character'),
-'character'), value, state)
+value,
+state
+)
 return _ValidUsername
 def ValidUsersGroup(edit, old_data):
 if old_ugname != value or not edit:
 if UsersGroup.get_by_group_name(value, cache=False,
 case_insensitive=True):
 raise formencode.Invalid(_('This users group '
-'already exists') , value,
+'already exists'), value,
 state)
 if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:
-raise formencode.Invalid(_('Group name may only contain '
+raise formencode.Invalid(
-'alphanumeric characters '
+_('RepoGroup name may only contain  alphanumeric characters '
-'underscores, periods or dashes '
+'underscores, periods or dashes and must begin with '
-'and must begin with alphanumeric '
+'alphanumeric character'),
-'character'), value, state)
+value,
+state
+)
 return _ValidUsersGroup
 def ValidReposGroup(edit, old_data):
 raise formencode.Invalid('', value, state,
 error_dict=e_dict)
 old_gname = None
 if edit:
-old_gname = Group.get(
+old_gname = RepoGroup.get(old_data.get('group_id')).group_name
-old_data.get('group_id')).group_name
 if old_gname != group_name or not edit:
 # check group
-gr = Group.query()\
+gr = RepoGroup.query()\
-.filter(Group.group_name == slug)\
+.filter(RepoGroup.group_name == slug)\
-.filter(Group.group_parent_id == group_parent_id)\
+.filter(RepoGroup.group_parent_id == group_parent_id)\
 .scalar()
 if gr:
 e_dict = {
 'group_name': _('This group already exists')
 raise formencode.Invalid('', value, state,
 error_dict=e_dict)
 return _ValidReposGroup
 class ValidPassword(formencode.validators.FancyValidator):
 def to_python(self, value, state):
-if value:
+if not value:
+return
-if value.get('password'):
-try:
+if value.get('password'):
-value['password'] = get_crypt_password(value['password'])
+try:
-except UnicodeEncodeError:
+value['password'] = get_crypt_password(value['password'])
-e_dict = {'password':_('Invalid characters in password')}
+except UnicodeEncodeError:
-raise formencode.Invalid('', value, state, error_dict=e_dict)
+e_dict = {'password': _('Invalid characters in password')}
+raise formencode.Invalid('', value, state, error_dict=e_dict)
-if value.get('password_confirmation'):
-try:
+if value.get('password_confirmation'):
-value['password_confirmation'] = \
+try:
-get_crypt_password(value['password_confirmation'])
+value['password_confirmation'] = \
-except UnicodeEncodeError:
+get_crypt_password(value['password_confirmation'])
-e_dict = {'password_confirmation':_('Invalid characters in password')}
+except UnicodeEncodeError:
-raise formencode.Invalid('', value, state, error_dict=e_dict)
+e_dict = {
+'password_confirmation': _('Invalid characters in password')
-if value.get('new_password'):
+}
-try:
+raise formencode.Invalid('', value, state, error_dict=e_dict)
-value['new_password'] = \
-get_crypt_password(value['new_password'])
+if value.get('new_password'):
-except UnicodeEncodeError:
+try:
-e_dict = {'new_password':_('Invalid characters in password')}
+value['new_password'] = \
-raise formencode.Invalid('', value, state, error_dict=e_dict)
+get_crypt_password(value['new_password'])
+except UnicodeEncodeError:
-return value
+e_dict = {'new_password': _('Invalid characters in password')}
+raise formencode.Invalid('', value, state, error_dict=e_dict)
+return value
 class ValidPasswordsMatch(formencode.validators.FancyValidator):
 def validate_python(self, value, state):
 pass_val = value.get('password') or value.get('new_password')
 if pass_val != value['password_confirmation']:
 e_dict = {'password_confirmation':
 _('Passwords do not match')}
 raise formencode.Invalid('', value, state, error_dict=e_dict)
 class ValidAuth(formencode.validators.FancyValidator):
 messages = {
 'invalid_password':_('invalid password'),
 'invalid_login':_('invalid user name'),
 'disabled_account':_('Your account is disabled')
 }
 # error mapping
-e_dict = {'username':messages['invalid_login'],
+e_dict = {'username': messages['invalid_login'],
-'password':messages['invalid_password']}
+'password': messages['invalid_password']}
-e_dict_disable = {'username':messages['disabled_account']}
+e_dict_disable = {'username': messages['disabled_account']}
 def validate_python(self, value, state):
 password = value['password']
 username = value['username']
 user = User.get_by_username(username)
 if authenticate(username, password):
 return value
 else:
 if user and user.active is False:
-log.warning('user %s is disabled', username)
+log.warning('user %s is disabled' % username)
-raise formencode.Invalid(self.message('disabled_account',
+raise formencode.Invalid(
-state=State_obj),
+self.message('disabled_account',
-value, state,
+state=State_obj),
-error_dict=self.e_dict_disable)
+value, state,
+error_dict=self.e_dict_disable
+)
 else:
-log.warning('user %s not authenticated', username)
+log.warning('user %s failed to authenticate' % username)
-raise formencode.Invalid(self.message('invalid_password',
+raise formencode.Invalid(
-state=State_obj), value, state,
+self.message('invalid_password',
-error_dict=self.e_dict)
+state=State_obj), value, state,
+error_dict=self.e_dict
+)
 class ValidRepoUser(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 try:
 except Exception:
 raise formencode.Invalid(_('This username is not valid'),
 value, state)
 return value
 def ValidRepoName(edit, old_data):
 class _ValidRepoName(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 repo_name = value.get('repo_name')
 slug = repo_name_slug(repo_name)
 if slug in [ADMIN_PREFIX, '']:
 e_dict = {'repo_name': _('This repository name is disallowed')}
 raise formencode.Invalid('', value, state, error_dict=e_dict)
 if value.get('repo_group'):
-gr = Group.get(value.get('repo_group'))
+gr = RepoGroup.get(value.get('repo_group'))
 group_path = gr.full_path
 # value needs to be aware of group name in order to check
 # db key This is an actual just the name to store in the
 # database
-repo_name_full = group_path + Group.url_sep() + repo_name
+repo_name_full = group_path + RepoGroup.url_sep() + repo_name
 else:
 group_path = ''
 repo_name_full = repo_name
 value['repo_name_full'] = repo_name_full
 rename = old_data.get('repo_name') != repo_name_full
 create = not edit
 if  rename or create:
 if group_path != '':
-if RepoModel().get_by_repo_name(repo_name_full,):
+if Repository.get_by_repo_name(repo_name_full):
-e_dict = {'repo_name':_('This repository already '
+e_dict = {
-'exists in a group "%s"') %
+'repo_name': _('This repository already exists in '
-gr.group_name}
+'a group "%s"') % gr.group_name
+}
 raise formencode.Invalid('', value, state,
 error_dict=e_dict)
-elif Group.get_by_group_name(repo_name_full):
+elif RepoGroup.get_by_group_name(repo_name_full):
-e_dict = {'repo_name':_('There is a group with this'
+e_dict = {
-' name already "%s"') %
+'repo_name': _('There is a group with this name '
-repo_name_full}
+'already "%s"') % repo_name_full
+}
 raise formencode.Invalid('', value, state,
 error_dict=e_dict)
-elif RepoModel().get_by_repo_name(repo_name_full):
+elif Repository.get_by_repo_name(repo_name_full):
-e_dict = {'repo_name':_('This repository '
+e_dict = {'repo_name': _('This repository '
 'already exists')}
 raise formencode.Invalid('', value, state,
 error_dict=e_dict)
 return value
 return _ValidRepoName
-def ValidForkName():
-class _ValidForkName(formencode.validators.FancyValidator):
+def ValidForkName(*args, **kwargs):
-def to_python(self, value, state):
+return ValidRepoName(*args, **kwargs)
-repo_name = value.get('fork_name')
-slug = repo_name_slug(repo_name)
-if slug in [ADMIN_PREFIX, '']:
-e_dict = {'repo_name': _('This repository name is disallowed')}
-raise formencode.Invalid('', value, state, error_dict=e_dict)
-if RepoModel().get_by_repo_name(repo_name):
-e_dict = {'fork_name':_('This repository '
-'already exists')}
-raise formencode.Invalid('', value, state,
-error_dict=e_dict)
-return value
-return _ValidForkName
 def SlugifyName():
 class _SlugifyName(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 return repo_name_slug(value)
 return _SlugifyName
 def ValidCloneUri():
 from mercurial.httprepo import httprepository, httpsrepository
 from rhodecode.lib.utils import make_ui
 if not value:
 pass
 elif value.startswith('https'):
 try:
 httpsrepository(make_ui('db'), value).capabilities
-except Exception, e:
+except Exception:
 log.error(traceback.format_exc())
 raise formencode.Invalid(_('invalid clone url'), value,
 state)
 elif value.startswith('http'):
 try:
 httprepository(make_ui('db'), value).capabilities
-except Exception, e:
+except Exception:
 log.error(traceback.format_exc())
 raise formencode.Invalid(_('invalid clone url'), value,
 state)
 else:
 raise formencode.Invalid(_('Invalid clone url, provide a '
 state)
 return value
 return _ValidCloneUri
 def ValidForkType(old_data):
 class _ValidForkType(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 if old_data['repo_type'] != value:
 'type as original'), value, state)
 return value
 return _ValidForkType
-class ValidPerms(formencode.validators.FancyValidator):
-messages = {'perm_new_member_name':_('This username or users group name'
+def ValidPerms(type_='repo'):
-' is not valid')}
+if type_ == 'group':
+EMPTY_PERM = 'group.none'
+elif type_ == 'repo':
+EMPTY_PERM = 'repository.none'
+class _ValidPerms(formencode.validators.FancyValidator):
+messages = {
+'perm_new_member_name':
+_('This username or users group name is not valid')
+}
+def to_python(self, value, state):
+perms_update = []
+perms_new = []
+# build a list of permission to update and new permission to create
+for k, v in value.items():
+# means new added member to permissions
+if k.startswith('perm_new_member'):
+new_perm = value.get('perm_new_member', False)
+new_member = value.get('perm_new_member_name', False)
+new_type = value.get('perm_new_member_type')
+if new_member and new_perm:
+if (new_member, new_perm, new_type) not in perms_new:
+perms_new.append((new_member, new_perm, new_type))
+elif k.startswith('u_perm_') or k.startswith('g_perm_'):
+member = k[7:]
+t = {'u': 'user',
+'g': 'users_group'
+}[k[0]]
+if member == 'default':
+if value.get('private'):
+# set none for default when updating to private repo
+v = EMPTY_PERM
+perms_update.append((member, v, t))
+value['perms_updates'] = perms_update
+value['perms_new'] = perms_new
+# update permissions
+for k, v, t in perms_new:
+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 = UsersGroup.query()\
+.filter(UsersGroup.users_group_active == True)\
+.filter(UsersGroup.users_group_name == k).one()
+except Exception:
+msg = self.message('perm_new_member_name',
+state=State_obj)
+raise formencode.Invalid(
+msg, value, state, error_dict={'perm_new_member_name': msg}
+)
+return value
+return _ValidPerms
+class ValidSettings(formencode.validators.FancyValidator):
 def to_python(self, value, state):
-perms_update = []
+# settings  form can't edit user
-perms_new = []
+if 'user' in value:
-#build a list of permission to update and new permission to create
+del['value']['user']
-for k, v in value.items():
-#means new added member to permissions
-if k.startswith('perm_new_member'):
-new_perm = value.get('perm_new_member', False)
-new_member = value.get('perm_new_member_name', False)
-new_type = value.get('perm_new_member_type')
-if new_member and new_perm:
-if (new_member, new_perm, new_type) not in perms_new:
-perms_new.append((new_member, new_perm, new_type))
-elif k.startswith('u_perm_') or k.startswith('g_perm_'):
-member = k[7:]
-t = {'u':'user',
-'g':'users_group'}[k[0]]
-if member == 'default':
-if value['private']:
-#set none for default when updating to private repo
-v = 'repository.none'
-perms_update.append((member, v, t))
-value['perms_updates'] = perms_update
-value['perms_new'] = perms_new
-#update permissions
-for k, v, t in perms_new:
-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 = UsersGroup.query()\
-.filter(UsersGroup.users_group_active == True)\
-.filter(UsersGroup.users_group_name == k).one()
-except Exception:
-msg = self.message('perm_new_member_name',
-state=State_obj)
-raise formencode.Invalid(msg, value, state,
-error_dict={'perm_new_member_name':msg})
 return value
-class ValidSettings(formencode.validators.FancyValidator):
-def to_python(self, value, state):
-#settings  form can't edit user
-if value.has_key('user'):
-del['value']['user']
-return value
 class ValidPath(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 if not os.path.isdir(value):
 msg = _('This is not a valid path')
 raise formencode.Invalid(msg, value, state,
-error_dict={'paths_root_path':msg})
+error_dict={'paths_root_path': msg})
 return value
 def UniqSystemEmail(old_data):
 class _UniqSystemEmail(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 value = value.lower()
-if old_data.get('email') != value:
+if old_data.get('email', '').lower() != value:
-user = User.query().filter(User.email == value).scalar()
+user = User.get_by_email(value, case_insensitive=True)
 if user:
 raise formencode.Invalid(
-_("This e-mail address is already taken"),
+_("This e-mail address is already taken"), value, state
-value, state)
+)
 return value
 return _UniqSystemEmail
 class ValidSystemEmail(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 value = value.lower()
-user = User.query().filter(User.email == value).scalar()
+user = User.get_by_email(value, case_insensitive=True)
 if  user is None:
-raise formencode.Invalid(_("This e-mail address doesn't exist.") ,
+raise formencode.Invalid(
-value, state)
+_("This e-mail address doesn't exist."), value, state
+)
 return value
 class LdapLibValidator(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 import ldap
 except ImportError:
 raise LdapImportError
 return value
 class AttrLoginValidator(formencode.validators.FancyValidator):
 def to_python(self, value, state):
 if not value or not isinstance(value, (str, unicode)):
-raise formencode.Invalid(_("The LDAP Login attribute of the CN "
+raise formencode.Invalid(
-"must be specified - this is the name "
+_("The LDAP Login attribute of the CN must be specified - "
-"of the attribute that is equivalent "
+"this is the name of the attribute that is equivalent "
-"to 'username'"),
+"to 'username'"), value, state
-value, state)
+)
 return value
-#===============================================================================
+#==============================================================================
 # FORMS
-#===============================================================================
+#==============================================================================
 class LoginForm(formencode.Schema):
 allow_extra_fields = True
 filter_extra_fields = True
 username = UnicodeString(
 strip=True,
 min=1,
 not_empty=True,
 messages={
-'empty':_('Please enter a login'),
+'empty': _('Please enter a login'),
-'tooShort':_('Enter a value %(min)i characters long or more')}
+'tooShort': _('Enter a value %(min)i characters long or more')}
 )
 password = UnicodeString(
 strip=True,
 min=3,
 not_empty=True,
 messages={
-'empty':_('Please enter a password'),
+'empty': _('Please enter a password'),
-'tooShort':_('Enter %(min)i characters or more')}
+'tooShort': _('Enter %(min)i characters or more')}
 )
+remember = StringBoolean(if_missing=False)
 chained_validators = [ValidAuth]
 def UserForm(edit=False, old_data={}):
 class _UserForm(formencode.Schema):
 allow_extra_fields = True
 filter_extra_fields = True
 username = All(UnicodeString(strip=True, min=1, not_empty=True),
 ValidUsername(edit, old_data))
 if edit:
 new_password = All(UnicodeString(strip=True, min=6, not_empty=False))
-password_confirmation = All(UnicodeString(strip=True, min=6, not_empty=False))
+password_confirmation = All(UnicodeString(strip=True, min=6,
+not_empty=False))
 admin = StringBoolean(if_missing=False)
 else:
 password = All(UnicodeString(strip=True, min=6, not_empty=True))
-password_confirmation = All(UnicodeString(strip=True, min=6, not_empty=False))
+password_confirmation = All(UnicodeString(strip=True, min=6,
+not_empty=False))
 active = StringBoolean(if_missing=False)
-name = UnicodeString(strip=True, min=1, not_empty=True)
+name = UnicodeString(strip=True, min=1, not_empty=False)
-lastname = UnicodeString(strip=True, min=1, not_empty=True)
+lastname = UnicodeString(strip=True, min=1, not_empty=False)
 email = All(Email(not_empty=True), UniqSystemEmail(old_data))
 chained_validators = [ValidPasswordsMatch, ValidPassword]
 return _UserForm
 testValueList=True,
 if_missing=None, not_empty=False)
 return _UsersGroupForm
 def ReposGroupForm(edit=False, old_data={}, available_groups=[]):
 class _ReposGroupForm(formencode.Schema):
 allow_extra_fields = True
-filter_extra_fields = True
+filter_extra_fields = False
 group_name = All(UnicodeString(strip=True, min=1, not_empty=True),
 SlugifyName())
 group_description = UnicodeString(strip=True, min=1,
 not_empty=True)
 group_parent_id = OneOf(available_groups, hideList=False,
 testValueList=True,
 if_missing=None, not_empty=False)
-chained_validators = [ValidReposGroup(edit, old_data)]
+chained_validators = [ValidReposGroup(edit, old_data), ValidPerms('group')]
 return _ReposGroupForm
 def RegisterForm(edit=False, old_data={}):
 class _RegisterForm(formencode.Schema):
 allow_extra_fields = True
 filter_extra_fields = True
 username = All(ValidUsername(edit, old_data),
 UnicodeString(strip=True, min=1, not_empty=True))
 password = All(UnicodeString(strip=True, min=6, not_empty=True))
 password_confirmation = All(UnicodeString(strip=True, min=6, not_empty=True))
 active = StringBoolean(if_missing=False)
-name = UnicodeString(strip=True, min=1, not_empty=True)
+name = UnicodeString(strip=True, min=1, not_empty=False)
-lastname = UnicodeString(strip=True, min=1, not_empty=True)
+lastname = UnicodeString(strip=True, min=1, not_empty=False)
 email = All(Email(not_empty=True), UniqSystemEmail(old_data))
 chained_validators = [ValidPasswordsMatch, ValidPassword]
 return _RegisterForm
 def PasswordResetForm():
 class _PasswordResetForm(formencode.Schema):
 allow_extra_fields = True
 filter_extra_fields = True
 email = All(ValidSystemEmail(), Email(not_empty=True))
 return _PasswordResetForm
 def RepoForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),
 repo_groups=[]):
 class _RepoForm(formencode.Schema):
 allow_extra_fields = True
 if edit:
 #this is repo owner
 user = All(UnicodeString(not_empty=True), ValidRepoUser)
-chained_validators = [ValidRepoName(edit, old_data), ValidPerms]
+chained_validators = [ValidRepoName(edit, old_data), ValidPerms()]
 return _RepoForm
-def RepoForkForm(edit=False, old_data={}, supported_backends=BACKENDS.keys()):
+def RepoForkForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),
+repo_groups=[]):
 class _RepoForkForm(formencode.Schema):
 allow_extra_fields = True
 filter_extra_fields = False
-fork_name = All(UnicodeString(strip=True, min=1, not_empty=True),
+repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),
 SlugifyName())
+repo_group = OneOf(repo_groups, hideList=True)
+repo_type = All(ValidForkType(old_data), OneOf(supported_backends))
 description = UnicodeString(strip=True, min=1, not_empty=True)
 private = StringBoolean(if_missing=False)
-repo_type = All(ValidForkType(old_data), OneOf(supported_backends))
+copy_permissions = StringBoolean(if_missing=False)
+update_after_clone = StringBoolean(if_missing=False)
-chained_validators = [ValidForkName()]
+fork_parent_id = UnicodeString()
+chained_validators = [ValidForkName(edit, old_data)]
 return _RepoForkForm
 def RepoSettingsForm(edit=False, old_data={}, supported_backends=BACKENDS.keys(),
 repo_groups=[]):
 class _RepoForm(formencode.Schema):
 allow_extra_fields = True
 SlugifyName())
 description = UnicodeString(strip=True, min=1, not_empty=True)
 repo_group = OneOf(repo_groups, hideList=True)
 private = StringBoolean(if_missing=False)
-chained_validators = [ValidRepoName(edit, old_data), ValidPerms,
+chained_validators = [ValidRepoName(edit, old_data), ValidPerms(),
 ValidSettings]
 return _RepoForm
 def ApplicationSettingsForm():
 rhodecode_title = UnicodeString(strip=True, min=1, not_empty=True)
 rhodecode_realm = UnicodeString(strip=True, min=1, not_empty=True)
 rhodecode_ga_code = UnicodeString(strip=True, min=1, not_empty=False)
 return _ApplicationSettingsForm
 def ApplicationUiSettingsForm():
 class _ApplicationUiSettingsForm(formencode.Schema):
 allow_extra_fields = True
 filter_extra_fields = False
 hooks_changegroup_repo_size = OneOf(['True', 'False'], if_missing=False)
 hooks_pretxnchangegroup_push_logger = OneOf(['True', 'False'], if_missing=False)
 hooks_preoutgoing_pull_logger = OneOf(['True', 'False'], if_missing=False)
 return _ApplicationUiSettingsForm
 def DefaultPermissionsForm(perms_choices, register_choices, create_choices):
 class _DefaultPermissionsForm(formencode.Schema):
 allow_extra_fields = True
 filter_extra_fields = True

Mercurial > kallithea

comparison rhodecode/model/forms.py @ 2031:82a88013a3fd