tracim.lib.core.workspace - Code Metrics - tracim/tracim_backend - Measure and Improve Code Quality continuously with Scrutinizer

tracim.lib.core.workspace B
last analyzed 2018-04-12 10:22 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	238
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	127
dl	0
loc	238
rs	8.2608
c	0
b	0
f	0
wmc	40

19 Methods

Rating	Name	Size	Complexity
B	WorkspaceApi.create_workspace()	42	3
A	WorkspaceApi._base_query()	8	3
A	WorkspaceApi.get_all_manageable()	14	3
A	WorkspaceApi.__init__()	13	1
A	WorkspaceApi.get_all()	2	1
A	WorkspaceApi.save()	2	1
A	WorkspaceApi.restore_one()	10	2
A	WorkspaceApi.get_one()	2	1
A	UnsafeWorkspaceApi._base_query()	2	1
A	WorkspaceApi.generate_label()	11	1
A	WorkspaceApi.delete_one()	6	2
A	WorkspaceApi._base_query_without_roles()	2	1
A	WorkspaceApi.get_one_by_label()	2	1
A	WorkspaceApi.get_base_query()	2	1
A	WorkspaceApi.enable_notifications()	4	3
A	WorkspaceApi.disable_notifications()	4	3
B	WorkspaceApi.get_notifiable_roles()	8	5
A	WorkspaceApi.execute_created_workspace_actions()	2	1
B	WorkspaceApi.get_all_for_user()	14	6

How to fix Complexity

# -*- coding: utf-8 -*-
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
import typing

from sqlalchemy.orm import Query
from sqlalchemy.orm import Session
from tracim.lib.utils.translation import fake_translator as _

from tracim.lib.core.userworkspace import RoleApi
from tracim.models.auth import Group
from tracim.models.auth import User
from tracim.models.data import UserRoleInWorkspace
from tracim.models.data import Workspace

__author__ = 'damien'


