repos, repo groups, user groups: allow to use disabled users in owner field.

This fixes  #3374. There's no good benefit of having possibility to prevent
setting disabled user from beeing an owner.
It can happen that we start preperating a system and use disabled accounts.
Also users shouldn't be forbidden to edit settings on an disabled owner.

rhodecode/controllers/admin/repo_groups.py

@@ -246,11 +246,10 b' class RepoGroupsController(BaseControlle'
                              repo_group=c.repo_group)
 
         repo_group_form = RepoGroupForm(
-            edit=True,
-            old_data=c.repo_group.get_dict(),
+            edit=True, old_data=c.repo_group.get_dict(),
             available_groups=c.repo_groups_choices,
-            can_create_in_root=can_create_in_root,
-        )()
+            can_create_in_root=can_create_in_root, allow_disabled=True)()
+
         try:
             form_result = repo_group_form.to_python(dict(request.POST))
             gr_name = form_result['group_name']

rhodecode/controllers/admin/repos.py

@@ -307,9 +307,9 b' class ReposController(BaseRepoController'
             'repo_group': repo.group.get_dict() if repo.group else {},
             'repo_type': repo.repo_type,
         }
-        _form = RepoForm(edit=True, old_data=old_data,
-                         repo_groups=c.repo_groups_choices,
-                         landing_revs=c.landing_revs_choices)()
+        _form = RepoForm(
+            edit=True, old_data=old_data, repo_groups=c.repo_groups_choices,
+            landing_revs=c.landing_revs_choices, allow_disabled=True)()
 
         try:
             form_result = _form.to_python(dict(request.POST))

rhodecode/controllers/admin/user_groups.py

@@ -209,9 +209,9 b' class UserGroupsController(BaseControlle'
 
         available_members = [safe_unicode(x[0]) for x in c.available_members]
 
-        users_group_form = UserGroupForm(edit=True,
-                                         old_data=c.user_group.get_dict(),
-                                         available_members=available_members)()
+        users_group_form = UserGroupForm(
+            edit=True, old_data=c.user_group.get_dict(),
+            available_members=available_members, allow_disabled=True)()
 
         try:
             form_result = users_group_form.to_python(request.POST)

rhodecode/model/forms.py

@@ -138,7 +138,11 b' def UserForm(edit=False, available_langu'
     return _UserForm
 
 
-def UserGroupForm(edit=False, old_data={}, available_members=[]):
+def UserGroupForm(edit=False, old_data=None, available_members=None,
+                  allow_disabled=False):
+    old_data = old_data or {}
+    available_members = available_members or []
+
     class _UserGroupForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
@@ -157,14 +161,18 b' def UserGroupForm(edit=False, old_data={'
                 available_members, hideList=False, testValueList=True,
                 if_missing=None, not_empty=False
             )
-            #this is user group owner
-            user = All(v.UnicodeString(not_empty=True), v.ValidRepoUser())
-
+            # this is user group owner
+            user = All(
+                v.UnicodeString(not_empty=True),
+                v.ValidRepoUser(allow_disabled))
     return _UserGroupForm
 
 
-def RepoGroupForm(edit=False, old_data={}, available_groups=[],
-                   can_create_in_root=False):
+def RepoGroupForm(edit=False, old_data=None, available_groups=None,
+                   can_create_in_root=False, allow_disabled=False):
+    old_data = old_data or {}
+    available_groups = available_groups or []
+
     class _RepoGroupForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
@@ -178,11 +186,14 b' def RepoGroupForm(edit=False, old_data={'
         group_parent_id = v.OneOf(available_groups, hideList=False,
                                   testValueList=True, not_empty=True)
         enable_locking = v.StringBoolean(if_missing=False)
-        chained_validators = [v.ValidRepoGroup(edit, old_data, can_create_in_root)]
+        chained_validators = [
+            v.ValidRepoGroup(edit, old_data, can_create_in_root)]
 
         if edit:
-            #this is repo group owner
-            user = All(v.UnicodeString(not_empty=True), v.ValidRepoUser())
+            # this is repo group owner
+            user = All(
+                v.UnicodeString(not_empty=True),
+                v.ValidRepoUser(allow_disabled))
 
     return _RepoGroupForm
 
@@ -221,7 +232,8 b' def PasswordResetForm():'
     return _PasswordResetForm
 
 
-def RepoForm(edit=False, old_data=None, repo_groups=None, landing_revs=None):
+def RepoForm(edit=False, old_data=None, repo_groups=None, landing_revs=None,
+             allow_disabled=False):
     old_data = old_data or {}
     repo_groups = repo_groups or []
     landing_revs = landing_revs or []
@@ -248,7 +260,9 b' def RepoForm(edit=False, old_data=None, '
 
         if edit:
             # this is repo owner
-            user = All(v.UnicodeString(not_empty=True), v.ValidRepoUser())
+            user = All(
+                v.UnicodeString(not_empty=True),
+                v.ValidRepoUser(allow_disabled))
             clone_uri_change = v.UnicodeString(
                 not_empty=False, if_missing=v.Missing)
 

rhodecode/model/validators.py

@@ -193,21 +193,26 b' def ValidRegex(msg=None):'
     return _validator
 
 
-def ValidRepoUser():
+def ValidRepoUser(allow_disabled=False):
     class _validator(formencode.validators.FancyValidator):
         messages = {
-            'invalid_username': _(u'Username %(username)s is not valid')
+            'invalid_username': _(u'Username %(username)s is not valid'),
+            'disabled_username': _(u'Username %(username)s is disabled')
         }
 
         def validate_python(self, value, state):
             try:
-                User.query().filter(User.active == true())\
-                    .filter(User.username == value).one()
+                user = User.query().filter(User.username == value).one()
             except Exception:
                 msg = M(self, 'invalid_username', state, username=value)
                 raise formencode.Invalid(
                     msg, value, state, error_dict={'username': msg}
                 )
+            if user and (not allow_disabled and not user.active):
+                msg = M(self, 'disabled_username', state, username=value)
+                raise formencode.Invalid(
+                    msg, value, state, error_dict={'username': msg}
+                )
 
     return _validator