Merge branch 'feature/578_add_api_for_workspace/apps' of github.com:tracim/tracim_backend into fix/better_api_doc

.travis.yml

@@ -5,6 +5,13 @@ python:
   - "3.5"
   - "3.6"
 
+services:
+  - docker
+  - redis-server
+
+before_install:
+  - docker pull mailhog/mailhog
+  - docker run -d -p 1025:1025 -p 8025:8025 mailhog/mailhog
 install:
   - pip install --upgrade pip setuptools
   - pip install -e ".[testing]"

README.md

@@ -19,6 +19,7 @@ on Debian Stretch (9) with sudo:
     sudo apt update
     sudo apt install git
     sudo apt install python3 python3-venv python3-dev python3-pip
+    sudo apt install redis-server
 
 ### Get the source ###
 
@@ -112,10 +113,20 @@ run wsgidav server:
 
 ## Run Tests and others checks ##
 
+Before running some functional test related to email, you need a local working *MailHog*
+see here : https://github.com/mailhog/MailHog
+
+You can run it this way with docker :
+
+    docker pull mailhog/mailhog
+    docker run -d -p 1025:1025 -p 8025:8025 mailhog/mailhog
+
 Run your project's tests:
 
     pytest
 
+### Lints and others checks ###
+
 Run mypy checks:
 
     mypy --ignore-missing-imports --disallow-untyped-defs tracim

development.ini.sample

@@ -2,7 +2,9 @@
 # app configuration
 # https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/environment.html
 ###
-[app:main]
+[pipeline:main]
+pipeline = tracim_web
+[app:tracim_web]
 use = egg:tracim_backend
 
 pyramid.reload_templates = true
@@ -13,6 +15,12 @@ pyramid.default_locale_name = en
 pyramid.includes =
     pyramid_debugtoolbar
 
+[pipeline:webdav]
+pipeline = tracim_webdav
+[app:tracim_webdav]
+use = egg:tracim_backend#webdav
+
+[DEFAULT]
 sqlalchemy.url = sqlite:///%(here)s/tracim.sqlite
 
 retry.attempts = 3

setup.py

