Cleans up following PEP8 rules

tracim/tracim/controllers/admin/user.py

 # -*- coding: utf-8 -*-
-import uuid
 import random
 
 import pytz
-from tracim import model  as pm
+from tracim import model as pm
 
-from sprox.tablebase import TableBase
-from sprox.formbase import EditableForm, AddRecordForm
-from sprox.fillerbase import TableFiller, EditFormFiller
-from tracim.config.app_cfg import CFG
-from tw2 import forms as tw2f
 import tg
 from tg import predicates
 from tg import tmpl_context
 from tg.i18n import ugettext as _
 
-from sprox.widgets import PropertyMultipleSelectField
-from sprox._compat import unicode_text
-
-from formencode import Schema
-from formencode.validators import FieldsMatch
-
 from tracim.controllers import TIMRestController
 from tracim.controllers.user import UserWorkspaceRestController
 
 from tracim.lib import helpers as h
 from tracim.lib.base import logger
 from tracim.lib.email import get_email_manager
-from tracim.lib.user import UserApi
 from tracim.lib.group import GroupApi
+from tracim.lib.user import UserApi
 from tracim.lib.userworkspace import RoleApi
 from tracim.lib.workspace import WorkspaceApi
 
 from tracim.model import DBSession
-from tracim.model.auth import Group, User
-from tracim.model.serializers import Context, CTX, DictLikeClass
+from tracim.model.auth import Group
+from tracim.model.serializers import CTX
+from tracim.model.serializers import Context
+from tracim.model.serializers import DictLikeClass
+
 
 class UserProfileAdminRestController(TIMRestController):
-    """
-     CRUD Controller allowing to manage groups of a user
-    """
+    """CRUD Controller allowing to manage groups of a user."""
 
     allow_only = predicates.in_group(Group.TIM_ADMIN_GROUPNAME)
 
     @property
     def allowed_profiles(self):
         return [
-        UserProfileAdminRestController._ALLOWED_PROFILE_USER,
-        UserProfileAdminRestController._ALLOWED_PROFILE_MANAGER,
-        UserProfileAdminRestController._ALLOWED_PROFILE_ADMIN
-    ]
+            UserProfileAdminRestController._ALLOWED_PROFILE_USER,
+            UserProfileAdminRestController._ALLOWED_PROFILE_MANAGER,
+            UserProfileAdminRestController._ALLOWED_PROFILE_ADMIN,
+        ]
 
     def _before(self, *args, **kw):
         """
-        Instantiate the current workspace in tg.tmpl_context
+        Instantiate the current workspace in tg.tmpl_context.
+
         :param args:
         :param kw:
         :return:
         tg.tmpl_context.user = user
 
     @tg.expose()
-    def switch(self, new_role):
+    def switch(self, new_role) -> None:
         """
-        :param new_role: value should be 'tracim-user', 'tracim-manager' (allowed to create workspaces) or 'tracim-admin' (admin the whole system)
-        :return:
+        Switch to the given new role.
+
+        :param new_role: value should be:
+            'tracim-user',
+            'tracim-manager' (allowed to create workspaces) or
+            'tracim-admin' (admin the whole system)
         """
         return self.put(new_role)
 
 
         group_api = GroupApi(current_user)
 
-        if current_user.user_id==user.user_id:
+        if current_user.user_id == user.user_id:
             tg.flash(_('You can\'t change your own profile'), CST.STATUS_ERROR)
             tg.redirect(self.parent_controller.url())
 
-
         redirect_url = self.parent_controller.url(skip_id=True)
 
         if new_profile not in self.allowed_profiles:
         pod_manager_group = group_api.get_one(Group.TIM_MANAGER)
         pod_admin_group = group_api.get_one(Group.TIM_ADMIN)
 
-        flash_message = _('User updated.') # this is the default value ; should never appear
+        # this is the default value ; should never appear
+        flash_message = _('User updated.')
 
-        if new_profile==UserProfileAdminRestController._ALLOWED_PROFILE_USER:
+        if new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_USER:
             if pod_user_group not in user.groups:
                 user.groups.append(pod_user_group)
 
 
             flash_message = _('User {} is now a basic user').format(user.get_display_name())
 
-        elif new_profile==UserProfileAdminRestController._ALLOWED_PROFILE_MANAGER:
+        elif new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_MANAGER:
             if pod_user_group not in user.groups:
                 user.groups.append(pod_user_group)
             if pod_manager_group not in user.groups:
 
             flash_message = _('User {} can now workspaces').format(user.get_display_name())
 
-
-        elif new_profile==UserProfileAdminRestController._ALLOWED_PROFILE_ADMIN:
+        elif new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_ADMIN:
             if pod_user_group not in user.groups:
                 user.groups.append(pod_user_group)
             if pod_manager_group not in user.groups:
             flash_message = _('User {} is now an administrator').format(user.get_display_name())
 
         else:
-            logger.error(self, 'Trying to change user {} profile with unexpected profile {}'.format(user.user_id, new_profile))
+            error_msg = \
+                'Trying to change user {} profile with unexpected profile {}'
+            logger.error(self, error_msg.format(user.user_id, new_profile))
             tg.flash(_('Unknown profile'), CST.STATUS_ERROR)
             tg.redirect(redirect_url)
 
         pass
 
 
-
 class UserPasswordAdminRestController(TIMRestController):
-    """
-     CRUD Controller allowing to manage password of a given user
-    """
+    """CRUD Controller allowing to manage password of a given user."""
 
-    allow_only = predicates.in_any_group(Group.TIM_MANAGER_GROUPNAME, Group.TIM_ADMIN_GROUPNAME)
+    allow_only = predicates.in_any_group(
+            Group.TIM_MANAGER_GROUPNAME,
+            Group.TIM_ADMIN_GROUPNAME,
+        )
 
     def _before(self, *args, **kw):
         """
