add command for initializedb and users

setup.py

@@ -25,6 +25,7 @@ requires = [
     'alembic',
     'hapic',
     'marshmallow',
+    'cliff',
 ]
 
 tests_require = [
@@ -75,7 +76,13 @@ setup(
             'main = tracim:main',
         ],
         'console_scripts': [
-            'initialize_tracim_db = tracim.scripts.initializedb:main',
+            'tracimcli = tracim.command:main',
         ],
+        'tracimcli': [
+            'test = tracim.command:TestTracimCommand',
+            'user_create = tracim.command.user:CreateUserCommand',
+            'user_update = tracim.command.user:UpdateUserCommand',
+            'db_init = tracim.command.initializedb:InitializeDBCommand',
+        ]
     },
 )

tracim/command/__init__.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+import sys
+import argparse
+import transaction
+
+from cliff.app import App
+from cliff.command import Command
+from cliff.commandmanager import CommandManager
+
+from pyramid.paster import bootstrap
+from tracim.exceptions import CommandAbortedError
+
+
+
+class TracimCLI(App):
+
+    def __init__(self):
+        super(TracimCLI, self).__init__(
+            description='TracimCli',
+            version='0.1',
+            command_manager=CommandManager('tracimcli'),
+            deferred_help=True,
+            )
+
+    def initialize_app(self, argv):
+        self.LOG.debug('initialize_app')
+
+    def prepare_to_run_command(self, cmd):
+        self.LOG.debug('prepare_to_run_command %s', cmd.__class__.__name__)
+
+    def clean_up(self, cmd, result, err):
+        self.LOG.debug('clean_up %s', cmd.__class__.__name__)
+        if err:
+            self.LOG.debug('got an error: %s', err)
+
+
+def main(argv=sys.argv[1:]):
+    myapp = TracimCLI()
+    return myapp.run(argv)
+
+
+if __name__ == "__main__":
+    main()
+
+
+class AppContextCommand(Command):
+    """
+    Command who initialize app context at beginning of take_action method.
+    """
+    auto_setup_context = True
+
+    def take_action(self, parsed_args):
+        super(AppContextCommand, self).take_action(parsed_args)
+        if self.auto_setup_context:
+            with bootstrap(parsed_args.config_file) as app_context:
+                with app_context['request'].tm:
+                    self.take_app_action(parsed_args, app_context)
+
+    def get_parser(self, prog_name):
+        parser = super(AppContextCommand, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "-c",
+            "--config",
+            help='application config file to read (default: development.ini)',
+            dest='config_file',
+            default="development.ini"
+        )
+        return parser
+
+    # def run(self, parsed_args):
+    #     super().run(parsed_args)
+    #     transaction.commit()
+
+
+class TestTracimCommand(AppContextCommand):
+
+    def take_app_action(self, parser, app_context):
+        print('test')
+
+
+class Extender(argparse.Action):
+    """
+    Copied class from http://stackoverflow.com/a/12461237/801924
+    """
+    def __call__(self, parser, namespace, values, option_strings=None):
+        # Need None here incase `argparse.SUPPRESS` was supplied for `dest`
+        dest = getattr(namespace, self.dest, None)
+        # print dest,self.default,values,option_strings
+        if not hasattr(dest, 'extend') or dest == self.default:
+            dest = []
+            setattr(namespace, self.dest, dest)
+            # if default isn't set to None, this method might be called
+            # with the default as `values` for other arguements which
+            # share this destination.
+            parser.set_defaults(**{self.dest: None})
+        try:
+            dest.extend(values)
+        except ValueError:
+            dest.append(values)

tracim/command/initializedb.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+import os
+import sys
+import transaction
+
+from pyramid.paster import (
+    get_appsettings,
+    setup_logging,
+    )
+from pyramid.scripts.common import parse_vars
+
+from tracim.command import AppContextCommand
+from tracim.models.meta import DeclarativeBase
+from tracim.models import (
+    get_engine,
+    get_session_factory,
+    get_tm_session,
+    )
+
+
+class InitializeDBCommand(AppContextCommand):
+    auto_setup_context = False
+
+    def get_description(self):
+        return "Initialize DB"
+
+    def get_epilog(self):
+        return "################"
+
+    def get_parser(self, prog_name):
+        parser = super().get_parser(prog_name)
+        return parser
+
+    def take_action(self, parsed_args):
+        super(InitializeDBCommand, self).take_action(parsed_args)
+        config_uri = parsed_args.config_file
+
+        setup_logging(config_uri)
+        settings = get_appsettings(config_uri)
+        engine = get_engine(settings)
+        DeclarativeBase.metadata.create_all(engine)
+        session_factory = get_session_factory(engine)
+
+        with transaction.manager:
+            pass
+            # dbsession = get_tm_session(session_factory, transaction.manager)
+            # model = MyModel(name='one', value=1)
+            # dbsession.add(model)
+            # Add global manager data, just for test