@@ -24,7 +24,7 @@ requires = [
     'zope.sqlalchemy',
     'alembic',
     # API
-    'hapic',
+    'hapic>=0.41',
     'marshmallow <3.0.0a1,>2.0.0',
     # CLI
     'cliff',
@@ -35,6 +35,11 @@ requires = [
     'filedepot',
     'babel',
     'python-slugify',
+    # mail-notifier
+    'mako',
+    'lxml',
+    'redis',
+    'rq',
 ]
 
 tests_require = [
@@ -43,6 +48,7 @@ tests_require = [
     'pytest-cov',
     'pep8',
     'mypy',
+    'requests'
 ]
 
 mysql_require = [
@@ -90,7 +96,8 @@ setup(
     install_requires=requires,
     entry_points={
         'paste.app_factory': [
-            'main = tracim:main',
+            'main = tracim:web',
+            'webdav = tracim:webdav'
         ],
         'console_scripts': [
             'tracimcli = tracim.command:main',

tests_configs.ini

@@ -0,0 +1,57 @@
+[base_test]
+sqlalchemy.url = sqlite:///:memory:
+depot_storage_name = test
+depot_storage_dir = /tmp/test/depot
+user.auth_token.validity = 604800
+preview_cache_dir = /tmp/test/preview_cache
+
+[mail_test]
+sqlalchemy.url = sqlite:///:memory:
+depot_storage_name = test
+depot_storage_dir = /tmp/test/depot
+user.auth_token.validity = 604800
+preview_cache_dir = /tmp/test/preview_cache
+email.notification.activated = true
+email.notification.from.email = test_user_from+{user_id}@localhost
+email.notification.from.default_label = Tracim Notifications
+email.notification.reply_to.email = test_user_reply+{content_id}@localhost
+email.notification.references.email = test_user_refs+{content_id}@localhost
+email.notification.content_update.template.html = %(here)s/tracim/templates/mail/content_update_body_html.mak
+email.notification.content_update.template.text = %(here)s/tracim/templates/mail/content_update_body_text.mak
+email.notification.created_account.template.html = %(here)s/tracim/templates/mail/created_account_body_html.mak
+email.notification.created_account.template.text = %(here)s/tracim/templates/mail/created_account_body_text.mak
+# Note: items between { and } are variable names. Do not remove / rename them
+email.notification.content_update.subject = [{website_title}] [{workspace_label}] {content_label} ({content_status_label})
+email.notification.created_account.subject = [{website_title}] Created account
+# processing_mode may be sync or async
+email.notification.processing_mode = sync
+email.notification.smtp.server = 127.0.0.1
+email.notification.smtp.port = 1025
+email.notification.smtp.user = test_user
+email.notification.smtp.password = just_a_password
+
+[mail_test_async]
+sqlalchemy.url = sqlite:///:memory:
+depot_storage_name = test
+depot_storage_dir = /tmp/test/depot
+user.auth_token.validity = 604800
+preview_cache_dir = /tmp/test/preview_cache
+email.notification.activated = true
+email.notification.from.email = test_user_from+{user_id}@localhost
+email.notification.from.default_label = Tracim Notifications
+email.notification.reply_to.email = test_user_reply+{content_id}@localhost
+email.notification.references.email = test_user_refs+{content_id}@localhost
+email.notification.content_update.template.html = %(here)s/tracim/templates/mail/content_update_body_html.mak
+email.notification.content_update.template.text = %(here)s/tracim/templates/mail/content_update_body_text.mak
+email.notification.created_account.template.html = %(here)s/tracim/templates/mail/created_account_body_html.mak
+email.notification.created_account.template.text = %(here)s/tracim/templates/mail/created_account_body_text.mak
+# Note: items between { and } are variable names. Do not remove / rename them
+email.notification.content_update.subject = [{website_title}] [{workspace_label}] {content_label} ({content_status_label})
+email.notification.created_account.subject = [{website_title}] Created account
+# processing_mode may be sync or async
+email.notification.processing_mode = sync
+email.processing_mode = async
+email.notification.smtp.server = 127.0.0.1
+email.notification.smtp.port = 1025
+email.notification.smtp.user = test_user
+email.notification.smtp.password = just_a_password

tracim/__init__.py

@@ -5,6 +5,8 @@ import time
 from pyramid.config import Configurator
 from pyramid.authentication import BasicAuthAuthenticationPolicy
 from hapic.ext.pyramid import PyramidContext
+from pyramid.exceptions import NotFound
+from sqlalchemy.exc import OperationalError
 
 from tracim.extensions import hapic
 from tracim.config import CFG
@@ -13,6 +15,7 @@ from tracim.lib.utils.authentification import basic_auth_check_credentials
 from tracim.lib.utils.authentification import BASIC_AUTH_WEBUI_REALM
 from tracim.lib.utils.authorization import AcceptAllAuthorizationPolicy
 from tracim.lib.utils.authorization import TRACIM_DEFAULT_PERM
+from tracim.lib.webdav import WebdavAppFactory
 from tracim.views import BASE_API_V2
 from tracim.views.core_api.session_controller import SessionController
 from tracim.views.core_api.system_controller import SystemController
@@ -22,9 +25,11 @@ from tracim.views.errors import ErrorSchema
 from tracim.lib.utils.cors import add_cors_support
 
 
-def main(global_config, **settings):
+def web(global_config, **local_settings):
     """ This function returns a Pyramid WSGI application.
     """
+    settings = global_config
+    settings.update(local_settings)
     # set CFG object
     app_config = CFG(settings)
     app_config.configure_filedepot()
@@ -52,12 +57,15 @@ def main(global_config, **settings):
     # Add SqlAlchemy DB
     configurator.include('.models')
     # set Hapic
-    hapic.set_context(
-        PyramidContext(
-            configurator=configurator,
-            default_error_builder=ErrorSchema()
-        )
+    context = PyramidContext(
+        configurator=configurator,
+        default_error_builder=ErrorSchema(),
+        debug=app_config.DEBUG,
     )
+    hapic.set_context(context)
+    context.handle_exception(NotFound, 404)
+    context.handle_exception(OperationalError, 500)
+    context.handle_exception(Exception, 500)
     # Add controllers
     session_controller = SessionController()
     system_controller = SystemController()
@@ -73,3 +81,12 @@ def main(global_config, **settings):
         'API of Tracim v2',
     )
     return configurator.make_wsgi_app()
+
+
+def webdav(global_config, **local_settings):
+    settings = global_config
+    settings.update(local_settings)
+    app_factory = WebdavAppFactory(
+        tracim_config_file_path=settings['__file__'],
+    )
+    return app_factory.get_wsgi_app()

tracim/command/user.py

@@ -12,6 +12,7 @@ from tracim.command import Extender
 #from tracim.lib.daemons import RadicaleDaemon
 #from tracim.lib.email import get_email_manager
 from tracim.exceptions import AlreadyExistError
+from tracim.exceptions import NotificationNotSend
 from tracim.exceptions import CommandAbortedError
 from tracim.lib.core.group import GroupApi
 from tracim.lib.core.user import UserApi
@@ -106,7 +107,13 @@ class UserCommand(AppContextCommand):
             group.users.remove(user)
         self._session.flush()
 
-    def _create_user(self, login: str, password: str, **kwargs) -> User:
+    def _create_user(
+            self,
+            login: str,
+            password: str,
+            do_notify: bool,
+            **kwargs
+    ) -> User:
         if not password:
             if self._password_required():
                 raise CommandAbortedError(
@@ -115,18 +122,23 @@ class UserCommand(AppContextCommand):
             password = ''
 
         try:
-            user = self._user_api.create_user(email=login)
-            user.password = password
-            self._user_api.save(user)
+            user = self._user_api.create_user(
+                email=login,
+                password=password,
+                do_save=True,
+                do_notify=do_notify,
+            )
             # 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()
+        except NotificationNotSend as exception:
+            self._session.rollback()
+            raise exception
 
         return user
 
@@ -167,10 +179,13 @@ class UserCommand(AppContextCommand):
             try:
                 user = self._create_user(
                     login=parsed_args.login,
-                    password=parsed_args.password
+                    password=parsed_args.password,
+                    do_notify=parsed_args.send_email,
                 )
             except AlreadyExistError:
                 raise CommandAbortedError("Error: User already exist (use `user update` command instead)")
+            except NotificationNotSend:
+                raise CommandAbortedError("Error: Cannot send email notification, user not created.")
             # TODO - G.M - 04-04-2018 - [Email] Check this code
             # if parsed_args.send_email:
             #     email_manager = get_email_manager()

tracim/command/webdav.py

@@ -6,6 +6,7 @@ from waitress import serve
 
 from tracim.command import AppContextCommand
 from tracim.lib.webdav import WebdavAppFactory
+from wsgi import webdav_app
 
 
 class WebdavRunnerCommand(AppContextCommand):
@@ -22,8 +23,5 @@ class WebdavRunnerCommand(AppContextCommand):
         super(WebdavRunnerCommand, self).take_action(parsed_args)
         tracim_config = parsed_args.config_file
         # TODO - G.M - 16-04-2018 - Allow specific webdav config file
-        app_factory = WebdavAppFactory(
-            tracim_config_file_path=tracim_config,
-        )
-        app = app_factory.get_wsgi_app()
+        app = webdav_app(tracim_config)
         serve(app, port=app.config['port'], host=app.config['host'])

tracim/config.py

@@ -4,6 +4,8 @@ from paste.deploy.converters import asbool
 from tracim.lib.utils.logger import logger
 from depot.manager import DepotManager
 
+from tracim.models.data import ActionDescription, ContentType
+
 
 class CFG(object):
     """Object used for easy access to config file parameters."""
@@ -128,90 +130,91 @@ class CFG(object):
             '604800',
         ))
 
+        self.DEBUG = asbool(settings.get('debug', False))
         # TODO - G.M - 27-03-2018 - [Email] Restore email config
         ###
         # EMAIL related stuff (notification, reply)
-        ###
-        #
-        # self.EMAIL_NOTIFICATION_NOTIFIED_EVENTS = [
-        #     # ActionDescription.COMMENT,
-        #     # ActionDescription.CREATION,
-        #     # ActionDescription.EDITION,
-        #     # ActionDescription.REVISION,
-        #     # ActionDescription.STATUS_UPDATE
-        # ]
-        #
-        # self.EMAIL_NOTIFICATION_NOTIFIED_CONTENTS = [
-        #     # ContentType.Page,
-        #     # ContentType.Thread,
-        #     # ContentType.File,
-        #     # ContentType.Comment,
-        #     # ContentType.Folder -- Folder is skipped
-        # ]
-        # if settings.get('email.notification.from'):
-        #     raise Exception(
-        #         'email.notification.from configuration is deprecated. '
-        #         'Use instead email.notification.from.email and '
-        #         'email.notification.from.default_label.'
-        #     )
-        #
-        # self.EMAIL_NOTIFICATION_FROM_EMAIL = settings.get(
-        #     'email.notification.from.email',
-        # )
-        # self.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL = settings.get(
-        #     'email.notification.from.default_label'
-        # )
-        # self.EMAIL_NOTIFICATION_REPLY_TO_EMAIL = settings.get(
-        #     'email.notification.reply_to.email',
-        # )
-        # self.EMAIL_NOTIFICATION_REFERENCES_EMAIL = settings.get(
-        #     'email.notification.references.email'
-        # )
-        # self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_HTML = settings.get(
-        #     'email.notification.content_update.template.html',
-        # )
-        # self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_TEXT = settings.get(
-        #     'email.notification.content_update.template.text',
-        # )
-        # self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_HTML = settings.get(
-        #     'email.notification.created_account.template.html',
-        #     './tracim/templates/mail/created_account_body_html.mak',
-        # )
-        # self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_TEXT = settings.get(
-        #     'email.notification.created_account.template.text',
-        #     './tracim/templates/mail/created_account_body_text.mak',
-        # )
-        # self.EMAIL_NOTIFICATION_CONTENT_UPDATE_SUBJECT = settings.get(
-        #     'email.notification.content_update.subject',
-        # )
-        # self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_SUBJECT = settings.get(
-        #     'email.notification.created_account.subject',
-        #     '[{website_title}] Created account',
-        # )
-        # self.EMAIL_NOTIFICATION_PROCESSING_MODE = settings.get(
-        #     'email.notification.processing_mode',
-        # )
-        #
+        ##
+
+        self.EMAIL_NOTIFICATION_NOTIFIED_EVENTS = [
+            ActionDescription.COMMENT,
+            ActionDescription.CREATION,
+            ActionDescription.EDITION,
+            ActionDescription.REVISION,
+            ActionDescription.STATUS_UPDATE
+        ]
+
+        self.EMAIL_NOTIFICATION_NOTIFIED_CONTENTS = [
+            ContentType.Page,
+            ContentType.Thread,
+            ContentType.File,
+            ContentType.Comment,
+            # ContentType.Folder -- Folder is skipped
+        ]
+        if settings.get('email.notification.from'):
+            raise Exception(
+                'email.notification.from configuration is deprecated. '
+                'Use instead email.notification.from.email and '
+                'email.notification.from.default_label.'
+            )
+
+        self.EMAIL_NOTIFICATION_FROM_EMAIL = settings.get(
+            'email.notification.from.email',
+        )
+        self.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL = settings.get(
+            'email.notification.from.default_label'
+        )
+        self.EMAIL_NOTIFICATION_REPLY_TO_EMAIL = settings.get(
+            'email.notification.reply_to.email',
+        )
+        self.EMAIL_NOTIFICATION_REFERENCES_EMAIL = settings.get(
+            'email.notification.references.email'
+        )
+        self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_HTML = settings.get(
+            'email.notification.content_update.template.html',
+        )
+        self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_TEXT = settings.get(
+            'email.notification.content_update.template.text',
+        )
+        self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_HTML = settings.get(
+            'email.notification.created_account.template.html',
+            './tracim/templates/mail/created_account_body_html.mak',
+        )
+        self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_TEXT = settings.get(
+            'email.notification.created_account.template.text',
+            './tracim/templates/mail/created_account_body_text.mak',
+        )
+        self.EMAIL_NOTIFICATION_CONTENT_UPDATE_SUBJECT = settings.get(
+            'email.notification.content_update.subject',
+        )
+        self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_SUBJECT = settings.get(
+            'email.notification.created_account.subject',
+            '[{website_title}] Created account',
+        )
+        self.EMAIL_NOTIFICATION_PROCESSING_MODE = settings.get(
+            'email.notification.processing_mode',
+        )
+
         self.EMAIL_NOTIFICATION_ACTIVATED = asbool(settings.get(
             'email.notification.activated',
         ))
-        # self.EMAIL_NOTIFICATION_SMTP_SERVER = settings.get(
-        #     'email.notification.smtp.server',
-        # )
-        # self.EMAIL_NOTIFICATION_SMTP_PORT = settings.get(
-        #     'email.notification.smtp.port',
-        # )
-        # self.EMAIL_NOTIFICATION_SMTP_USER = settings.get(
-        #     'email.notification.smtp.user',
-        # )
-        # self.EMAIL_NOTIFICATION_SMTP_PASSWORD = settings.get(
-        #     'email.notification.smtp.password',
-        # )
-        # self.EMAIL_NOTIFICATION_LOG_FILE_PATH = settings.get(
-        #     'email.notification.log_file_path',
-        #     None,
-        # )
-        #
+        self.EMAIL_NOTIFICATION_SMTP_SERVER = settings.get(
+            'email.notification.smtp.server',
+        )
+        self.EMAIL_NOTIFICATION_SMTP_PORT = settings.get(
+            'email.notification.smtp.port',
+        )
+        self.EMAIL_NOTIFICATION_SMTP_USER = settings.get(
+            'email.notification.smtp.user',
+        )
+        self.EMAIL_NOTIFICATION_SMTP_PASSWORD = settings.get(
+            'email.notification.smtp.password',
+        )
+        self.EMAIL_NOTIFICATION_LOG_FILE_PATH = settings.get(
+            'email.notification.log_file_path',
+            None,
+        )
+
         # self.EMAIL_REPLY_ACTIVATED = asbool(settings.get(
         #     'email.reply.activated',
         #     False,
@@ -267,36 +270,36 @@ class CFG(object):
         #         mandatory_msg.format('email.reply.lockfile_path')
         #     )
         #
-        # self.EMAIL_PROCESSING_MODE = settings.get(
-        #     'email.processing_mode',
-        #     'sync',
-        # ).upper()
-        #
-        # if self.EMAIL_PROCESSING_MODE not in (
-        #         self.CST.ASYNC,
-        #         self.CST.SYNC,
-        # ):
-        #     raise Exception(
-        #         'email.processing_mode '
-        #         'can ''be "{}" or "{}", not "{}"'.format(
-        #             self.CST.ASYNC,
-        #             self.CST.SYNC,
-        #             self.EMAIL_PROCESSING_MODE,
-        #         )
-        #     )
-        #
-        # self.EMAIL_SENDER_REDIS_HOST = settings.get(
-        #     'email.async.redis.host',
-        #     'localhost',
-        # )
-        # self.EMAIL_SENDER_REDIS_PORT = int(settings.get(
-        #     'email.async.redis.port',
-        #     6379,
-        # ))
-        # self.EMAIL_SENDER_REDIS_DB = int(settings.get(
-        #     'email.async.redis.db',
-        #     0,
-        # ))
+        self.EMAIL_PROCESSING_MODE = settings.get(
+            'email.processing_mode',
+            'sync',
+        ).upper()
+
+        if self.EMAIL_PROCESSING_MODE not in (
+                self.CST.ASYNC,
+                self.CST.SYNC,
+        ):
+            raise Exception(
+                'email.processing_mode '
+                'can ''be "{}" or "{}", not "{}"'.format(
+                    self.CST.ASYNC,
+                    self.CST.SYNC,
+                    self.EMAIL_PROCESSING_MODE,
+                )
+            )
+
+        self.EMAIL_SENDER_REDIS_HOST = settings.get(
+            'email.async.redis.host',
+            'localhost',
+        )
+        self.EMAIL_SENDER_REDIS_PORT = int(settings.get(
+            'email.async.redis.port',
+            6379,
+        ))
+        self.EMAIL_SENDER_REDIS_DB = int(settings.get(
+            'email.async.redis.db',
+            0,
+        ))
 
         ###
         # WSGIDAV (Webdav server)

tracim/exceptions.py

@@ -61,7 +61,7 @@ class SameValueError(ValueError):
     pass
 
 
-class NotAuthentificated(TracimException):
+class NotAuthenticated(TracimException):
     pass
 
 
@@ -96,5 +96,10 @@ class WrongUserPassword(TracimException):
 class UserDoesNotExist(TracimException):
     pass
 
+
 class UserNotFoundInTracimRequest(TracimException):
-    pass
+    pass
+
+
+class NotificationNotSend(TracimException):
+    pass

tracim/fixtures/content.py

@@ -73,12 +73,14 @@ class Content(Fixture):
             workspace=w1,
             label='w1f1',
             do_save=True,
+            do_notify=False,
         )
         w1f2 = content_api.create(
             content_type=ContentType.Folder,
             workspace=w1,
             label='w1f2',
             do_save=True,
+            do_notify=False,
         )
 
         w2f1 = content_api.create(
@@ -86,12 +88,14 @@ class Content(Fixture):
             workspace=w2,
             label='w2f1',
             do_save=True,
+            do_notify=False,
         )
         w2f2 = content_api.create(
             content_type=ContentType.Folder,
             workspace=w2,
             label='w2f2',
             do_save=True,
+            do_notify=False,
         )
 
         w3f1 = content_api.create(
@@ -99,6 +103,7 @@ class Content(Fixture):
             workspace=w3,
             label='w3f3',
             do_save=True,
+            do_notify=False,
         )
 
         # Pages, threads, ..
@@ -108,6 +113,7 @@ class Content(Fixture):
             parent=w1f1,
             label='w1f1p1',
             do_save=True,
+            do_notify=False,
         )
         w1f1t1 = content_api.create(
             content_type=ContentType.Thread,
@@ -115,6 +121,7 @@ class Content(Fixture):
             parent=w1f1,
             label='w1f1t1',
             do_save=False,
+            do_notify=False,
         )
         w1f1t1.description = 'w1f1t1 description'
         self._session.add(w1f1t1)
@@ -124,6 +131,7 @@ class Content(Fixture):
             parent=w1f1,
             label='w1f1d1',
             do_save=False,
+            do_notify=False,
         )
         w1f1d1_txt.file_extension = '.txt'
         w1f1d1_txt.depot_file = FileIntent(
@@ -138,6 +146,7 @@ class Content(Fixture):
             parent=w1f1,
             label='w1f1d2',
             do_save=False,
+            do_notify=False,
         )
         w1f1d2_html.file_extension = '.html'
         w1f1d2_html.depot_file = FileIntent(
@@ -152,6 +161,7 @@ class Content(Fixture):
             label='w1f1f1',
             parent=w1f1,
             do_save=True,
+            do_notify=False,
         )
 
         w2f1p1 = content_api.create(
@@ -160,5 +170,6 @@ class Content(Fixture):
             parent=w2f1,
             label='w2f1p1',
             do_save=True,
+            do_notify=False,
         )
         self._session.flush()

tracim/lib/core/content.py

@@ -376,7 +376,7 @@ class ContentApi(object):
 
         return result
 
-    def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', do_save=False, is_temporary: bool=False) -> Content:
+    def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', do_save=False, is_temporary: bool=False, do_notify=True) -> Content:
         assert content_type in ContentType.allowed_types()
 
         if content_type == ContentType.Folder and not label:
@@ -399,7 +399,7 @@ class ContentApi(object):
 
         if do_save:
             self._session.add(content)
-            self.save(content, ActionDescription.CREATION)
+            self.save(content, ActionDescription.CREATION, do_notify=do_notify)
         return content
 
 
@@ -1127,8 +1127,9 @@ class ContentApi(object):
         :return:
         """
         NotifierFactory.create(
-            self._config,
-            self._user
+            config=self._config,
+            current_user=self._user,
+            session=self._session,
         ).notify_content_update(content)
 
     def get_keywords(self, search_string, search_string_separators=None) -> [str]:

tracim/lib/core/notifications.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
+from sqlalchemy.orm import Session
 
+from tracim import CFG
 from tracim.lib.utils.logger import logger
 from tracim.models.auth import User
 from tracim.models.data import Content
@@ -9,7 +11,11 @@ class INotifier(object):
     """
     Interface for Notifier instances
     """
-    def __init__(self, config, current_user: User=None):
+    def __init__(self,
+                 config: CFG,
+                 session: Session,
+                 current_user: User=None,
+    ) -> None:
         pass
 
     def notify_content_update(self, content: Content):
@@ -19,17 +25,28 @@ class INotifier(object):
 class NotifierFactory(object):
 
     @classmethod
-    def create(cls, config, current_user: User=None) -> INotifier:
+    def create(cls, config, session, current_user: User=None) -> INotifier:
         if not config.EMAIL_NOTIFICATION_ACTIVATED:
-            return DummyNotifier(config, current_user)
-        return EmailNotifier(config, current_user)
+            return DummyNotifier(config, session, current_user)
+        from tracim.lib.mail_notifier.notifier import EmailNotifier
+        return EmailNotifier(config, session, current_user)
 
 
 class DummyNotifier(INotifier):
     send_count = 0
 
-    def __init__(self, config, current_user: User=None):
-        INotifier.__init__(config, current_user)
+    def __init__(
+            self,
+            config: CFG,
+            session: Session,
+            current_user: User=None
+    ) -> None:
+        INotifier.__init__(
+            self,
+            config,
+            session,
+            current_user,
+        )
         logger.info(self, 'Instantiating Dummy Notifier')
 
     def notify_content_update(self, content: Content):
@@ -38,8 +55,3 @@ class DummyNotifier(INotifier):
             self,
             'Fake notifier, do not send notification for update of content {}'.format(content.content_id)  # nopep8
         )
-
-
-class EmailNotifier(INotifier):
-    # TODO - G.M [emailNotif] move and restore Email Notifier in another file.
-    pass

tracim/lib/core/user.py

@@ -1,9 +1,12 @@
 # -*- coding: utf-8 -*-
 import threading
+from smtplib import SMTPException
 
 import transaction
 import typing as typing
 
+from tracim.exceptions import NotificationNotSend
+from tracim.lib.mail_notifier.notifier import get_email_manager
 from sqlalchemy.orm import Session
 
 from tracim import CFG
@@ -114,8 +117,9 @@ class UserApi(object):
             user: User,
             name: str=None,
             email: str=None,
-            do_save=True,
+            password: str=None,
             timezone: str='',
+            do_save=True,
     ) -> None:
         if name is not None:
             user.display_name = name
@@ -123,16 +127,56 @@ class UserApi(object):
         if email is not None:
             user.email = email
 
+        if password is not None:
+            user.password = password
+
         user.timezone = timezone
 
         if do_save:
             self.save(user)
 
-    def create_user(self, email=None, groups=[], save_now=False) -> User:
+    def create_user(
+        self,
+        email,
+        password: str = None,
+        name: str = None,
+        timezone: str = '',
+        groups=[],
+        do_save: bool=True,
+        do_notify: bool=True,
+    ) -> User:
+        new_user = self.create_minimal_user(email, groups, save_now=False)
+        self.update(
+            user=new_user,
+            name=name,
+            email=email,
+            password=password,
+            timezone=timezone,
+            do_save=False,
+        )
+        if do_notify:
+            try:
+                email_manager = get_email_manager(self._config, self._session)
+                email_manager.notify_created_account(
+                    new_user,
+                    password=password
+                )
+            except SMTPException as e:
+                raise NotificationNotSend()
+        if do_save:
+            self.save(new_user)
+        return new_user
+
+    def create_minimal_user(
+            self,
+            email,
+            groups=[],
+            save_now=False
+    ) -> User:
+        """Previous create_user method"""
         user = User()
 
-        if email:
-            user.email = email
+        user.email = email
 
         for group in groups:
             user.groups.append(group)

tracim/lib/core/userworkspace.py

@@ -49,6 +49,7 @@ class RoleApi(object):
         """
         Return WorkspaceInContext object from Workspace
         """
+        assert self._config
         workspace = UserRoleWorkspaceInContext(
             user_role=user_role,
             dbsession=self._session,
@@ -138,7 +139,8 @@ class RoleApi(object):
         workspace:Workspace
     ) -> typing.List[UserRoleInWorkspace]:
         return self._session.query(UserRoleInWorkspace)\
-            .filter(UserRoleInWorkspace.workspace_id == workspace.workspace_id).all()  # nopep8
+            .filter(UserRoleInWorkspace.workspace_id==workspace.workspace_id)\
+            .all()
 
     def save(self, role: UserRoleInWorkspace) -> None:
         self._session.flush()

tracim/lib/mail_notifier/daemon.py

@@ -0,0 +1,61 @@
+from sqlalchemy.orm import collections
+
+from tracim.lib.utils.logger import logger
+from tracim.lib.utils.utils import get_rq_queue
+from tracim.lib.utils.utils import get_redis_connection
+from rq.dummy import do_nothing
+from rq.worker import StopRequested
+from rq import Connection as RQConnection
+from rq import Worker as BaseRQWorker
+
+
+class FakeDaemon(object):
+    """
+    Temporary class for transition between tracim 1 and tracim 2
+    """
+    def __init__(self, config, *args, **kwargs):
+        pass
+
+
+class MailSenderDaemon(FakeDaemon):
+    # NOTE: use *args and **kwargs because parent __init__ use strange
+    # * parameter
+    def __init__(self, config, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.config = config
+        self.worker = None  # type: RQWorker
+
+    def append_thread_callback(self, callback: collections.Callable) -> None:
+        logger.warning('MailSenderDaemon not implement append_thread_callback')
+        pass
+
+    def stop(self) -> None:
+        # When _stop_requested at False, tracim.lib.daemons.RQWorker
+        # will raise StopRequested exception in worker thread after receive a
+        # job.
+        self.worker._stop_requested = True
+        redis_connection = get_redis_connection(self.config)
+        queue = get_rq_queue(redis_connection, 'mail_sender')
+        queue.enqueue(do_nothing)
+
+    def run(self) -> None:
+
+        with RQConnection(get_redis_connection(self.config)):
+            self.worker = RQWorker(['mail_sender'])
+            self.worker.work()
+
+
+class RQWorker(BaseRQWorker):
+    def _install_signal_handlers(self):
+        # RQ Worker is designed to work in main thread
+        # So we have to disable these signals (we implement server stop in
+        # MailSenderDaemon.stop method).
+        pass
+
+    def dequeue_job_and_maintain_ttl(self, timeout):
+        # RQ Worker is designed to work in main thread, so we add behaviour
+        # here: if _stop_requested has been set to True, raise the standard way
+        # StopRequested exception to stop worker.
+        if self._stop_requested:
+            raise StopRequested()
+        return super().dequeue_job_and_maintain_ttl(timeout)

tracim/lib/mail_notifier/notifier.py

@@ -0,0 +1,571 @@
+# -*- coding: utf-8 -*-
+import datetime
+import typing
+
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.utils import formataddr
+
+from lxml.html.diff import htmldiff
+from mako.template import Template
+from sqlalchemy.orm import Session
+
+from tracim import CFG
+from tracim.lib.core.notifications import INotifier
+from tracim.lib.mail_notifier.sender import EmailSender
+from tracim.lib.mail_notifier.utils import SmtpConfiguration, EST
+from tracim.lib.mail_notifier.sender import send_email_through
+from tracim.lib.core.workspace import WorkspaceApi
+from tracim.lib.utils.logger import logger
+from tracim.models import User
+from tracim.models.auth import User
+from tracim.models.data import ActionDescription
+from tracim.models.data import Content
+from tracim.models.data import ContentType
+from tracim.models.data import UserRoleInWorkspace
+from tracim.lib.utils.translation import fake_translator as l_, \
+    fake_translator as _
+
+
+class EmailNotifier(INotifier):
+    """
+    EmailNotifier, this class will decide how to notify by mail
+    in order to let a EmailManager create email
+    """
+
+    def __init__(
+            self,
+            config: CFG,
+            session: Session,
+            current_user: User=None
+    ):
+        """
+        :param current_user: the user that has triggered the notification
+        :return:
+        """
+        INotifier.__init__(self, config, session, current_user)
+        logger.info(self, 'Instantiating Email Notifier')
+
+        self._user = current_user
+        self.session = session
+        self.config = config
+        self._smtp_config = SmtpConfiguration(
+            self.config.EMAIL_NOTIFICATION_SMTP_SERVER,
+            self.config.EMAIL_NOTIFICATION_SMTP_PORT,
+            self.config.EMAIL_NOTIFICATION_SMTP_USER,
+            self.config.EMAIL_NOTIFICATION_SMTP_PASSWORD
+        )
+
+    def notify_content_update(self, content: Content):
+
+        if content.get_last_action().id not \
+                in self.config.EMAIL_NOTIFICATION_NOTIFIED_EVENTS:
+            logger.info(
+                self,
+                'Skip email notification for update of content {}'
+                'by user {} (the action is {})'.format(
+                    content.content_id,
+                    # below: 0 means "no user"
+                    self._user.user_id if self._user else 0,
+                    content.get_last_action().id
+                )
+            )
+            return
+
+        logger.info(self,
+                    'About to email-notify update'
+                    'of content {} by user {}'.format(
+                        content.content_id,
+                        # Below: 0 means "no user"
+                        self._user.user_id if self._user else 0
+                    )
+        )
+
+        if content.type not \
+                in self.config.EMAIL_NOTIFICATION_NOTIFIED_CONTENTS:
+            logger.info(
+                self,
+                'Skip email notification for update of content {}'
+                'by user {} (the content type is {})'.format(
+                    content.type,
+                    # below: 0 means "no user"
+                    self._user.user_id if self._user else 0,
+                    content.get_last_action().id
+                )
+            )
+            return
+
+        logger.info(self,
+                    'About to email-notify update'
+                    'of content {} by user {}'.format(
+                        content.content_id,
+                        # Below: 0 means "no user"
+                        self._user.user_id if self._user else 0
+                    )
+        )
+
+        ####
+        #
+        # INFO - D.A. - 2014-11-05 - Emails are sent through asynchronous jobs.
+        # For that reason, we do not give SQLAlchemy objects but ids only
+        # (SQLA objects are related to a given thread/session)
+        #
+        try:
+            if self.config.EMAIL_NOTIFICATION_PROCESSING_MODE.lower() == self.config.CST.ASYNC.lower():
+                logger.info(self, 'Sending email in ASYNC mode')
+                # TODO - D.A - 2014-11-06
+                # This feature must be implemented in order to be able to scale to large communities
+                raise NotImplementedError('Sending emails through ASYNC mode is not working yet')
+            else:
+                logger.info(self, 'Sending email in SYNC mode')
+                EmailManager(
+                    self._smtp_config,
+                    self.config,
+                    self.session,
+                ).notify_content_update(self._user.user_id, content.content_id)
+        except TypeError as e:
+            logger.error(self, 'Exception catched during email notification: {}'.format(e.__str__()))
+
+
+class EmailManager(object):
+    """
+    Compared to Notifier, this class is independant from the HTTP request thread
+    This class will build Email and send it for both created account and content
+    update
+    """
+
+    def __init__(
+            self,
+            smtp_config: SmtpConfiguration,
+            config: CFG,
+            session: Session
+    ) -> None:
+        self._smtp_config = smtp_config
+        self.config = config
+        self.session = session
+        # FIXME - G.M - We need to have a session for the emailNotifier
+
+        # if not self.session:
+        #     engine = get_engine(settings)
+        #     session_factory = get_session_factory(engine)
+        #     app_config = CFG(settings)
+
+    def _get_sender(self, user: User=None) -> str:
+        """
+        Return sender string like "Bob Dylan
+            (via Tracim) <notification@mail.com>"
+        :param user: user to extract display name
+        :return: sender string
+        """
+
+        email_template = self.config.EMAIL_NOTIFICATION_FROM_EMAIL
+        mail_sender_name = self.config.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL  # nopep8
+        if user:
+            mail_sender_name = '{name} via Tracim'.format(name=user.display_name)
+            email_address = email_template.replace('{user_id}', str(user.user_id))
+            # INFO - D.A. - 2017-08-04
+            # We use email_template.replace() instead of .format() because this
+            # method is more robust to errors in config file.
+            #
+            # For example, if the email is info+{userid}@tracim.fr
+            # email.format(user_id='bob') will raise an exception
+            # email.replace('{user_id}', 'bob') will just ignore {userid}
+        else:
+            email_address = email_template.replace('{user_id}', '0')
+
+        return formataddr((mail_sender_name, email_address))
+
+    # Content Notification
+
+    @staticmethod
+    def log_notification(
+            config: CFG,
+            action: str,
+            recipient: typing.Optional[str],
+            subject: typing.Optional[str],
+    ) -> None:
+        """Log notification metadata."""
+        log_path = config.EMAIL_NOTIFICATION_LOG_FILE_PATH
+        if log_path:
+            # TODO - A.P - 2017-09-06 - file logging inefficiency
+            # Updating a document with 100 users to notify will leads to open
+            # and close the file 100 times.
+            with open(log_path, 'a') as log_file:
+                print(
+                    datetime.datetime.now(),
+                    action,
+                    recipient,
+                    subject,
+                    sep='|',
+                    file=log_file,
+                )
+
+    def notify_content_update(
+            self,
+            event_actor_id: int,
+            event_content_id: int
+    ) -> None:
+        """
+        Look for all users to be notified about the new content and send them an
+        individual email
+        :param event_actor_id: id of the user that has triggered the event
+        :param event_content_id: related content_id
+        :return:
+        """
+        # FIXME - D.A. - 2014-11-05
+        # Dirty import. It's here in order to avoid circular import
+        from tracim.lib.core.content import ContentApi
+        from tracim.lib.core.user import UserApi
+        user = UserApi(
+            None,
+            config=self.config,
+            session=self.session,
+            ).get_one(event_actor_id)
+        logger.debug(self, 'Content: {}'.format(event_content_id))
+        content_api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.config,
+            )
+        content = ContentApi(
+            session=self.session,
+            current_user=user, # TODO - use a system user instead of the user that has triggered the event
+            config=self.config,
+            show_archived=True,
+            show_deleted=True,
+        ).get_one(event_content_id, ContentType.Any)
+        main_content = content.parent if content.type == ContentType.Comment else content
+        notifiable_roles = WorkspaceApi(
+            current_user=user,
+            session=self.session,
+            config=self.config,
+        ).get_notifiable_roles(content.workspace)
+
+        if len(notifiable_roles) <= 0:
+            logger.info(self, 'Skipping notification as nobody subscribed to in workspace {}'.format(content.workspace.label))
+            return
+
+
+        logger.info(self, 'Sending asynchronous emails to {} user(s)'.format(len(notifiable_roles)))
+        # INFO - D.A. - 2014-11-06
+        # The following email sender will send emails in the async task queue
+        # This allow to build all mails through current thread but really send them (including SMTP connection)
+        # In the other thread.
+        #
+        # This way, the webserver will return sooner (actually before notification emails are sent
+        async_email_sender = EmailSender(
+            self.config,
+            self._smtp_config,
+            self.config.EMAIL_NOTIFICATION_ACTIVATED
+        )
+        for role in notifiable_roles:
+            logger.info(self, 'Sending email to {}'.format(role.user.email))
+            to_addr = formataddr((role.user.display_name, role.user.email))
+            #
+            # INFO - G.M - 2017-11-15 - set content_id in header to permit reply
+            # references can have multiple values, but only one in this case.
+            replyto_addr = self.config.EMAIL_NOTIFICATION_REPLY_TO_EMAIL.replace( # nopep8
+                '{content_id}',str(content.content_id)
+            )
+
+            reference_addr = self.config.EMAIL_NOTIFICATION_REFERENCES_EMAIL.replace( #nopep8
+                '{content_id}',str(content.content_id)
+             )
+            #
+            #  INFO - D.A. - 2014-11-06
+            # We do not use .format() here because the subject defined in the .ini file
+            # may not include all required labels. In order to avoid partial format() (which result in an exception)
+            # we do use replace and force the use of .__str__() in order to process LazyString objects
+            #
+            subject = self.config.EMAIL_NOTIFICATION_CONTENT_UPDATE_SUBJECT
+            subject = subject.replace(EST.WEBSITE_TITLE, self.config.WEBSITE_TITLE.__str__())
+            subject = subject.replace(EST.WORKSPACE_LABEL, main_content.workspace.label.__str__())
+            subject = subject.replace(EST.CONTENT_LABEL, main_content.label.__str__())
+            subject = subject.replace(EST.CONTENT_STATUS_LABEL, main_content.get_status().label.__str__())
+            reply_to_label = l_('{username} & all members of {workspace}').format(
+                username=user.display_name,
+                workspace=main_content.workspace.label)
+
+            message = MIMEMultipart('alternative')
+            message['Subject'] = subject
+            message['From'] = self._get_sender(user)
+            message['To'] = to_addr
+            message['Reply-to'] = formataddr((reply_to_label, replyto_addr))
+            # INFO - G.M - 2017-11-15
+            # References can theorically have label, but in pratice, references
+            # contains only message_id from parents post in thread.
+            # To link this email to a content we create a virtual parent
+            # in reference who contain the content_id.
+            message['References'] = formataddr(('',reference_addr))
+            body_text = self._build_email_body_for_content(self.config.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_TEXT, role, content, user)
+            body_html = self._build_email_body_for_content(self.config.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_HTML, role, content, user)
+
+            part1 = MIMEText(body_text, 'plain', 'utf-8')
+            part2 = MIMEText(body_html, 'html', 'utf-8')
+            # Attach parts into message container.
+            # According to RFC 2046, the last part of a multipart message, in this case
+            # the HTML message, is best and preferred.
+            message.attach(part1)
+            message.attach(part2)
+
+            self.log_notification(
+                action='CREATED',
+                recipient=message['To'],
+                subject=message['Subject'],
+                config=self.config,
+            )
+
+            send_email_through(
+                self.config,
+                async_email_sender.send_mail,
+                message
+            )
+
+    def notify_created_account(
+            self,
+            user: User,
+            password: str,
+    ) -> None:
+        """
+        Send created account email to given user.
+
+        :param password: choosed password
+        :param user: user to notify
+        """
+        # TODO BS 20160712: Cyclic import
+        logger.debug(self, 'user: {}'.format(user.user_id))
+        logger.info(self, 'Sending asynchronous email to 1 user ({0})'.format(
+            user.email,
+        ))
+
+        async_email_sender = EmailSender(
+            self.config,
+            self._smtp_config,
+            self.config.EMAIL_NOTIFICATION_ACTIVATED
+        )
+
+        subject = \
+            self.config.EMAIL_NOTIFICATION_CREATED_ACCOUNT_SUBJECT \
+            .replace(
+                EST.WEBSITE_TITLE,
+                self.config.WEBSITE_TITLE.__str__()
+            )
+        message = MIMEMultipart('alternative')
+        message['Subject'] = subject
+        message['From'] = self._get_sender()
+        message['To'] = formataddr((user.get_display_name(), user.email))
+
+        text_template_file_path = self.config.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_TEXT  # nopep8
+        html_template_file_path = self.config.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_HTML  # nopep8
+
+        context = {
+            'user': user,
+            'password': password,
+            # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for logo_url  # nopep8
+            'logo_url': '',
+            # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for login_url  # nopep8
+            'login_url': self.config.WEBSITE_BASE_URL,
+        }
+        body_text = self._render_template(
+            mako_template_filepath=text_template_file_path,
+            context=context
+        )
+
+        body_html = self._render_template(
+            mako_template_filepath=html_template_file_path,
+            context=context,
+        )
+
+        part1 = MIMEText(body_text, 'plain', 'utf-8')
+        part2 = MIMEText(body_html, 'html', 'utf-8')
+
+        # Attach parts into message container.
+        # According to RFC 2046, the last part of a multipart message,
+        # in this case the HTML message, is best and preferred.
+        message.attach(part1)
+        message.attach(part2)
+
+        send_email_through(
+            config=self.config,
+            sendmail_callable=async_email_sender.send_mail,
+            message=message
+        )
+
+    def _render_template(
+            self,
+            mako_template_filepath: str,
+            context: dict
+    ) -> str:
+        """
+        Render mako template with all needed current variables.
+
+        :param mako_template_filepath: file path of mako template
+        :param context: dict with template context
+        :return: template rendered string
+        """
+
+        template = Template(filename=mako_template_filepath)
+        return template.render(
+            _=_,
+            config=self.config,
+            **context
+        )
+
+    def _build_email_body_for_content(
+            self,
+            mako_template_filepath: str,
+            role: UserRoleInWorkspace,
+            content: Content,
+            actor: User
+    ) -> str:
+        """
+        Build an email body and return it as a string
+        :param mako_template_filepath: the absolute path to the mako template to be used for email body building
+        :param role: the role related to user to whom the email must be sent. The role is required (and not the user only) in order to show in the mail why the user receive the notification
+        :param content: the content item related to the notification
+        :param actor: the user at the origin of the action / notification (for example the one who wrote a comment
+        :param config: the global configuration
+        :return: the built email body as string. In case of multipart email, this method must be called one time for text and one time for html
+        """
+        logger.debug(self, 'Building email content from MAKO template {}'.format(mako_template_filepath))
+
+        main_title = content.label
+        content_intro = ''
+        content_text = ''
+        call_to_action_text = ''
+
+        # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for call_to_action_url  # nopep8
+        call_to_action_url =''
+        # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for status_icon_url  # nopep8
+        status_icon_url = ''
+        # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for workspace_url  # nopep8
+        workspace_url = ''
+        # TODO - G.M - 11-06-2018 - [emailTemplateURL] correct value for logo_url  # nopep8
+        logo_url = ''
+
+        action = content.get_last_action().id
+        if ActionDescription.COMMENT == action:
+            content_intro = l_('<span id="content-intro-username">{}</span> added a comment:').format(actor.display_name)
+            content_text = content.description
+            call_to_action_text = l_('Answer')
+
+        elif ActionDescription.CREATION == action:
+
+            # Default values (if not overriden)
+            content_text = content.description
+            call_to_action_text = l_('View online')
+
+            if ContentType.Thread == content.type:
+                call_to_action_text = l_('Answer')
+                content_intro = l_('<span id="content-intro-username">{}</span> started a thread entitled:').format(actor.display_name)
+                content_text = '<p id="content-body-intro">{}</p>'.format(content.label) + \
+                               content.get_last_comment_from(actor).description
+
+            elif ContentType.File == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> added a file entitled:').format(actor.display_name)
+                if content.description:
+                    content_text = content.description
+                else:
+                    content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
+
+            elif ContentType.Page == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> added a page entitled:').format(actor.display_name)
+                content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
+
+        elif ActionDescription.REVISION == action:
+            content_text = content.description
+            call_to_action_text = l_('View online')
+
+            if ContentType.File == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> uploaded a new revision.').format(actor.display_name)
+                content_text = ''
+
+            elif ContentType.Page == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> updated this page.').format(actor.display_name)
+                previous_revision = content.get_previous_revision()
+                title_diff = ''
+                if previous_revision.label != content.label:
+                    title_diff = htmldiff(previous_revision.label, content.label)
+                content_text = str(l_('<p id="content-body-intro">Here is an overview of the changes:</p>'))+ \
+                    title_diff + \
+                    htmldiff(previous_revision.description, content.description)
+
+            elif ContentType.Thread == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> updated the thread description.').format(actor.display_name)
+                previous_revision = content.get_previous_revision()
+                title_diff = ''
+                if previous_revision.label != content.label:
+                    title_diff = htmldiff(previous_revision.label, content.label)
+                content_text = str(l_('<p id="content-body-intro">Here is an overview of the changes:</p>'))+ \
+                    title_diff + \
+                    htmldiff(previous_revision.description, content.description)
+
+        elif ActionDescription.EDITION == action:
+            call_to_action_text = l_('View online')
+
+            if ContentType.File == content.type:
+                content_intro = l_('<span id="content-intro-username">{}</span> updated the file description.').format(actor.display_name)
+                content_text = '<p id="content-body-intro">{}</p>'.format(content.get_label()) + \
+                    content.description
+
+        elif ActionDescription.STATUS_UPDATE == action:
+            call_to_action_text = l_('View online')
+            intro_user_msg = l_(
+                '<span id="content-intro-username">{}</span> '
+                'updated the following status:'
+            )
+            content_intro = intro_user_msg.format(actor.display_name)
+            intro_body_msg = '<p id="content-body-intro">{}: {}</p>'
+            content_text = intro_body_msg.format(
+                content.get_label(),
+                content.get_status().label,
+            )
+
+        if '' == content_intro and content_text == '':
+            # Skip notification, but it's not normal
+            logger.error(
+                self, 'A notification is being sent but no content. '
+                      'Here are some debug informations: [content_id: {cid}]'
+                      '[action: {act}][author: {actor}]'.format(
+                    cid=content.content_id, act=action, actor=actor
+                )
+            )
+            raise ValueError('Unexpected empty notification')
+
+        context = {
+            'user': role.user,
+            'workspace': role.workspace,
+            'workspace_url': workspace_url,
+            'main_title': main_title,
+            'status_label': content.get_status().label,
+            'status_icon_url': status_icon_url,
+            'role_label': role.role_as_label(),
+            'content_intro': content_intro,
+            'content_text': content_text,
+            'call_to_action_text': call_to_action_text,
+            'call_to_action_url': call_to_action_url,
+            'logo_url': logo_url,
+        }
+        user = role.user
+        workspace = role.workspace
+        body_content = self._render_template(
+            mako_template_filepath=mako_template_filepath,
+            context=context,
+        )
+        return body_content
+
+
+def get_email_manager(config: CFG, session: Session):
+    """
+    :return: EmailManager instance
+    """
+    #  TODO: Find a way to import properly without cyclic import
+
+    smtp_config = SmtpConfiguration(
+        config.EMAIL_NOTIFICATION_SMTP_SERVER,
+        config.EMAIL_NOTIFICATION_SMTP_PORT,
+        config.EMAIL_NOTIFICATION_SMTP_USER,
+        config.EMAIL_NOTIFICATION_SMTP_PASSWORD
+    )
+
+    return EmailManager(config=config, smtp_config=smtp_config, session=session)

tracim/lib/mail_notifier/sender.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+import smtplib
+import typing
+from email.message import Message
+from email.mime.multipart import MIMEMultipart
+
+from tracim.config import CFG
+from tracim.lib.utils.logger import logger
+from tracim.lib.utils.utils import get_rq_queue
+from tracim.lib.utils.utils import get_redis_connection
+from tracim.lib.mail_notifier.utils import SmtpConfiguration
+
+def send_email_through(
+        config: CFG,
+        sendmail_callable: typing.Callable[[Message], None],
+        message: Message,
+) -> None:
+    """
+    Send mail encapsulation to send it in async or sync mode.
+
+    TODO BS 20170126: A global mail/sender management should be a good
+                      thing. Actually, this method is an fast solution.
+    :param config: system configuration
+    :param sendmail_callable: A callable who get message on first parameter
+    :param message: The message who have to be sent
+    """
+
+    if config.EMAIL_PROCESSING_MODE == config.CST.SYNC:
+        sendmail_callable(message)
+    elif config.EMAIL_PROCESSING_MODE == config.CST.ASYNC:
+        redis_connection = get_redis_connection(config)
+        queue = get_rq_queue(redis_connection, 'mail_sender')
+        queue.enqueue(sendmail_callable, message)
+    else:
+        raise NotImplementedError(
+            'Mail sender processing mode {} is not implemented'.format(
+                config.EMAIL_PROCESSING_MODE,
+            )
+        )
+
+
+class EmailSender(object):
+    """
+    Independent email sender class.
+
+    To allow its use in any thread, as an asyncjob_perform() call for
+    example, it has no dependencies on SQLAlchemy nor tg HTTP request.
+    """
+
+    def __init__(
+            self,
+            config: CFG,
+            smtp_config: SmtpConfiguration,
+            really_send_messages
+    ) -> None:
+        self._smtp_config = smtp_config
+        self.config = config
+        self._smtp_connection = None
+        self._is_active = really_send_messages
+
+    def connect(self):
+        if not self._smtp_connection:
+            log = 'Connecting from SMTP server {}'
+            logger.info(self, log.format(self._smtp_config.server))
+            self._smtp_connection = smtplib.SMTP(
+                self._smtp_config.server,
+                self._smtp_config.port
+            )
+            self._smtp_connection.ehlo()
+
+            if self._smtp_config.login:
+                try:
+                    starttls_result = self._smtp_connection.starttls()
+                    log = 'SMTP start TLS result: {}'
+                    logger.debug(self, log.format(starttls_result))
+                except Exception as e:
+                    log = 'SMTP start TLS error: {}'
+                    logger.debug(self, log.format(e.__str__()))
+
+            if self._smtp_config.login:
+                try:
+                    login_res = self._smtp_connection.login(
+                        self._smtp_config.login,
+                        self._smtp_config.password
+                    )
+                    log = 'SMTP login result: {}'
+                    logger.debug(self, log.format(login_res))
+                except Exception as e:
+                    log = 'SMTP login error: {}'
+                    logger.debug(self, log.format(e.__str__()))
+            logger.info(self, 'Connection OK')
+
+    def disconnect(self):
+        if self._smtp_connection:
+            log = 'Disconnecting from SMTP server {}'
+            logger.info(self, log.format(self._smtp_config.server))
+            self._smtp_connection.quit()
+            logger.info(self, 'Connection closed.')
+
+    def send_mail(self, message: MIMEMultipart):
+        if not self._is_active:
+            log = 'Not sending email to {} (service disabled)'
+            logger.info(self, log.format(message['To']))
+        else:
+            self.connect()  # Actually, this connects to SMTP only if required
+            logger.info(self, 'Sending email to {}'.format(message['To']))
+            self._smtp_connection.send_message(message)
+            from tracim.lib.mail_notifier.notifier import EmailManager
+            EmailManager.log_notification(
+                action='   SENT',
+                recipient=message['To'],
+                subject=message['Subject'],
+                config=self.config,
+            )

tracim/lib/mail_notifier/utils.py

@@ -0,0 +1,33 @@
+class SmtpConfiguration(object):
+    """Container class for SMTP configuration used in Tracim."""
+
+    def __init__(self, server: str, port: int, login: str, password: str):
+        self.server = server
+        self.port = port
+        self.login = login
+        self.password = password
+
+
+class EST(object):
+    """
+    EST = Email Subject Tags - this is a convenient class - no business logic
+    here
+    This class is intended to agregate all dynamic content that may be included
+    in email subjects
+    """
+
+    WEBSITE_TITLE = '{website_title}'
+    WORKSPACE_LABEL = '{workspace_label}'
+    CONTENT_LABEL = '{content_label}'
+    CONTENT_STATUS_LABEL = '{content_status_label}'
+
+    @classmethod
+    def all(cls):
+        return [
+            cls.CONTENT_LABEL,
+            cls.CONTENT_STATUS_LABEL,
+            cls.WEBSITE_TITLE,
+            cls.WORKSPACE_LABEL
+        ]
+
+

tracim/lib/utils/authentification.py

@@ -51,6 +51,6 @@ def _get_basic_auth_unsafe_user(
         if not login:
             return None
         user = uapi.get_one_by_email(login)
-    except (NoResultFound, UserDoesNotExist):
+    except UserDoesNotExist:
         return None
     return user

tracim/lib/utils/authorization.py

@@ -44,7 +44,7 @@ class AcceptAllAuthorizationPolicy(object):
 # We prefer to use decorators
 
 
-def require_same_user_or_profile(group):
+def require_same_user_or_profile(group: int):
     """
     Decorator for view to restrict access of tracim request if candidate user
     is distinct from authenticated user and not with high enough profile.
@@ -64,7 +64,7 @@ def require_same_user_or_profile(group):
     return decorator
 
 
-def require_profile(group):
+def require_profile(group: int):
     """
     Decorator for view to restrict access of tracim request if profile is
     not high enough
@@ -82,7 +82,7 @@ def require_profile(group):
     return decorator
 
 
-def require_workspace_role(minimal_required_role):
+def require_workspace_role(minimal_required_role: int):
     """
     Decorator for view to restrict access of tracim request if role
     is not high enough

tracim/lib/utils/request.py

@@ -6,7 +6,7 @@ from pyramid.request import Request
 from sqlalchemy.orm.exc import NoResultFound
 
 
-from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import NotAuthenticated
 from tracim.exceptions import UserNotFoundInTracimRequest
 from tracim.exceptions import UserDoesNotExist
 from tracim.exceptions import WorkspaceNotFound
@@ -40,11 +40,14 @@ class TracimRequest(Request):
         )
         # Current workspace, found by request headers or content
         self._current_workspace = None  # type: Workspace
+
         # Authenticated user
         self._current_user = None  # type: User
+
         # User found from request headers, content, distinct from authenticated
         # user
         self._user_candidate = None  # type: User
+
         # INFO - G.M - 18-05-2018 - Close db at the end of the request
         self.add_finished_callback(self._cleanup)
 
@@ -168,7 +171,7 @@ def get_auth_safe_user(
             raise UserNotFoundInTracimRequest('You request a current user but the context not permit to found one')  # nopep8
         user = uapi.get_one_by_email(login)
     except (UserDoesNotExist, UserNotFoundInTracimRequest) as exc:
-        raise NotAuthentificated('User {} not found'.format(login)) from exc
+        raise NotAuthenticated('User {} not found'.format(login)) from exc
     return user
 
 
@@ -187,7 +190,7 @@ def get_workspace(
         if 'workspace_id' in request.matchdict:
             workspace_id = request.matchdict['workspace_id']
         if not workspace_id:
-            raise WorkspaceNotFound('No workspace_id param')
+            raise WorkspaceNotFound('No workspace_id property found in request')
         wapi = WorkspaceApi(
             current_user=user,
             session=request.dbsession,

tracim/lib/utils/utils.py

@@ -1,10 +1,35 @@
 # -*- coding: utf-8 -*-
 import datetime
+from redis import Redis
+from rq import Queue
+
+from tracim.config import CFG
 
 DEFAULT_WEBDAV_CONFIG_FILE = "wsgidav.conf"
 DEFAULT_TRACIM_CONFIG_FILE = "development.ini"
 
 
+def get_redis_connection(config: CFG) -> Redis:
+    """
+    :param config: current app_config
+    :return: redis connection
+    """
+    return Redis(
+        host=config.EMAIL_SENDER_REDIS_HOST,
+        port=config.EMAIL_SENDER_REDIS_PORT,
+        db=config.EMAIL_SENDER_REDIS_DB,
+    )
+
+
+def get_rq_queue(redis_connection: Redis, queue_name: str ='default') -> Queue:
+    """
+    :param queue_name: name of queue
+    :return: wanted queue
+    """
+
+    return Queue(name=queue_name, connection=redis_connection)
+
+
 def cmp_to_key(mycmp):
     """
     List sort related function

tracim/lib/webdav/__init__.py

@@ -27,43 +27,37 @@ from tracim.models import get_engine, get_session_factory
 class WebdavAppFactory(object):
 
     def __init__(self,
-                 webdav_config_file_path: str = None,
                  tracim_config_file_path: str = None,
                  ):
         self.config = self._initConfig(
-            webdav_config_file_path,
             tracim_config_file_path
         )
 
     def _initConfig(self,
-                    webdav_config_file_path: str = None,
                     tracim_config_file_path: str = None
                     ):
         """Setup configuration dictionary from default,
          command line and configuration file."""
-        if not webdav_config_file_path:
-            webdav_config_file_path = DEFAULT_WEBDAV_CONFIG_FILE
         if not tracim_config_file_path:
             tracim_config_file_path = DEFAULT_TRACIM_CONFIG_FILE
 
         # Set config defaults
         config = DEFAULT_CONFIG.copy()
         temp_verbose = config["verbose"]
+        # Get pyramid Env
+        tracim_config_file_path = os.path.abspath(tracim_config_file_path)
+        config['tracim_config'] = tracim_config_file_path
+        settings = self._get_tracim_settings(config)
+        app_config = CFG(settings)
 
-        default_config_file = os.path.abspath(webdav_config_file_path)
+        default_config_file = os.path.abspath(settings['wsgidav.config_path'])
         webdav_config_file = self._readConfigFile(
-            webdav_config_file_path,
+            default_config_file,
             temp_verbose
             )
         # Configuration file overrides defaults
         config.update(webdav_config_file)
 
-        # Get pyramid Env
-        tracim_config_file_path = os.path.abspath(tracim_config_file_path)
-        config['tracim_config'] = tracim_config_file_path
-        settings = get_appsettings(config['tracim_config'])
-        app_config = CFG(settings)
-
         if not useLxml and config["verbose"] >= 1:
             print(
                 "WARNING: Could not import lxml: using xml instead (slower). "
@@ -93,10 +87,23 @@ class WebdavAppFactory(object):
         config['domaincontroller'] = TracimDomainController(
             presetdomain=None,
             presetserver=None,
-            app_config = app_config,
+            app_config=app_config,
         )
         return config
 
+    def _get_tracim_settings(
+            self,
+            default_config,
+    ):
+        """
+        Get tracim settings
+        """
+        global_conf = get_appsettings(default_config['tracim_config']).global_conf
+        local_conf = get_appsettings(default_config['tracim_config'], 'tracim_web')  # nopep8
+        settings = global_conf
+        settings.update(local_conf)
+        return settings
+
     # INFO - G.M - 13-04-2018 - Copy from
     # wsgidav.server.run_server._readConfigFile
     def _readConfigFile(self, config_file, verbose):

tracim/lib/webdav/middlewares.py

@@ -256,7 +256,10 @@ class TracimEnv(BaseMiddleware):
         super().__init__(application, config)
         self._application = application
         self._config = config
-        self.settings = get_appsettings(config['tracim_config'])
+        global_conf = get_appsettings(config['tracim_config']).global_conf
+        local_conf = get_appsettings(config['tracim_config'], 'tracim_web')
+        self.settings = global_conf
+        self.settings.update(local_conf)
         self.engine = get_engine(self.settings)
         self.session_factory = get_session_factory(self.engine)
         self.app_config = CFG(self.settings)

tracim/models/applications.py

@@ -47,7 +47,7 @@ thread = Application(
 
 )
 
-file = Application(
+_file = Application(
     label='Files',
     slug='contents/files',
     icon='paperclip',
@@ -81,7 +81,7 @@ htmlpage = Application(
 applications = [
     htmlpage,
     markdownpluspage,
-    file,
+    _file,
     thread,
     calendar,
 ]

tracim/models/data.py

@@ -139,12 +139,12 @@ class UserRoleInWorkspace(DeclarativeBase):
         WORKSPACE_MANAGER: 'workspace_manager',
     }
 
-    # LABEL = dict()
-    # LABEL[0] = l_('N/A')
-    # LABEL[1] = l_('Reader')
-    # LABEL[2] = l_('Contributor')
-    # LABEL[4] = l_('Content Manager')
-    # LABEL[8] = l_('Workspace Manager')
+    LABEL = dict()
+    LABEL[0] = l_('N/A')
+    LABEL[1] = l_('Reader')
+    LABEL[2] = l_('Contributor')
+    LABEL[4] = l_('Content Manager')
+    LABEL[8] = l_('Workspace Manager')
     #
     # STYLE = dict()
     # STYLE[0] = ''
@@ -169,8 +169,9 @@ class UserRoleInWorkspace(DeclarativeBase):
     # def style(self):
     #     return UserRoleInWorkspace.STYLE[self.role]
     #
-    # def role_as_label(self):
-    #     return UserRoleInWorkspace.LABEL[self.role]
+
+    def role_as_label(self):
+        return UserRoleInWorkspace.LABEL[self.role]
 
     @classmethod
     def get_all_role_values(cls) -> typing.List[int]:
@@ -340,6 +341,7 @@ class ContentStatus(object):
                  # type=''
     ):
         self.id = id
+        self.label = self.id
         # TODO - G.M - 10-04-2018 - [Cleanup] Drop this
         # self.icon = ContentStatus._ICONS[id]
         # self.css = ContentStatus._CSS[id]

tracim/templates/mail/content_update_body_html.mak

@@ -0,0 +1,73 @@
+## -*- coding: utf-8 -*-
+<html>
+  <head>
+    <style>
+      a { color: #3465af;}
+      a.call-to-action {
+        background: #3465af;
+        padding: 3px 4px 5px 4px;
+        border: 1px solid #12438d;
+        font-weight: bold;
+        color: #FFF;
+        text-decoration: none;
+        margin-left: 5px;
+      }
+      a.call-to-action img { vertical-align: middle;}
+      th { vertical-align: top;}
+      
+      #content-intro-username { font-size: 1.5em; color: #666; font-weight: bold; }
+      #content-intro { margin: 0; border: 1em solid #DDD; border-width: 0 0 0 0em; padding: 1em 1em 1em 1em; }
+      #content-body { margin: 0em; border: 2em solid #DDD; border-width: 0 0 0 4em; padding: 0.5em 2em 1em 1em; }
+      #content-body-intro { font-size: 2em; color: #666; }
+      #content-body-only-title { font-size: 1.5em; }
+
+      #content-body ins { background-color: #AFA; }
+      #content-body del { background-color: #FAA; }
+
+
+      #call-to-action-button { background-color: #5CB85C; border: 1px solid #4CAE4C; color: #FFF; text-decoration: none; font-weight: bold; border-radius: 3px; font-size: 2em; padding: 4px 0.3em;}
+      #call-to-action-container { text-align: right; margin-top: 2em; }
+
+      #footer hr { border: 0px solid #CCC; border-top-width: 1px; width: 8em; max-width:25%; margin-left: 0;}
+      #footer { color: #999; margin: 4em auto auto 0.5em; }
+      #footer a { color: #999; }
+    </style>
+  </head>
+  <body style="font-family: Arial; font-size: 12px; max-width: 600px; margin: 0; padding: 0;">
+
+    <table style="width: 100%; cell-padding: 0; border-collapse: collapse; margin: 0">
+      <tr style="background-color: F5F5F5; border-bottom: 1px solid #CCC;" >
+        <td style="background-color: #666;">
+            <img alt="logo" src="${logo_url}" style="vertical-align: middle;">
+        </td>
+        <td style="padding: 0.5em; background-color: #666; text-align: left;">
+          <span style="font-size: 1.3em; color: #FFF; font-weight: bold;">
+            ${main_title}
+            &mdash;&nbsp;<span style="font-weight: bold; color: #999; font-weight: bold;">
+              ${status_label|n}
+              <img alt="status_icon" src="${status_icon_url}" style="vertical-align: middle;">
+            </span>
+        </td>
+      </tr>
+    </table>
+
+    <p id="content-intro">${content_intro|n}</p>
+    <div id="content-body">
+        <div>${content_text|n}</div>
+        <div href='' id="call-to-action-container">
+        </div>
+    </div>
+    
+    <div id="footer">
+        <p>
+
+            ${_('{user_display_name}, you receive this email because you are registered on <i>{website_title}</i> and you are <i>{user_role_label}</i> in the workspace <a href="{workspace_url}">{workspace_label}</a>.').format(user_display_name=user.display_name, user_role_label=role_label, workspace_url=workspace_url, workspace_label=workspace.label, website_title=config.WEBSITE_TITLE)|n}
+        </p>
+        <hr/>
+        <p>
+            ${_('This email was automatically sent by <i>Tracim</i>, a collaborative software developped by Algoo.')}<br/>
+            Algoo SAS &mdash; 340 Rue de l'Eygala, 38430 Moirans, France &mdash; <a style="text-decoration: none;" href="http://algoo.fr">www.algoo.fr</a>
+        </p>
+    </div>
+  </body>
+</html>

tracim/templates/mail/content_update_body_text.mak

@@ -0,0 +1,31 @@
+## -*- coding: utf-8 -*-
+
+Dear ${user.display_name},
+
+This email is intended to be read as HTML content.
+Please configure your email client to get the best of Tracim notifications.
+
+We understand that Email was originally intended to carry raw text only.
+And you probably understand on your own that we are a decades after email
+was created ;)
+
+Hope you'll switch your mail client configuration and enjoy Tracim :)
+
+
+--------------------------------------------------------------------------------
+
+
+You receive this email because you are registered on /${config.WEBSITE_TITLE}/
+and you are /${role_label}/ in the workspace /${workspace.label}/
+
+----
+
+This email was automatically sent by *Tracim*,
+a collaborative software developped by Algoo.
+
+**Algoo SAS**
+340 Rue de l'Eygala
+38430 Moirans
+France
+http://algoo.fr
+

tracim/templates/mail/created_account_body_html.mak

@@ -0,0 +1,88 @@
+## -*- coding: utf-8 -*-
+<html>
+  <head>
+    <style>
+      a { color: #3465af;}
+      a.call-to-action {
+        background: #3465af;
+        padding: 3px 4px 5px 4px;
+        border: 1px solid #12438d;
+        font-weight: bold;
+        color: #FFF;
+        text-decoration: none;
+        margin-left: 5px;
+      }
+      a.call-to-action img { vertical-align: middle;}
+      th { vertical-align: top;}
+      
+      #content-intro-username { font-size: 1.5em; color: #666; font-weight: bold; }
+      #content-intro { margin: 0; border: 1em solid #DDD; border-width: 0 0 0 0em; padding: 1em 1em 1em 1em; }
+      #content-body { margin: 0em; border: 2em solid #DDD; border-width: 0 0 0 4em; padding: 0.5em 2em 1em 1em; }
+      #content-body-intro { font-size: 2em; color: #666; }
+      #content-body-only-title { font-size: 1.5em; }
+
+      #content-body ins { background-color: #AFA; }
+      #content-body del { background-color: #FAA; }
+
+
+      #call-to-action-button { background-color: #5CB85C; border: 1px solid #4CAE4C; color: #FFF; text-decoration: none; font-weight: bold; border-radius: 3px; font-size: 2em; padding: 4px 0.3em;}
+      #call-to-action-container { text-align: right; margin-top: 2em; }
+
+      #footer hr { border: 0px solid #CCC; border-top-width: 1px; width: 8em; max-width:25%; margin-left: 0;}
+      #footer { color: #999; margin: 4em auto auto 0.5em; }
+      #footer a { color: #999; }
+    </style>
+  </head>
+  <body style="font-family: Arial; font-size: 12px; max-width: 600px; margin: 0; padding: 0;">
+
+    <table style="width: 100%; cell-padding: 0; border-collapse: collapse; margin: 0">
+      <tr style="background-color: F5F5F5; border-bottom: 1px solid #CCC;" >
+        <td style="background-color: #666;">
+            <img alt="logo" src="${logo_url}" style="vertical-align: middle;">
+        </td>
+        <td style="padding: 0.5em; background-color: #666; text-align: left;">
+          <span style="font-size: 1.3em; color: #FFF; font-weight: bold;">
+
+            ${config.WEBSITE_TITLE}: ${_('Created account')}
+
+          </span>
+        </td>
+      </tr>
+    </table>
+
+    <div id="content-body">
+        <div>
+            ${_('An administrator just create account for you on {website_title}'.format(
+                website_title=config.WEBSITE_TITLE
+            ))}
+
+            <ul>
+                <li>
+                    <b>${_('Login')}</b>: ${user.email}
+                </li>
+                <li>
+                    <b>${_('Password')}</b>: ${password}
+                </li>
+            </ul>
+
+        </div>
+        <div id="call-to-action-container">
+
+            ${_('To go to {website_title}, please click on following link'.format(
+                website_title=config.WEBSITE_TITLE
+            ))}
+
+            <span style="">
+                <a href="${login_url}" id='call-to-action-button'>${login_url}</a>
+            </span>
+        </div>
+    </div>
+    
+    <div id="footer">
+        <p>
+            ${_('This email was sent by <i>Tracim</i>, a collaborative software developped by Algoo.')}<br/>
+            Algoo SAS &mdash; 340 Rue de l'Eygala, 38430 Moirans, France &mdash; <a style="text-decoration: none;" href="http://algoo.fr">www.algoo.fr</a>
+        </p>
+    </div>
+  </body>
+</html>

tracim/templates/mail/created_account_body_text.mak

@@ -0,0 +1,25 @@
+## -*- coding: utf-8 -*-
+
+${_('An administrator just create account for you on {website_title}'.format(
+    website_title=config.WEBSITE_TITLE
+))}
+
+* ${_('Login')}: ${user.email}
+* ${_('Password')}: ${password}
+
+${_('To go to {website_title}, please click on following link'.format(
+    website_title=config.WEBSITE_TITLE
+))}
+
+${login_url}
+
+--------------------------------------------------------------------------------
+
+This email was sent by *Tracim*,
+a collaborative software developped by Algoo.
+
+**Algoo SAS**
+340 Rue de l'Eygala
+38430 Moirans
+France
+http://algoo.fr

tracim/tests/__init__.py

@@ -1,5 +1,8 @@
 # -*- coding: utf-8 -*-
 import unittest
+
+import plaster
+import requests
 import transaction
 from depot.manager import DepotManager
 from pyramid import testing
@@ -17,7 +20,7 @@ from tracim.fixtures import FixturesLoader
 from tracim.fixtures.users_and_groups import Base as BaseFixture
 from tracim.config import CFG
 from tracim.extensions import hapic
-from tracim import main
+from tracim import web
 from webtest import TestApp
 
 
@@ -42,7 +45,7 @@ class FunctionalTest(unittest.TestCase):
 
         }
         hapic.reset_context()
-        app = main({}, **settings)
+        app = web({}, **settings)
         self.init_database(settings)
         self.testapp = TestApp(app)
 
@@ -92,16 +95,16 @@ class BaseTest(unittest.TestCase):
     Pyramid default test.
     """
 
+    config_uri = 'tests_configs.ini'
+    config_section = 'base_test'
+
     def setUp(self):
         logger.debug(self, 'Setup Test...')
-        self.config = testing.setUp(settings={
-            'sqlalchemy.url': 'sqlite:///:memory:',
-            'user.auth_token.validity': '604800',
-            'depot_storage_dir': '/tmp/test/depot',
-            'depot_storage_name': 'test',
-            'preview_cache_dir': '/tmp/test/preview_cache',
-
-        })
+        self.settings = plaster.get_settings(
+            self.config_uri,
+            self.config_section
+        )
+        self.config = testing.setUp(settings = self.settings)
         self.config.include('tracim.models')
         DepotManager._clear()
         DepotManager.configure(
@@ -226,3 +229,15 @@ class DefaultTest(StandardTest):
             owner=user
         )
         return thread
+
+
+class MailHogTest(DefaultTest):
+    """
+    Theses test need a working mailhog
+    """
+
+    config_section = 'mail_test'
+
+    def tearDown(self):
+        logger.debug(self, 'Cleanup MailHog list...')
+        requests.delete('http://127.0.0.1:8025/api/v1/messages')

tracim/tests/functional/test_mail_notification.py

@@ -0,0 +1,267 @@
+# coding=utf-8
+# INFO - G.M - 09-06-2018 - Those test need a working MailHog
+
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+
+import requests
+from rq import SimpleWorker
+
+from tracim.fixtures.users_and_groups import Base as BaseFixture
+from tracim.fixtures.content import Content as ContentFixture
+from tracim.lib.utils.utils import get_redis_connection
+from tracim.lib.utils.utils import get_rq_queue
+from tracim.models.data import ContentType
+
+from tracim.lib.core.content import ContentApi
+from tracim.lib.core.user import UserApi
+from tracim.lib.core.workspace import WorkspaceApi
+from tracim.lib.mail_notifier.sender import EmailSender
+from tracim.lib.mail_notifier.utils import SmtpConfiguration
+from tracim.tests import MailHogTest
+
+
+class TestEmailSender(MailHogTest):
+
+    def test__func__connect_disconnect__ok__nominal_case(self):
+        smtp_config = SmtpConfiguration(
+            self.app_config.EMAIL_NOTIFICATION_SMTP_SERVER,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_PORT,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_USER,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_PASSWORD
+        )
+        sender = EmailSender(
+            self.app_config,
+            smtp_config,
+            True,
+        )
+        sender.connect()
+        sender.disconnect()
+
+    def test__func__send_email__ok__nominal_case(self):
+        smtp_config = SmtpConfiguration(
+            self.app_config.EMAIL_NOTIFICATION_SMTP_SERVER,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_PORT,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_USER,
+            self.app_config.EMAIL_NOTIFICATION_SMTP_PASSWORD
+        )
+        sender = EmailSender(
+            self.app_config,
+            smtp_config,
+            True,
+        )
+
+        # Create test_mail
+        msg = MIMEMultipart()
+        msg['Subject'] = 'test__func__send_email__ok__nominal_case'
+        msg['From'] = 'test_send_mail@localhost'
+        msg['To'] = 'receiver_test_send_mail@localhost'
+        text = "test__func__send_email__ok__nominal_case"
+        html = """\
+        <html>
+          <head></head>
+          <body>
+            <p>test__func__send_email__ok__nominal_case</p>
+          </body>
+        </html>
+        """.replace(' ', '').replace('\n', '')
+        part1 = MIMEText(text, 'plain')
+        part2 = MIMEText(html, 'html')
+        msg.attach(part1)
+        msg.attach(part2)
+
+        sender.send_mail(msg)
+        sender.disconnect()
+
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == 'test_send_mail@localhost'
+        assert headers['To'][0] == 'receiver_test_send_mail@localhost'
+        assert headers['Subject'][0] == 'test__func__send_email__ok__nominal_case'  # nopep8
+        assert response[0]['MIME']['Parts'][0]['Body'] == text
+        assert response[0]['MIME']['Parts'][1]['Body'] == html
+
+
+class TestNotificationsSync(MailHogTest):
+
+    fixtures = [BaseFixture, ContentFixture]
+
+    def test_func__create_user_with_mail_notification__ok__nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        u = api.create_user(
+            email='bob@bob',
+            password='pass',
+            name='bob',
+            timezone='+2',
+            do_save=True,
+            do_notify=True,
+        )
+        assert u is not None
+        assert u.email == "bob@bob"
+        assert u.validate_password('pass')
+        assert u.display_name == 'bob'
+        assert u.timezone == '+2'
+
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == 'Tracim Notifications <test_user_from+0@localhost>'  # nopep8
+        assert headers['To'][0] == 'bob <bob@bob>'
+        assert headers['Subject'][0] == '[TRACIM] Created account'
+
+    def test_func__create_new_content_with_notification__ok__nominal_case(self):
+        uapi = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        current_user = uapi.get_one_by_email('admin@admin.admin')
+        # Create new user with notification enabled on w1 workspace
+        wapi = WorkspaceApi(
+            current_user=current_user,
+            session=self.session,
+            config=self.app_config,
+        )
+        workspace = wapi.get_one_by_label('w1')
+        user = uapi.get_one_by_email('bob@fsf.local')
+        wapi.enable_notifications(user, workspace)
+
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        item = api.create(
+            ContentType.Folder,
+            workspace,
+            None,
+            'parent',
+            do_save=True,
+            do_notify=False,
+        )
+        item2 = api.create(
+            ContentType.File,
+            workspace,
+            item,
+            'file1',
+            do_save=True,
+            do_notify=True,
+        )
+
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == '"Bob i. via Tracim" <test_user_from+3@localhost>'  # nopep8
+        assert headers['To'][0] == 'Global manager <admin@admin.admin>'
+        assert headers['Subject'][0] == '[TRACIM] [w1] file1 (open)'
+        assert headers['References'][0] == 'test_user_refs+13@localhost'
+        assert headers['Reply-to'][0] == '"Bob i. & all members of w1" <test_user_reply+13@localhost>'  # nopep8
+
+
+class TestNotificationsAsync(MailHogTest):
+    fixtures = [BaseFixture, ContentFixture]
+    config_section = 'mail_test_async'
+
+    def test_func__create_user_with_mail_notification__ok__nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        u = api.create_user(
+            email='bob@bob',
+            password='pass',
+            name='bob',
+            timezone='+2',
+            do_save=True,
+            do_notify=True,
+        )
+        assert u is not None
+        assert u.email == "bob@bob"
+        assert u.validate_password('pass')
+        assert u.display_name == 'bob'
+        assert u.timezone == '+2'
+
+        # Send mail async from redis queue
+        redis = get_redis_connection(
+            self.app_config
+        )
+        queue = get_rq_queue(
+            redis,
+            'mail_sender',
+        )
+        worker = SimpleWorker([queue], connection=queue.connection)
+        worker.work(burst=True)
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == 'Tracim Notifications <test_user_from+0@localhost>'  # nopep8
+        assert headers['To'][0] == 'bob <bob@bob>'
+        assert headers['Subject'][0] == '[TRACIM] Created account'
+
+    def test_func__create_new_content_with_notification__ok__nominal_case(self):
+        uapi = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
+        current_user = uapi.get_one_by_email('admin@admin.admin')
+        # Create new user with notification enabled on w1 workspace
+        wapi = WorkspaceApi(
+            current_user=current_user,
+            session=self.session,
+            config=self.app_config,
+        )
+        workspace = wapi.get_one_by_label('w1')
+        user = uapi.get_one_by_email('bob@fsf.local')
+        wapi.enable_notifications(user, workspace)
+
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
+        item = api.create(
+            ContentType.Folder,
+            workspace,
+            None,
+            'parent',
+            do_save=True,
+            do_notify=False,
+        )
+        item2 = api.create(
+            ContentType.File,
+            workspace,
+            item,
+            'file1',
+            do_save=True,
+            do_notify=True,
+        )
+        # Send mail async from redis queue
+        redis = get_redis_connection(
+            self.app_config
+        )
+        queue = get_rq_queue(
+            redis,
+            'mail_sender',
+        )
+        worker = SimpleWorker([queue], connection=queue.connection)
+        worker.work(burst=True)
+        # check mail received
+        response = requests.get('http://127.0.0.1:8025/api/v1/messages')
+        response = response.json()
+        headers = response[0]['Content']['Headers']
+        assert headers['From'][0] == '"Bob i. via Tracim" <test_user_from+3@localhost>'  # nopep8
+        assert headers['To'][0] == 'Global manager <admin@admin.admin>'
+        assert headers['Subject'][0] == '[TRACIM] [w1] file1 (open)'
+        assert headers['References'][0] == 'test_user_refs+13@localhost'
+        assert headers['Reply-to'][0] == '"Bob i. & all members of w1" <test_user_reply+13@localhost>'  # nopep8

tracim/tests/functional/test_session.py

@@ -17,8 +17,6 @@ class TestLogoutEndpoint(FunctionalTest):
 
 class TestLoginEndpointUnititedDB(FunctionalTestNoDB):
 
-    @pytest.mark.xfail(raises=OperationalError,
-                       reason='Not supported yet by hapic')
     def test_api__try_login_enpoint__err_500__no_inited_db(self):
         params = {
             'email': 'admin@admin.admin',

tracim/tests/library/test_content_api.py

@@ -116,8 +116,8 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
         workspace = WorkspaceApi(
             current_user=user,
             session=self.session,
@@ -210,13 +210,17 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(
+            email='this.is@user',
+            groups=groups,
+            save_now=True
+        )
         workspace_api = WorkspaceApi(
             current_user=user,
             session=self.session,
-            config=self.app_config,
+            config=self.app_config
         )
+
         workspace = workspace_api.create_workspace(
             'test workspace',
             save_now=True
@@ -315,7 +319,7 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(
+        user = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
@@ -381,8 +385,8 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
         workspace = WorkspaceApi(
             current_user=user,
             session=self.session,
@@ -456,8 +460,8 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
@@ -496,8 +500,8 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
@@ -540,8 +544,8 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
@@ -584,12 +588,12 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(
+        user = uapi.create_minimal_user(
             email='user1@user',
             groups=groups,
             save_now=True
         )
-        user2 = uapi.create_user(
+        user2 = uapi.create_minimal_user(
             email='user2@user',
             groups=groups,
             save_now=True
@@ -703,12 +707,12 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(
+        user = uapi.create_minimal_user(
             email='user1@user',
             groups=groups,
             save_now=True
         )
-        user2 = uapi.create_user(
+        user2 = uapi.create_minimal_user(
             email='user2@user',
             groups=groups,
             save_now=True
@@ -820,12 +824,12 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(
+        user = uapi.create_minimal_user(
             email='user1@user',
             groups=groups,
             save_now=True,
         )
-        user2 = uapi.create_user(
+        user2 = uapi.create_minimal_user(
             email='user2@user',
             groups=groups,
             save_now=True
@@ -925,10 +929,10 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user_a = uapi.create_user(email='this.is@user',
-                                  groups=groups, save_now=True)
-        user_b = uapi.create_user(email='this.is@another.user',
-                                  groups=groups, save_now=True)
+        user_a = uapi.create_minimal_user(email='this.is@user',
+                                          groups=groups, save_now=True)
+        user_b = uapi.create_minimal_user(email='this.is@another.user',
+                                          groups=groups, save_now=True)
 
         wapi = WorkspaceApi(
             current_user=user_a,
@@ -1032,12 +1036,12 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user_a = uapi.create_user(
+        user_a = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
         )
-        user_b = uapi.create_user(
+        user_b = uapi.create_minimal_user(
             email='this.is@another.user',
             groups=groups,
             save_now=True
@@ -1105,12 +1109,12 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user_a = uapi.create_user(
+        user_a = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
         )
-        user_b = uapi.create_user(
+        user_b = uapi.create_minimal_user(
             email='this.is@another.user',
             groups=groups,
             save_now=True
@@ -1204,7 +1208,7 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
@@ -1222,8 +1226,7 @@ class TestContentApi(DefaultTest):
         
         wid = workspace.workspace_id
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
@@ -1333,7 +1336,7 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True,
@@ -1348,8 +1351,7 @@ class TestContentApi(DefaultTest):
             save_now=True
         )
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
@@ -1414,7 +1416,7 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
@@ -1431,8 +1433,7 @@ class TestContentApi(DefaultTest):
         )
         wid = workspace.workspace_id
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
@@ -1539,7 +1540,7 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True,
@@ -1555,8 +1556,7 @@ class TestContentApi(DefaultTest):
             save_now=True
         )
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
@@ -1627,7 +1627,7 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
@@ -1645,8 +1645,7 @@ class TestContentApi(DefaultTest):
         )
         wid = workspace.workspace_id
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
@@ -1784,7 +1783,7 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user1 = uapi.create_user(
+        user1 = uapi.create_minimal_user(
             email='this.is@user',
             groups=groups,
             save_now=True
@@ -1802,8 +1801,7 @@ class TestContentApi(DefaultTest):
         )
         wid = workspace.workspace_id
 
-        user2 = uapi.create_user()
-        user2.email = 'this.is@another.user'
+        user2 = uapi.create_minimal_user('this.is@another.user')
         uapi.save(user2)
 
         RoleApi(
@@ -1942,8 +1940,8 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
@@ -1998,8 +1996,8 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,
@@ -2054,8 +2052,8 @@ class TestContentApi(DefaultTest):
                   group_api.get_one(Group.TIM_MANAGER),
                   group_api.get_one(Group.TIM_ADMIN)]
 
-        user = uapi.create_user(email='this.is@user',
-                                groups=groups, save_now=True)
+        user = uapi.create_minimal_user(email='this.is@user',
+                                        groups=groups, save_now=True)
 
         workspace = WorkspaceApi(
             current_user=user,

tracim/tests/library/test_notification.py

@@ -4,18 +4,20 @@ import re
 
 
 from tracim.lib.core.notifications import DummyNotifier
-from tracim.lib.core.notifications import EmailNotifier
+
 from tracim.lib.core.notifications import NotifierFactory
+from tracim.lib.mail_notifier.notifier import EmailNotifier
 from tracim.models.auth import User
 from tracim.models.data import Content
 from tracim.tests import DefaultTest
 from tracim.tests import eq_
 
+
 class TestDummyNotifier(DefaultTest):
 
     def test_dummy_notifier__notify_content_update(self):
         c = Content()
-        notifier = DummyNotifier(self.app_config)
+        notifier = DummyNotifier(self.app_config, self.session)
         notifier.notify_content_update(c)
         # INFO - D.A. - 2014-12-09 -
         # Old notification_content_update raised an exception

tracim/tests/library/test_user_api.py

@@ -14,19 +14,49 @@ from tracim.tests import eq_
 
 class TestUserApi(DefaultTest):
 
-    def test_unit__create_and_update_user__ok__nominal_case(self):
+    def test_unit__create_minimal_user__ok__nominal_case(self):
         api = UserApi(
             current_user=None,
             session=self.session,
             config=self.config,
         )
-        u = api.create_user()
-        api.update(u, 'bob', 'bob@bob', True)
+        u = api.create_minimal_user('bob@bob')
+        assert u.email == 'bob@bob'
+        assert u.display_name is None
 
+    def test_unit__create_minimal_user_and_update__ok__nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.config,
+        )
+        u = api.create_minimal_user('bob@bob')
+        api.update(u, 'bob', 'bob@bob', 'pass', do_save=True)
         nu = api.get_one_by_email('bob@bob')
-        assert nu != None
-        eq_('bob@bob', nu.email)
-        eq_('bob', nu.display_name)
+        assert nu is not None
+        assert nu.email == 'bob@bob'
+        assert nu.display_name == 'bob'
+        assert nu.validate_password('pass')
+
+    def test__unit__create__user__ok_nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.config,
+        )
+        u = api.create_user(
+            email='bob@bob',
+            password='pass',
+            name='bob',
+            timezone='+2',
+            do_save=True,
+            do_notify=False,
+        )
+        assert u is not None
+        assert u.email == "bob@bob"
+        assert u.validate_password('pass')
+        assert u.display_name == 'bob'
+        assert u.timezone == '+2'
 
     def test_unit__user_with_email_exists__ok__nominal_case(self):
         api = UserApi(
@@ -34,21 +64,22 @@ class TestUserApi(DefaultTest):
             session=self.session,
             config=self.config,
         )
-        u = api.create_user()
-        api.update(u, 'bibi', 'bibi@bibi', True)
+        u = api.create_minimal_user('bibi@bibi')
+        api.update(u, 'bibi', 'bibi@bibi', 'pass', do_save=True)
         transaction.commit()
 
         eq_(True, api.user_with_email_exists('bibi@bibi'))
         eq_(False, api.user_with_email_exists('unknown'))
 
-    def test_unit__get_one_by_email__ok__nominal_case(self):
+    def test_get_one_by_email(self):
         api = UserApi(
             current_user=None,
             session=self.session,
             config=self.config,
         )
-        u = api.create_user()
-        api.update(u, 'bibi', 'bibi@bibi', True)
+        u = api.create_minimal_user('bibi@bibi')
+        self.session.flush()
+        api.update(u, 'bibi', 'bibi@bibi', 'pass', do_save=True)
         uid = u.user_id
         transaction.commit()
 
@@ -63,17 +94,17 @@ class TestUserApi(DefaultTest):
         with pytest.raises(UserDoesNotExist):
             api.get_one_by_email('unknown')
 
-    # def test_unit__get_all__ok__nominal_case(self):
-    #     # TODO - G.M - 29-03-2018 Check why this method is not enabled
-    #     api = UserApi(
-    #         current_user=None,
-    #         session=self.session,
-    #         config=self.config,
-    #     )
-    #     u1 = api.create_user(True)
-    #     u2 = api.create_user(True)
-    #     users = api.get_all()
-    #     assert 2==len(users)
+    def test_unit__get_all__ok__nominal_case(self):
+        api = UserApi(
+            current_user=None,
+            session=self.session,
+            config=self.config,
+        )
+        u1 = api.create_minimal_user('bibi@bibi')
+
+        users = api.get_all()
+        # u1 + Admin user from BaseFixture
+        assert 2 == len(users)
 
     def test_unit__get_one__ok__nominal_case(self):
         api = UserApi(
@@ -81,8 +112,8 @@ class TestUserApi(DefaultTest):
             session=self.session,
             config=self.config,
         )
-        u = api.create_user()
-        api.update(u, 'titi', 'titi@titi', True)
+        u = api.create_minimal_user('titi@titi')
+        api.update(u, 'titi', 'titi@titi', 'pass', do_save=True)
         one = api.get_one(u.user_id)
         eq_(u.user_id, one.user_id)
 

tracim/tests/library/test_webdav.py

@@ -3,8 +3,10 @@ import io
 
 import pytest
 from sqlalchemy.exc import InvalidRequestError
-
+from wsgidav.wsgidav_app import DEFAULT_CONFIG
+from tracim import WebdavAppFactory
 from tracim.lib.core.user import UserApi
+from tracim.lib.webdav import TracimDomainController
 from tracim.tests import eq_
 from tracim.lib.core.notifications import DummyNotifier
 from tracim.lib.webdav.dav_provider import Provider
@@ -15,6 +17,53 @@ from tracim.tests import StandardTest
 from tracim.fixtures.content import Content as ContentFixtures
 from tracim.fixtures.users_and_groups import Base as BaseFixture
 from wsgidav import util
+from unittest.mock import MagicMock
+
+
+class TestWebdavFactory(StandardTest):
+
+    def test_unit__initConfig__ok__nominal_case(self):
+        """
+        Check if config is correctly modify for wsgidav using mocked
+        wsgidav and tracim conf (as dict)
+        :return:
+        """
+        tracim_settings = {
+            'sqlalchemy.url': 'sqlite:///:memory:',
+            'user.auth_token.validity': '604800',
+            'depot_storage_dir': '/tmp/test/depot',
+            'depot_storage_name': 'test',
+            'preview_cache_dir': '/tmp/test/preview_cache',
+            'wsgidav.config_path': 'development.ini'
+
+        }
+        wsgidav_setting = DEFAULT_CONFIG.copy()
+        wsgidav_setting.update(
+            {
+               'root_path':  '',
+               'acceptbasic': True,
+               'acceptdigest': False,
+               'defaultdigest': False,
+            }
+        )
+        mock = MagicMock()
+        mock._initConfig = WebdavAppFactory._initConfig
+        mock._readConfigFile.return_value = wsgidav_setting
+        mock._get_tracim_settings.return_value = tracim_settings
+        config = mock._initConfig(mock)
+        assert config
+        assert config['acceptbasic'] is True
+        assert config['acceptdigest'] is False
+        assert config['defaultdigest'] is False
+        # TODO - G.M - 25-05-2018 - Better check for middleware stack config
+        assert 'middleware_stack' in config
+        assert len(config['middleware_stack']) == 7
+        assert 'root_path' in config
+        assert 'provider_mapping' in config
+        assert config['root_path'] in config['provider_mapping']
+        assert isinstance(config['provider_mapping'][config['root_path']], Provider)  # nopep8
+        assert 'domaincontroller' in config
+        assert isinstance(config['domaincontroller'], TracimDomainController)
 
 
 class TestWebDav(StandardTest):

tracim/tests/library/test_workspace.py

@@ -53,7 +53,7 @@ class TestThread(DefaultTest):
             current_user=admin,
             config=self.config
         )
-        u = uapi.create_user(email='u.u@u.u', save_now=True)
+        u = uapi.create_minimal_user(email='u.u@u.u', save_now=True)
         eq_([], wapi.get_notifiable_roles(workspace=w))
         rapi = RoleApi(
             session=self.session,
@@ -92,7 +92,7 @@ class TestThread(DefaultTest):
             current_user=None,
             config=self.app_config,
         )
-        u = uapi.create_user('u.s@e.r', [gapi.get_one(Group.TIM_USER)], True)
+        u = uapi.create_minimal_user('u.s@e.r', [gapi.get_one(Group.TIM_USER)], True)
         wapi = WorkspaceApi(
             session=self.session,
             current_user=u,

tracim/views/core_api/session_controller.py

@@ -13,7 +13,7 @@ from tracim.views.core_api.schemas import UserSchema
 from tracim.views.core_api.schemas import NoContentSchema
 from tracim.views.core_api.schemas import LoginOutputHeaders
 from tracim.views.core_api.schemas import BasicAuthSchema
-from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import NotAuthenticated
 from tracim.exceptions import AuthenticationFailed
 
 
@@ -52,7 +52,7 @@ class SessionController(Controller):
         return
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.output_body(UserSchema(),)
     def whoami(self, context, request: TracimRequest, hapic_data=None):
         """

tracim/views/core_api/system_controller.py

@@ -1,7 +1,7 @@
 # coding=utf-8
 from pyramid.config import Configurator
 
-from tracim.exceptions import NotAuthentificated, InsufficientUserProfile
+from tracim.exceptions import NotAuthenticated, InsufficientUserProfile
 from tracim.lib.utils.authorization import require_profile
 from tracim.models import Group
 from tracim.models.applications import applications
@@ -20,7 +20,7 @@ from tracim.views.core_api.schemas import ApplicationSchema
 class SystemController(Controller):
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @require_profile(Group.TIM_USER)
     @hapic.output_body(ApplicationSchema(many=True),)

tracim/views/core_api/user_controller.py

@@ -12,7 +12,7 @@ except ImportError:
 
 from tracim import hapic, TracimRequest
 
-from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import NotAuthenticated
 from tracim.exceptions import InsufficientUserProfile
 from tracim.exceptions import UserDoesNotExist
 from tracim.lib.core.workspace import WorkspaceApi
@@ -24,7 +24,7 @@ from tracim.views.core_api.schemas import WorkspaceDigestSchema
 class UserController(Controller):
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(UserDoesNotExist, HTTPStatus.NOT_FOUND)
     @require_same_user_or_profile(Group.TIM_ADMIN)

tracim/views/core_api/workspace_controller.py

@@ -15,7 +15,7 @@ except ImportError:
     from http import client as HTTPStatus
 
 from tracim import hapic, TracimRequest
-from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import NotAuthenticated
 from tracim.exceptions import InsufficientUserProfile
 from tracim.exceptions import WorkspaceNotFound
 from tracim.lib.core.user import UserApi
@@ -29,7 +29,7 @@ from tracim.views.core_api.schemas import WorkspaceMemberSchema
 class WorkspaceController(Controller):
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.READER)
@@ -49,7 +49,7 @@ class WorkspaceController(Controller):
         return wapi.get_workspace_with_context(request.current_workspace)
 
     @hapic.with_api_doc()
-    @hapic.handle_exception(NotAuthentificated, HTTPStatus.UNAUTHORIZED)
+    @hapic.handle_exception(NotAuthenticated, HTTPStatus.UNAUTHORIZED)
     @hapic.handle_exception(InsufficientUserProfile, HTTPStatus.FORBIDDEN)
     @hapic.handle_exception(WorkspaceNotFound, HTTPStatus.FORBIDDEN)
     @require_workspace_role(UserRoleInWorkspace.READER)

wsgi/__init__.py

@@ -0,0 +1,17 @@
+# coding=utf-8
+import plaster
+import pyramid.paster
+
+from tracim.lib.webdav import WebdavAppFactory
+
+
+def web_app(config_uri):
+    pyramid.paster.setup_logging(config_uri)
+    return pyramid.paster.get_app(config_uri)
+
+
+def webdav_app(config_uri):
+    config_uri = '{}#webdav'.format(config_uri)
+    plaster.setup_logging(config_uri)
+    loader = plaster.get_loader(config_uri, protocols=['wsgi'])
+    return loader.get_wsgi_app()

wsgi/web.py

@@ -1,9 +1,7 @@
 # coding=utf-8
 # Runner for uwsgi
 import os
-import pyramid.paster
+from wsgi import web_app
 
 config_uri = os.environ['TRACIM_CONF_PATH']
-
-pyramid.paster.setup_logging(config_uri)
-application = pyramid.paster.get_app(config_uri)
+application = web_app(config_uri)

wsgi/webdav.py

@@ -1,12 +1,7 @@
 # coding=utf-8
 # Runner for uwsgi
-from tracim.lib.webdav import WebdavAppFactory
 import os
+from wsgi import webdav_app
 
 config_uri = os.environ['TRACIM_CONF_PATH']
-webdav_config_uri = os.environ['TRACIM_WEBDAV_CONF_PATH']
-app_factory = WebdavAppFactory(
-    tracim_config_file_path=config_uri,
-    webdav_config_file_path=webdav_config_uri,
-)
-application = app_factory.get_wsgi_app()
+application = webdav_app(config_uri)