-        Instantiate the current workspace in tg.tmpl_context
+        Instantiate the current workspace in tg.tmpl_context.
+
         :param args:
         :param kw:
         :return:
         tg.tmpl_context.user_id = user_id
         tg.tmpl_context.user = user
 
-
     @tg.expose('tracim.templates.admin.user_password_edit')
     def edit(self):
         current_user = tmpl_context.current_user
         api = UserApi(current_user)
         dictified_user = Context(CTX.USER).toDict(tmpl_context.user, 'user')
-        return DictLikeClass(result = dictified_user)
+        return DictLikeClass(result=dictified_user)
 
     @tg.expose()
     def put(self, new_password1, new_password2, next_url=''):
             tg.flash(_('Empty password is not allowed.'), CST.STATUS_ERROR)
             tg.redirect(next_url)
 
-        if new_password1!=new_password2:
+        if new_password1 != new_password2:
             tg.flash(_('New passwords do not match.'), CST.STATUS_ERROR)
             tg.redirect(next_url)
 
 
     def _before(self, *args, **kw):
         """
-        Instantiate the current workspace in tg.tmpl_context
+        Instantiate the current workspace in tg.tmpl_context.
+
         :param args:
         :param kw:
         :return:
 
 
 class UserRestController(TIMRestController):
-    """
-     CRUD Controller allowing to manage Users
-    """
-    allow_only = predicates.in_any_group(Group.TIM_MANAGER_GROUPNAME, Group.TIM_ADMIN_GROUPNAME)
+    """CRUD Controller allowing to manage Users."""
+
+    allow_only = predicates.in_any_group(
+            Group.TIM_MANAGER_GROUPNAME,
+            Group.TIM_ADMIN_GROUPNAME,
+        )
 
     password = UserPasswordAdminRestController()
     profile = UserProfileAdminRestController()
     def current_item_id_key_in_context(cls):
         return 'user_id'
 
-
     @tg.require(predicates.in_group(Group.TIM_MANAGER_GROUPNAME))
     @tg.expose('tracim.templates.admin.user_getall')
     def get_all(self, *args, **kw):
         fake_api = Context(CTX.USERS).toDict({'current_user': current_user_content})
 
         dictified_users = Context(CTX.USERS).toDict(users, 'users', 'user_nb')
-        return DictLikeClass(result = dictified_users, fake_api=fake_api)
+        return DictLikeClass(result=dictified_users, fake_api=fake_api)
 
     @tg.require(predicates.in_group(Group.TIM_MANAGER_GROUPNAME))
     @tg.expose()
     @classmethod
     def generate_password(
             cls,
-            password_length = PASSWORD_LENGTH,
-            password_chars = PASSWORD_CHARACTERS
-            ):
-
+            password_length=PASSWORD_LENGTH,
+            password_chars=PASSWORD_CHARACTERS,
+    ):
         # character list that will be contained into the password
         char_list = []
 
-        for j in range(0, password_length):
+        for _unused in range(password_length):
             # This puts a random char from the list above inside
             # the list of chars and then merges them into a String
             char_list.append(random.choice(password_chars))
     @tg.expose('tracim.templates.admin.user_getone')
     def get_one(self, user_id):
         current_user = tmpl_context.current_user
-        api = UserApi(current_user )
+        api = UserApi(current_user)
         # role_api = RoleApi(tg.tmpl_context.current_user)
         # user_api = UserApi(tg.tmpl_context.current_user)
 
-        user = api.get_one(user_id) # FIXME
+        user = api.get_one(user_id)  # FIXME
 
         role_api = RoleApi(tg.tmpl_context.current_user)
         role_list = role_api.get_roles_for_select_field()
                                          role_types=role_list)
         fake_api = Context(CTX.ADMIN_USER).toDict(fake_api_content)
 
-        return DictLikeClass(result = dictified_user, fake_api=fake_api)
-
+        return DictLikeClass(result=dictified_user, fake_api=fake_api)
 
     @tg.expose('tracim.templates.admin.user_edit')
     def edit(self, id):
             tg.redirect(next_url)
         tg.redirect(self.url())
 
-
     @tg.require(predicates.in_group(Group.TIM_ADMIN_GROUPNAME))
     @tg.expose()
     def enable(self, id, next_url=None):
         api.save(user)
 
         tg.flash(_('User {} enabled.').format(user.get_display_name()), CST.STATUS_OK)
-        if next_url=='user':
+        if next_url == 'user':
             tg.redirect(self.url(id=user.user_id))
         tg.redirect(self.url())
 
         current_user = tmpl_context.current_user
         api = UserApi(current_user)
 
-        if current_user.user_id==id:
+        if current_user.user_id == id:
             tg.flash(_('You can\'t de-activate your own account'), CST.STATUS_ERROR)
         else:
             user = api.get_one(id)
             api.save(user)
             tg.flash(_('User {} disabled').format(user.get_display_name()), CST.STATUS_OK)
 
-        if next_url=='user':
+        if next_url == 'user':
             tg.redirect(self.url(id=user.user_id))
         tg.redirect(self.url())