tracim/command/user.py

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+import transaction
+from sqlalchemy.exc import IntegrityError
+
+from tracim import CFG
+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
+
+
+class UserCommand(AppContextCommand):
+
+    ACTION_CREATE = 'create'
+    ACTION_UPDATE = 'update'
+
+    action = NotImplemented
+
+    def get_description(self):
+        return '''Create or update user.'''
+
+    def get_parser(self, prog_name):
+        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):
+        return self._user_api.user_with_email_exists(login)
+
+    def _get_group(self, name):
+        return self._group_api.get_one_with_name(name)
+
+    def _add_user_to_named_group(self, user, group_name):
+        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, group_name):
+        group = self._get_group(group_name)
+        if user in group.users:
+            group.users.remove(user)
+        self._session.flush()
+
+    def _create_user(self, login, password, **kwargs):
+        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
+            # # 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, password):
+        user = self._user_api.get_one_by_email(login)
+        user.password = password
+        self._session.flush()
+        transaction.commit()
+
+    def take_app_action(self, parsed_args, app_context):
+        # TODO - G.M - 05-04-2018 -Refactor this in order
+        # to not setup object var outside of __init__ .
+        self._session = app_context['request'].dbsession
+        self._app_config = app_context['registry'].settings['CFG']
+        self._user_api = UserApi(
+            current_user=None,
+            session=self._session,
+            config=self._app_config,
+        )
+        self._group_api = GroupApi(
+            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):
+        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)")
+            # TODO - G.M - 04-04-2018 - [Email] Check this code
+            # 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, parsed_args):
+        # 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):
+        # TODO - G.M - 04-04-2018 - [LDAP] Check this code
+        # if config.get('auth_type') == LDAPAuth.name:
+        #     return False
+        return True
+
+    def _check_context(self, parsed_args):
+        # TODO - G.M - 04-04-2018 - [LDAP] Check this code
+        # 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
+        #         )
+        pass
+
+
+class CreateUserCommand(UserCommand):
+    action = UserCommand.ACTION_CREATE
+
+
+class UpdateUserCommand(UserCommand):
+    action = UserCommand.ACTION_UPDATE
+
+
+class LDAPUserUnknown(CommandAbortedError):
+    pass

tracim/scripts/__init__.py

@@ -1,2 +0,0 @@
-# -*- coding: utf-8 -*-
-# package

tracim/scripts/initializedb.py

@@ -1,46 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import sys
-import transaction
-
-from pyramid.paster import (
-    get_appsettings,
-    setup_logging,
-    )
-
-from pyramid.scripts.common import parse_vars
-
-from ..models.meta import DeclarativeBase
-from ..models import (
-    get_engine,
-    get_session_factory,
-    get_tm_session,
-    )
-
-
-def usage(argv):
-    cmd = os.path.basename(argv[0])
-    print('usage: %s <config_uri> [var=value]\n'
-          '(example: "%s development.ini")' % (cmd, cmd))
-    sys.exit(1)
-
-
-def main(argv=sys.argv):
-    if len(argv) < 2:
-        usage(argv)
-    config_uri = argv[1]
-    options = parse_vars(argv[2:])
-    setup_logging(config_uri)
-    settings = get_appsettings(config_uri, options=options)
-
-    engine = get_engine(settings)
-    DeclarativeBase.metadata.create_all(engine)
-
-    session_factory = get_session_factory(engine)
-    # TODO - G.M - 28-03-2018 - [Cleanup] Remove code related to example
-    with transaction.manager:
-        pass
-        # dbsession = get_tm_session(session_factory, transaction.manager)
-        # model = MyModel(name='one', value=1)
-        # dbsession.add(model)
-        # Add global manager data, just for test