tracim.command.user

Complexity

Total Complexity

23

Size/Duplication

Total Lines	232
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
B	UserCommand._create_user()	0	23	4
A	UserCommand._get_group()	0	2	1
A	UserCommand.get_parser()	0	50	1
A	UserCommand._proceed_groups()	0	13	3
A	UserCommand._add_user_to_named_group()	0	9	2
A	UserCommand._update_password_for_login()	0	5	1
A	UserCommand._user_exist()	0	2	1
A	UserCommand.get_description()	0	2	1
A	UserCommand._check_context()	0	9	1
A	UserCommand._password_required()	0	5	1
A	UserCommand.take_app_action()	0	22	1
B	UserCommand._proceed_user()	0	28	4
A	UserCommand._remove_user_from_named_group()	0	9	2

# -*- coding: utf-8 -*-

This module should have a docstring.

import argparse
from pyramid.scripting import AppEnvironment
import transaction
from sqlalchemy.exc import IntegrityError

from tracim import CFG

Unused CFG imported from tracim

from tracim.command import AppContextCommand
from tracim.command import Extender
#from tracim.lib.auth.ldap import LDAPAuth
#from tracim.lib.daemons import DaemonsManager
#from tracim.lib.daemons import RadicaleDaemon
#from tracim.lib.email import get_email_manager
from tracim.exceptions import AlreadyExistError
from tracim.exceptions import CommandAbortedError
from tracim.lib.core.group import GroupApi
from tracim.lib.core.user import UserApi
from tracim.models import User
from tracim.models import Group


class UserCommand(AppContextCommand):

This class should have a docstring.

The variable __class__ seems to be unused.

    ACTION_CREATE = 'create'
    ACTION_UPDATE = 'update'

    action = NotImplemented

    def get_description(self) -> str:
        return '''Create or update user.'''

    def get_parser(self, prog_name: str) -> argparse.ArgumentParser:
        parser = super().get_parser(prog_name)

        parser.add_argument(
            "-l",
            "--login",
            help='User login (email)',
            dest='login',
            required=True
        )

        parser.add_argument(
            "-p",
            "--password",
            help='User password',
            dest='password',
            required=False,
            default=None
        )

        parser.add_argument(
            "-g",
            "--add-to-group",
            help='Add user to group',
            dest='add_to_group',
            nargs='*',
            action=Extender,
            default=[],
        )

        parser.add_argument(
            "-rmg",
            "--remove-from-group",
            help='Remove user from group',
            dest='remove_from_group',
            nargs='*',
            action=Extender,
            default=[],
        )

        parser.add_argument(
            "--send-email",
            help='Send mail to user',
            dest='send_email',
            required=False,
            action='store_true',
            default=False,
        )

        return parser

    def _user_exist(self, login: str) -> User:
        return self._user_api.user_with_email_exists(login)

    def _get_group(self, name: str) -> Group:
        return self._group_api.get_one_with_name(name)

    def _add_user_to_named_group(
            self,
            user: str,
            group_name: str
    ) -> None:
        group = self._get_group(group_name)
        if user not in group.users:
            group.users.append(user)
        self._session.flush()

    def _remove_user_from_named_group(
            self,
            user: User,
            group_name: str
    ) -> None:
        group = self._get_group(group_name)
        if user in group.users:
            group.users.remove(user)
        self._session.flush()

    def _create_user(self, login: str, password: str, **kwargs) -> User:

The argument kwargs seems to be unused.

        if not password:
            if self._password_required():
                raise CommandAbortedError(
                    "You must provide -p/--password parameter"
                )
            password = ''

        try:
            user = self._user_api.create_user(email=login)
            user.password = password
            self._user_api.save(user)
            # TODO - G.M - 04-04-2018 - [Caldav] Check this code