class WorkspaceApi(object):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    def __init__(
            self,
            session: Session,
            current_user: User,
            force_role: bool=False

    ):
        """
        :param current_user: Current user of context
        :param force_role: If True, app role in queries even if admin
        """
        self._session = session
        self._user = current_user
        self._force_role = force_role

    def _base_query_without_roles(self):
        return self._session.query(Workspace).filter(Workspace.is_deleted == False)


    def _base_query(self):
        if not self._force_role and self._user.profile.id>=Group.TIM_ADMIN:

            return self._base_query_without_roles()

        return self._session.query(Workspace).\
            join(Workspace.roles).\
            filter(UserRoleInWorkspace.user_id == self._user.user_id).\
            filter(Workspace.is_deleted == False)


    def create_workspace(
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
            self,
            label: str='',

            description: str='',

            calendar_enabled: bool=False,

            save_now: bool=False,

    ) -> Workspace:
        if not label:
            label = self.generate_label()

        workspace = Workspace()
        workspace.label = label
        workspace.description = description
        workspace.calendar_enabled = calendar_enabled

        # By default, we force the current user to be the workspace manager
        # And to receive email notifications
        role_api = RoleApi(
            session=self._session,
            current_user=self._user,
        )

        role = role_api.create_one(
            self._user,
            workspace,
            UserRoleInWorkspace.WORKSPACE_MANAGER,
            with_notif=True,
        )

        self._session.add(workspace)
        self._session.add(role)

        if save_now:
            self._session.flush()

        # TODO - G.M - 28-03-2018 - [Calendar] Reenable calendar stuff

        # if calendar_enabled:
        #     self._ensure_calendar_exist(workspace)
        # else:
        #     self._disable_calendar(workspace)

        return workspace

    def get_one(self, id):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._base_query().filter(Workspace.workspace_id == id).one()

    def get_one_by_label(self, label: str) -> Workspace:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._base_query().filter(Workspace.label == label).one()

    """
    def get_one_for_current_user(self, id):
        return self._base_query().filter(Workspace.workspace_id==id).\
            session.query(ZKContact).filter(ZKContact.groups.any(ZKGroup.id.in_([1,2,3])))
            filter(sqla.).one()
    """


    def get_all(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._base_query().all()

    def get_all_for_user(self, user: User, ignored_ids=None):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        workspaces = []

        for role in user.roles:
            if not role.workspace.is_deleted:
                if not ignored_ids:
                    workspaces.append(role.workspace)
                elif role.workspace.workspace_id not in ignored_ids:
                        workspaces.append(role.workspace)

                else:
                    pass  # do not return workspace

        workspaces.sort(key=lambda workspace: workspace.label.lower())
        return workspaces

    def get_all_manageable(self) -> typing.List[Workspace]:
        """Get all workspaces the current user has manager rights on."""
        workspaces = []  # type: typing.List[Workspace]
        if self._user.profile.id == Group.TIM_ADMIN:
            workspaces = self._base_query().order_by(Workspace.label).all()
        elif self._user.profile.id == Group.TIM_MANAGER:
            workspaces = self._base_query() \
                .filter(
                    UserRoleInWorkspace.role ==
                    UserRoleInWorkspace.WORKSPACE_MANAGER
                ) \
                .order_by(Workspace.label) \
                .all()
        return workspaces

    def disable_notifications(self, user: User, workspace: Workspace):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        for role in user.roles:
            if role.workspace==workspace:

                role.do_notify = False

    def enable_notifications(self, user: User, workspace: Workspace):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        for role in user.roles:
            if role.workspace==workspace:

                role.do_notify = True

    def get_notifiable_roles(self, workspace: Workspace) -> [UserRoleInWorkspace]:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        roles = []
        for role in workspace.roles:
            if role.do_notify==True \

                    and role.user!=self._user \

                    and role.user.is_active:
                roles.append(role)
        return roles

    def save(self, workspace: Workspace):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        self._session.flush()

    def delete_one(self, workspace_id, flush=True):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        workspace = self.get_one(workspace_id)
        workspace.is_deleted = True

        if flush:
            self._session.flush()

    def restore_one(self, workspace_id, flush=True):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        workspace = self._session.query(Workspace)\
            .filter(Workspace.is_deleted==True)\

            .filter(Workspace.workspace_id==workspace_id).one()

        workspace.is_deleted = False

        if flush:
            self._session.flush()

        return workspace

    def execute_created_workspace_actions(self, workspace: Workspace) -> None:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        pass
        # TODO - G.M - 28-03-2018 - [Calendar] Re-enable this calendar stuff

        # self.ensure_calendar_exist(workspace)

    # TODO - G.M - 28-03-2018 - [Calendar] Re-enable this calendar stuff

    # def ensure_calendar_exist(self, workspace: Workspace) -> None:
    #     # Note: Cyclic imports
    #     from tracim.lib.calendar import CalendarManager
    #     from tracim.model.organisational import WorkspaceCalendar
    #
    #     calendar_manager = CalendarManager(self._user)
    #
    #     try:
    #         calendar_manager.enable_calendar_file(
    #             calendar_class=WorkspaceCalendar,
    #             related_object_id=workspace.workspace_id,
    #             raise_=True,
    #         )
    #     # If previous calendar file no exist, calendar must be created
    #     except FileNotFoundError:
    #         self._user.ensure_auth_token()
    #
    #         # Ensure database is up-to-date
    #         self.session.flush()
    #         transaction.commit()
    #
    #         calendar_manager.create_then_remove_fake_event(
    #             calendar_class=WorkspaceCalendar,
    #             related_object_id=workspace.workspace_id,
    #         )
    #
    # def disable_calendar(self, workspace: Workspace) -> None:
    #     # Note: Cyclic imports
    #     from tracim.lib.calendar import CalendarManager
    #     from tracim.model.organisational import WorkspaceCalendar
    #
    #     calendar_manager = CalendarManager(self._user)
    #     calendar_manager.disable_calendar_file(
    #         calendar_class=WorkspaceCalendar,
    #         related_object_id=workspace.workspace_id,
    #         raise_=False,
    #     )

    def get_base_query(self) -> Query:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._base_query()

    def generate_label(self) -> str:
        """
        :return: Generated workspace label
        """
        query = self._base_query_without_roles() \
            .filter(Workspace.label.ilike('{0}%'.format(
                _('Workspace'),
            )))

        return _('Workspace {}').format(
            query.count() + 1,
        )


class UnsafeWorkspaceApi(WorkspaceApi):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    def _base_query(self):
        return self.session.query(Workspace).filter(Workspace.is_deleted==False)



1			# -- coding: utf-8 --
			0 ignored issues – show Coding Style introduced 2018-04-06 10:21 UTC by Report Bug Copy Issue Report This module should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
2			import typing
3
4			from sqlalchemy.orm import Query
5			from sqlalchemy.orm import Session
6			from tracim.lib.utils.translation import fake_translator as _
7
8			from tracim.lib.core.userworkspace import RoleApi
9			from tracim.models.auth import Group
10			from tracim.models.auth import User
11			from tracim.models.data import UserRoleInWorkspace
12			from tracim.models.data import Workspace
13
14			__author__ = 'damien'
15
16
17			class WorkspaceApi(object):
			0 ignored issues – show Coding Style introduced 2018-03-30 20:04 UTC by Report Bug Copy Issue Report This class should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history... Unused Code introduced 2018-03-30 20:04 UTC by Report Bug Copy Issue Report The variable `__class__` seems to be unused. Loading history...
18
19			def __init__(
20			self,
21			session: Session,
22			current_user: User,
23			force_role: bool=False
			0 ignored issues – show Coding Style introduced 2018-03-30 20:04 UTC by Report Bug Copy Issue Report Exactly one space required around keyword argument assignment Loading history...
24			):
25			"""
26			:param current_user: Current user of context
27			:param force_role: If True, app role in queries even if admin
28			"""
29			self._session = session
30			self._user = current_user
31			self._force_role = force_role
32
33			def _base_query_without_roles(self):
34			return self._session.query(Workspace).filter(Workspace.is_deleted == False)
			0 ignored issues – show introduced 2018-03-30 20:04 UTC by Report Bug Copy Issue Report Comparison to False should be 'not expr' or 'expr is False' Loading history...
35
36			def _base_query(self):

tracim / tracim_backend

tracim.lib.core.workspace B last analyzed 2018-04-12 10:22 UTC

Complexity

Size/Duplication

Importance

19 Methods

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like

tracim.lib.core.workspace B
last analyzed 2018-04-12 10:22 UTC