educommon 3.12.0__py3-none-any.whl → 3.13.2__py3-none-any.whl

educommon/auth/rbac/actions.py

@@ -1,4 +1,5 @@
 """Паки и экшены для окна реестра "Роли"."""
+
 import json
 from collections import (
     defaultdict,
@@ -101,12 +102,11 @@ from educommon.m3 import (
 
 
 def _get_role(role_id):
+    """Возвращает объект роли по ID или выбрасывает исключение."""
     try:
         return Role.objects.get(pk=role_id)
     except Role.DoesNotExist:
-        raise ApplicationLogicException(
-            'Роль ID:{} не существует'.format(role_id)
-        )
+        raise ApplicationLogicException('Роль ID:{} не существует'.format(role_id))
 
 
 class RolesTreeRowsAction(ObjectRowsAction):
@@ -143,14 +143,15 @@ class RolesTreeRowsAction(ObjectRowsAction):
 
     def prepare_object(self, obj):
         """Сохранение данных роли в словарь перед сериализацией в JSON."""
-        data = super(RolesTreeRowsAction, self).prepare_object(obj)
+        data = super().prepare_object(obj)
 
         data['leaf'] = self.is_leaf(obj)
 
         return data
 
     def run(self, *args, **kwargs):
-        result = super(RolesTreeRowsAction, self).run(*args, **kwargs)
+        """Тело Action, вызывается при обработке запроса к серверу."""
+        result = super().run(*args, **kwargs)
 
         data = result.data.get('rows', [])
 
@@ -161,10 +162,15 @@ class AddRoleToRoleWindowAction(ObjectSelectWindowAction):
     """Отображение окна добавления одной роли в другую."""
 
     def create_window(self):
+        """Метод инстанцирует окно."""
         self.win = ui.RoleSelectWindow()
 
     def set_window_params(self):
-        super(AddRoleToRoleWindowAction, self).set_window_params()
+        """Метод заполняет словарь self.win_params, который будет передан в окно.
+
+        Этот словарь выступает как шина передачи данных от Actions/Packs к окну.
+        """
+        super().set_window_params()
 
         self.win_params['pack'] = self.parent
 
@@ -178,6 +184,7 @@ class AddRoleToRoleAction(BaseAction):
 
     @convert_validation_error_to(ApplicationLogicException)
     def run(self, request, context):
+        """Тело Action, вызывается при обработке запроса к серверу."""
         role_parent = RoleParent(
             role=_get_role(getattr(context, self.parent.id_param_name)),
             parent=_get_role(context.parent_id),
@@ -192,15 +199,13 @@ class DeleteRoleFromRoleAction(BaseAction):
     """Удаление одной роли из другой."""
 
     def run(self, request, context):
+        """Тело Action, вызывается при обработке запроса к серверу."""
         try:
             role_parent = RoleParent.objects.get(
-                role=_get_role(getattr(context, self.parent.id_param_name)),
-                parent_id=context.parent_id
+                role=_get_role(getattr(context, self.parent.id_param_name)), parent_id=context.parent_id
             )
         except RoleParent.DoesNotExist:
-            raise ApplicationLogicException(
-                'Выбранная роль должна являться вложенной ролью.'
-            )
+            raise ApplicationLogicException('Выбранная роль должна являться вложенной ролью.')
 
         role_parent.delete()
 
@@ -228,7 +233,7 @@ class Pack(TreeObjectPack):
     column_name_on_select = 'name'
 
     def __init__(self):
-        super(Pack, self).__init__()
+        super().__init__()
 
         self.replace_action('rows_action', RolesTreeRowsAction())
 
@@ -236,30 +241,36 @@ class Pack(TreeObjectPack):
         self.add_role_to_role_action = AddRoleToRoleAction()
         self.delete_role_from_role_action = DeleteRoleFromRoleAction()
 
-        self.actions.extend((
-            self.add_role_to_role_window_action,
-            self.add_role_to_role_action,
-            self.delete_role_from_role_action,
-        ))
+        self.actions.extend(
+            (
+                self.add_role_to_role_window_action,
+                self.add_role_to_role_action,
+                self.delete_role_from_role_action,
+            )
+        )
         # ---------------------------------------------------------------------
         # Настройка разрешений для экшенов пака.
         self.need_check_permission = True
         self.perm_code = PERM_GROUP__ROLE
 
-        for action in (self.autocomplete_action,
-                       self.list_window_action,
-                       self.multi_select_window_action,
-                       self.rows_action,
-                       self.select_window_action,
-                       self.edit_window_action):
+        for action in (
+            self.autocomplete_action,
+            self.list_window_action,
+            self.multi_select_window_action,
+            self.rows_action,
+            self.select_window_action,
+            self.edit_window_action,
+        ):
             action.perm_code = 'view'
 
-        for action in (self.new_window_action,
-                       self.save_action,
-                       self.delete_action,
-                       self.add_role_to_role_window_action,
-                       self.add_role_to_role_action,
-                       self.delete_role_from_role_action):
+        for action in (
+            self.new_window_action,
+            self.save_action,
+            self.delete_action,
+            self.add_role_to_role_window_action,
+            self.add_role_to_role_action,
+            self.delete_role_from_role_action,
+        ):
             action.perm_code = 'edit'
         # ---------------------------------------------------------------------
 
@@ -270,11 +281,10 @@ class Pack(TreeObjectPack):
         )
 
     def declare_context(self, action):
-        result = super(Pack, self).declare_context(action)
+        """Декларирует контекст для экшна."""
+        result = super().declare_context(action)
 
-        if action in (self.rows_action,
-                      self.add_role_to_role_window_action,
-                      self.add_role_to_role_action):
+        if action in (self.rows_action, self.add_role_to_role_window_action, self.add_role_to_role_action):
             result[self.id_param_name] = dict(type='int')
 
         if action is self.rows_action:
@@ -297,27 +307,22 @@ class Pack(TreeObjectPack):
         return result
 
     def get_rows_query(self, request, context):
+        """Возвращает выборку из БД для получения списка данных."""
         request_params = get_request_params(request)
         if request_params.get('filter'):
-            return super(Pack, self).get_rows_query(request, context)
+            return super().get_rows_query(request, context)
 
         current_role_id = getattr(context, self.id_param_name)
 
         if request_params.get('filter', False):
-            result = super(Pack, self).get_rows_query(
-                request, context
-            )
+            result = super().get_rows_query(request, context)
         elif current_role_id < 0:
             # Вывод корневых ролей
-            result = self.model.objects.exclude(
-                pk__in=RoleParent.objects.values('role').distinct()
-            )
+            result = self.model.objects.exclude(pk__in=RoleParent.objects.values('role').distinct())
         else:
             # Вывод ролей, вложенных в указанную роль
             result = self.model.objects.filter(
-                pk__in=RoleParent.objects.filter(
-                    parent=current_role_id
-                ).values('role').distinct()
+                pk__in=RoleParent.objects.filter(parent=current_role_id).values('role').distinct()
             )
 
         if context.select_mode and context.role_id is not None:
@@ -328,20 +333,15 @@ class Pack(TreeObjectPack):
             try:
                 role = Role.objects.get(pk=context.role_id)
             except Role.DoesNotExist:
-                raise ApplicationLogicException(
-                    'Роль ID:{} не найдена'.format(context.role_id)
-                )
+                raise ApplicationLogicException('Роль ID:{} не найдена'.format(context.role_id))
 
-            result = result.exclude(
-                pk__in=set([role.id]) | set(r.id for r in role.subroles)
-            )
+            result = result.exclude(pk__in=set([role.id]) | set(r.id for r in role.subroles))
 
         return result
 
     def get_list_window_params(self, params, request, context):
-        params = super(Pack, self).get_list_window_params(
-            params, request, context
-        )
+        """Возвращает словарь параметров, которые будут переданы окну списка."""
+        params = super().get_list_window_params(params, request, context)
 
         if not params['is_select_mode']:
             params['width'] = 700
@@ -352,9 +352,8 @@ class Pack(TreeObjectPack):
         return params
 
     def get_edit_window_params(self, params, request, context):
-        params = super(Pack, self).get_edit_window_params(
-            params, request, context
-        )
+        """Возвращает словарь параметров, которые будут переданы окну редактирования."""
+        params = super().get_edit_window_params(params, request, context)
 
         params['roles_pack'] = self
         params['partitions_pack'] = get_pack(PartitionsPack)
@@ -368,21 +367,13 @@ class Pack(TreeObjectPack):
             params['show_user_types'] = True
             params['user_types'] = tuple(
                 (u_type.id, u_type.name)
-                for u_type in (
-                    ContentType.objects.get_for_models(
-                        *rbac_config.user_types
-                    ).values()
-                )
+                for u_type in (ContentType.objects.get_for_models(*rbac_config.user_types).values())
             )
             if not params['create_new']:
-                params['user_type_ids'] = tuple(
-                    params['object'].user_types.values_list('pk', flat=True)
-                )
+                params['user_type_ids'] = tuple(params['object'].user_types.values_list('pk', flat=True))
 
         if not params['create_new']:
-            params['permission_ids'] = list(
-                params['object'].permissions.values_list('pk', flat=True)
-            )
+            params['permission_ids'] = list(params['object'].permissions.values_list('pk', flat=True))
 
         params['can_edit'] = rbac.has_access(self.save_action, request)
         if not params['can_edit']:
@@ -413,33 +404,25 @@ class Pack(TreeObjectPack):
         )
         # Проверка, есть ли пользователи с удаляемыми типами
         if types_to_delete and user_roles_to_delete.exists():
-            related_content_types = ContentType.objects.filter(
-                pk__in=types_to_delete
-            )
+            related_content_types = ContentType.objects.filter(pk__in=types_to_delete)
             raise ApplicationLogicException(
                 'Невозможно отменить назначение роли для пользователей '
                 'типа {}, т.к. данная роль уже назначена {} '
                 'пользователей.'.format(
-                    ', '.join(
-                        '"{}"'.format(ct.name) for ct in related_content_types
-                    ),
-                    'этому типу'
-                    if len(types_to_delete) == 1 else 'этим типам',
+                    ', '.join('"{}"'.format(ct.name) for ct in related_content_types),
+                    'этому типу' if len(types_to_delete) == 1 else 'этим типам',
                 )
             )
         # Удаление лишних типов пользователей
-        RoleUserType.objects.filter(
-            role=role, user_type__in=types_to_delete
-        ).delete()
+        RoleUserType.objects.filter(role=role, user_type__in=types_to_delete).delete()
         # Добавление новых типов пользователей
         for user_type_id in new_user_types - old_user_types:
-            RoleUserType.objects.create(
-                role=role, user_type_id=user_type_id
-            )
+            RoleUserType.objects.create(role=role, user_type_id=user_type_id)
 
     @convert_validation_error_to(ValidationError)
     @atomic
     def save_row(self, obj, create_new, request, context):
+        """Сохраняет объект."""
         # При отключении флага удаляются все связи с типами пользователей
         if not (create_new or obj.can_be_assigned):
             RoleUserType.objects.filter(role=obj).delete()
@@ -454,9 +437,7 @@ class Pack(TreeObjectPack):
             try:
                 parent = Role.objects.get(pk=context.parent_id)
             except Role.DoesNotExist:
-                raise ApplicationLogicException(
-                    'Роль ID:{} не существует.'.format(context.parent_id)
-                )
+                raise ApplicationLogicException('Роль ID:{} не существует.'.format(context.parent_id))
 
             RoleParent.objects.create(role=obj, parent=parent)
         else:
@@ -472,9 +453,7 @@ class Pack(TreeObjectPack):
 
             # Добавление новых прав в роль
             for permission_id in new_permissions - old_permissions:
-                RolePermission.objects.get_or_create(
-                    role=obj, permission_id=permission_id
-                )
+                RolePermission.objects.get_or_create(role=obj, permission_id=permission_id)
 
 
 class Partition(VirtualModel):
@@ -488,6 +467,12 @@ class Partition(VirtualModel):
 
     @classmethod
     def _get_ids(cls):
+        """Метод получения ID и названий разделов системы.
+
+        Метод возвращает iterable, или callable, возвращаюший iterable,
+        для каждого элемента которого (iterable) будет инстанцирован объект класса
+        (каждый эл-т итератора передаётся в конструктор).
+        """
         if not hasattr(cls, 'data'):
             cls.data = []
             for i, title in enumerate(sorted(rbac.partitions)):
@@ -514,7 +499,7 @@ class PartitionsPack(ObjectPack):
     allow_paging = False
 
     def __init__(self):
-        super(PartitionsPack, self).__init__()
+        super().__init__()
         # ---------------------------------------------------------------------
 
         self.need_check_permission = True
@@ -552,18 +537,17 @@ class PermissionsPack(ObjectPack):
     allow_paging = False
 
     def __init__(self):
-        super(PermissionsPack, self).__init__()
-        # ---------------------------------------------------------------------
+        super().__init__()
 
         self.need_check_permission = True
         self.perm_code = PERM_GROUP__ROLE
 
         for action in self.actions:
             action.perm_code = 'view'
-        # ---------------------------------------------------------------------
 
     def declare_context(self, action):
-        result = super(PermissionsPack, self).declare_context(action)
+        """Декларирует контекст для экшна"""
+        result = super().declare_context(action)
 
         if action is self.rows_action:
             result['partition_id'] = dict(type='int')
@@ -571,70 +555,71 @@ class PermissionsPack(ObjectPack):
         return result
 
     def prepare_row(self, obj, request, context):
-        result = super(PermissionsPack, self).prepare_row(
-            obj, request, context
-        )
+        """Установка дополнительных атрибутов объекта."""
+        result = super().prepare_row(obj, request, context)
 
-        permission_names = (
-            rbac.get_dependent_permissions(obj.name) - rbac.hidden_permissions
+        permission_names = rbac.get_dependent_permissions(obj.name) - rbac.hidden_permissions
+        result.dependencies = json.dumps(
+            sorted(get_permission_full_title(dependency) for dependency in permission_names)
         )
-        result.dependencies = json.dumps(sorted(
-            get_permission_full_title(dependency)
-            for dependency in permission_names
-        ))
 
         return result
 
     def get_rows_query(self, request, context):
+        """Возвращает выборку из БД для получения списка данных."""
         # Определение название раздела по его id.
         try:
-            partition = PartitionsPack.model.objects.get(
-                id=context.partition_id
-            ).title
+            partition = PartitionsPack.model.objects.get(id=context.partition_id).title
         except PartitionsPack.model.DoesNotExists:
-            raise ApplicationLogicException(
-                'Раздел {} не существует'.format(context.partition_id)
+            raise ApplicationLogicException('Раздел {} не существует'.format(context.partition_id))
+
+        query = (
+            super()
+            .get_rows_query(request, context)
+            .filter(
+                # Условия для выборки разрешений только из раздела partition.
+                reduce(or_, (Q(name__startswith=code + '/') for code in rbac.partitions[partition])),
+                hidden=False,
             )
-
-        query = super(PermissionsPack, self).get_rows_query(
-            request, context
-        ).filter(
-            # Условия для выборки разрешений только из раздела partition.
-            reduce(or_, (
-                Q(name__startswith=code + '/')
-                for code in rbac.partitions[partition]
-            )),
-            hidden=False,
-        ).annotate(title_with_group=Case(
-            # Добавление названия группы к названию разрешения.
-            output_field=CharField(),
-            *(
-                When(
-                    name__startswith=group + '/',
-                    then=Concat(
-                        Value(title + ' - ' if title else ''),
-                        F('title'),
-                    )
+            .annotate(
+                title_with_group=Case(
+                    # Добавление названия группы к названию разрешения.
+                    output_field=CharField(),
+                    *(
+                        When(
+                            name__startswith=group + '/',
+                            then=Concat(
+                                Value(title + ' - ' if title else ''),
+                                F('title'),
+                            ),
+                        )
+                        for group, title in rbac.groups.items()
+                    ),
                 )
-                for group, title in rbac.groups.items()
             )
-        ))
+        )
 
         return query
+
+
 # -----------------------------------------------------------------------------
 
+
 def _get_group_name(perm_name):
     """Возвращает имя группы разрешения."""
     return perm_name.split('/')[0]
 
+
 def _get_group_title(perm_name):
     """Возвращает название группы разрешений."""
     group_name = _get_group_name(perm_name)
     group_title = rbac.groups[group_name]
+
     return group_title
 
 
 def _get_partition_title(perm_name):
+    """Возвращает название раздела, к которому относится разрешение."""
     group_name = perm_name.split('/')[0]
 
     for title, names in rbac.partitions.items():
@@ -648,6 +633,10 @@ class ResultPermissionsAction(BaseAction):
     """Возвращает данные для грида "Итоговые разрешения"."""
 
     def _get_nested_roles(self, role_id):
+        """Возвращает все вложенные роли для заданной роли.
+
+        Строит рекурсивное множество дочерних ролей, включая вложенные на любой глубине.
+        """
         role_children = defaultdict(set)
         query = RoleParent.objects.values_list('parent', 'role')
 
@@ -667,10 +656,9 @@ class ResultPermissionsAction(BaseAction):
         return get_nested_roles(role_id)
 
     def _get_nested_roles_permissions(self, role_id):
+        """Возвращает разрешения, назначенные вложенным ролям заданной роли."""
         query = Permission.objects.filter(
-            pk__in=RolePermission.objects.filter(
-                role_id__in=self._get_nested_roles(role_id)
-            ).values('permission'),
+            pk__in=RolePermission.objects.filter(role_id__in=self._get_nested_roles(role_id)).values('permission'),
             hidden=False,
         ).values_list('name', 'title', 'description')
 
@@ -685,17 +673,19 @@ class ResultPermissionsAction(BaseAction):
             )
 
     def _get_dependent_permissions(self, permission_ids):
+        """Возвращает разрешения, от которых зависят указанные разрешения.
+
+        Исключает скрытые разрешения и формирует структуру для отображения
+        в интерфейсе.
+        """
         permissions_by_id = {
             pk: (name, title, description)
             for pk, name, title, description in Permission.objects.filter(
                 hidden=False,
-            ).values_list(
-                'pk', 'name', 'title', 'description'
-            )
+            ).values_list('pk', 'name', 'title', 'description')
         }
         permissions_by_name = {
-            name: (pk, title, description)
-            for pk, (name, title, description) in permissions_by_id.items()
+            name: (pk, title, description) for pk, (name, title, description) in permissions_by_id.items()
         }
 
         for perm_id in permission_ids:
@@ -719,6 +709,7 @@ class ResultPermissionsAction(BaseAction):
                 )
 
     def _get_role_permissions(self, permission_ids):
+        """Возвращает основные разрешения, явно назначенные роли."""
         query = Permission.objects.filter(
             pk__in=permission_ids,
             hidden=False,
@@ -736,6 +727,15 @@ class ResultPermissionsAction(BaseAction):
                 )
 
     def run(self, request, context):
+        """Обрабатывает запрос на получение итоговых разрешений роли.
+
+        Комбинирует разрешения:
+        - явно назначенные роли;
+        - зависимые разрешения;
+        - разрешения вложенных ролей.
+
+        Возвращает данные, сгруппированные по разделам и группам.
+        """
         perm_names = set()
 
         data = defaultdict(lambda: defaultdict(list))
@@ -751,11 +751,13 @@ class ResultPermissionsAction(BaseAction):
                 partition_title = perm_data['partition']
                 group_title = perm_data['group']
 
-                data[partition_title][group_title].append(dict(
-                    title=perm_data['title'],
-                    description=perm_data['description'],
-                    source=perm_data['source'],
-                ))
+                data[partition_title][group_title].append(
+                    dict(
+                        title=perm_data['title'],
+                        description=perm_data['description'],
+                        source=perm_data['source'],
+                    )
+                )
 
         return PreJsonResult(data)
 
@@ -764,14 +766,12 @@ class ResultPermissionsPack(BasePack):
     """Набор действий для грида "Итоговые разрешения" окна редактирования."""
 
     def __init__(self):
-        super(ResultPermissionsPack, self).__init__()
+        super().__init__()
         # ---------------------------------------------------------------------
 
         self.result_permissions_action = ResultPermissionsAction()
 
-        self.actions.extend((
-            self.result_permissions_action,
-        ))
+        self.actions.extend((self.result_permissions_action,))
         # ---------------------------------------------------------------------
 
         self.need_check_permission = True
@@ -782,11 +782,14 @@ class ResultPermissionsPack(BasePack):
         # ---------------------------------------------------------------------
 
     def declare_context(self, action):
-        result = super(ResultPermissionsPack, self).declare_context(action)
+        """Декларация контекста для экшна."""
+        result = super().declare_context(action)
 
         if action is self.result_permissions_action:
             result[get_pack_id(Pack)] = dict(type='int_or_none', default=None)
             result['role_permissions'] = dict(type='int_list', default=())
 
         return result
+
+
 # -----------------------------------------------------------------------------

educommon/auth/rbac/app_meta.py

@@ -1,4 +1,5 @@
 """Инициализация приложения в M3."""
+
 from educommon import (
     ioc,
 )
@@ -9,9 +10,11 @@ from educommon.auth.rbac import (
 
 def register_actions():
     """Регистрация паков приложения в контроллере."""
-    ioc.get('auth_controller').extend_packs((
-        actions.Pack(),
-        actions.PartitionsPack(),
-        actions.PermissionsPack(),
-        actions.ResultPermissionsPack(),
-    ))
+    ioc.get('auth_controller').extend_packs(
+        (
+            actions.Pack(),
+            actions.PartitionsPack(),
+            actions.PermissionsPack(),
+            actions.ResultPermissionsPack(),
+        )
+    )

educommon/auth/rbac/backends/base.py

@@ -19,10 +19,7 @@ class BackendBase(metaclass=ABCMeta):
 
         :rtype: bool
         """
-        return (
-            action.parent.need_check_permission or
-            action.need_check_permission
-        )
+        return action.parent.need_check_permission or action.need_check_permission
 
     def _get_current_user(self, request):
         """Возвращает текущего пользователя.
@@ -37,10 +34,7 @@ class BackendBase(metaclass=ABCMeta):
         :rtype: tuple
         """
         if action.sub_permissions:
-            result = tuple(
-                action.get_perm_code(sub_perm)
-                for sub_perm in action.sub_permissions
-            )
+            result = tuple(action.get_perm_code(sub_perm) for sub_perm in action.sub_permissions)
         else:
             result = (action.get_perm_code(),)