TODO and FIXME comments should generally be avoided.

            # # We need to enable radicale if it not already done
            # daemons = DaemonsManager()
            # daemons.run('radicale', RadicaleDaemon)

            self._user_api.execute_created_user_actions(user)
        except IntegrityError:
            self._session.rollback()
            raise AlreadyExistError()

        return user

    def _update_password_for_login(self, login: str, password: str) -> None:
        user = self._user_api.get_one_by_email(login)
        user.password = password
        self._session.flush()
        transaction.commit()

    def take_app_action(

This method should have a docstring.

            self,
            parsed_args: argparse.Namespace,

The variable argparse does not seem to be defined.

            app_context: AppEnvironment
    ) -> None:
        # TODO - G.M - 05-04-2018 -Refactor this in order

TODO and FIXME comments should generally be avoided.

        # to not setup object var outside of __init__ .
        self._session = app_context['request'].dbsession

The attribute _session was defined outside __init__.

        self._app_config = app_context['registry'].settings['CFG']

The attribute _app_config was defined outside __init__.

        self._user_api = UserApi(

The attribute _user_api was defined outside __init__.

            current_user=None,
            session=self._session,
            config=self._app_config,
        )
        self._group_api = GroupApi(

The attribute _group_api was defined outside __init__.

            current_user=None,
            session=self._session,
        )
        user = self._proceed_user(parsed_args)
        self._proceed_groups(user, parsed_args)

        print("User created/updated")

    def _proceed_user(self, parsed_args: argparse.Namespace) -> User:

The variable argparse does not seem to be defined.

        self._check_context(parsed_args)

        if self.action == self.ACTION_CREATE:
            try:
                user = self._create_user(
                    login=parsed_args.login,
                    password=parsed_args.password
                )
            except AlreadyExistError:
                raise CommandAbortedError("Error: User already exist (use `user update` command instead)")

This line is too long as per the coding-style (106/100).

            # TODO - G.M - 04-04-2018 - [Email] Check this code

TODO and FIXME comments should generally be avoided.

            # if parsed_args.send_email:
            #     email_manager = get_email_manager()
            #     email_manager.notify_created_account(
            #         user=user,
            #         password=parsed_args.password,
            #     )

        else:
            if parsed_args.password:
                self._update_password_for_login(
                    login=parsed_args.login,
                    password=parsed_args.password
                )
            user = self._user_api.get_one_by_email(parsed_args.login)

        return user

    def _proceed_groups(
            self,
            user: User,
            parsed_args: argparse.Namespace

The variable argparse does not seem to be defined.

    ) -> None:
        # User always in "users" group
        self._add_user_to_named_group(user, 'users')

        for group_name in parsed_args.add_to_group:
            self._add_user_to_named_group(user, group_name)

        for group_name in parsed_args.remove_from_group:
            self._remove_user_from_named_group(user, group_name)

    def _password_required(self) -> bool:

This method could be written as a function/class method.

        # TODO - G.M - 04-04-2018 - [LDAP] Check this code

TODO and FIXME comments should generally be avoided.

        # if config.get('auth_type') == LDAPAuth.name:
        #     return False
        return True

    def _check_context(self, parsed_args: argparse.Namespace) -> None:

The variable argparse does not seem to be defined.

        # TODO - G.M - 04-04-2018 - [LDAP] Check this code

TODO and FIXME comments should generally be avoided.

        # if config.get('auth_type') == LDAPAuth.name:
        #     auth_instance = config.get('auth_instance')
        #     if not auth_instance.ldap_auth.user_exist(parsed_args.login):
        #         raise LDAPUserUnknown(
        #             "LDAP is enabled and user with login/email \"%s\" not found in LDAP" % parsed_args.login

This line is too long as per the coding-style (110/100).

        #         )
        pass


class CreateUserCommand(UserCommand):

This class should have a docstring.

    action = UserCommand.ACTION_CREATE


class UpdateUserCommand(UserCommand):

This class should have a docstring.

    action = UserCommand.ACTION_UPDATE


class LDAPUserUnknown(CommandAbortedError):

This class should have a docstring.

    pass