CFG object is now accessible with self.app_config, config is now param of ContentApi + add Minimal notification code

tracim/config.py

 # -*- coding: utf-8 -*-
 from urllib.parse import urlparse
+from paste.deploy.converters import asbool
 from tracim.lib.utils.logger import logger
 from depot.manager import DepotManager
 
 
 class RequestWithCFG(Request):
 
-    def config(self):
+    def app_config(self):
         cfg = CFG(self.registry.settings)
         cfg.configure_filedepot()
         return cfg
         #     'email.notification.processing_mode',
         # )
         #
-        # self.EMAIL_NOTIFICATION_ACTIVATED = asbool(settings.get(
-        #     'email.notification.activated',
-        # ))
+        self.EMAIL_NOTIFICATION_ACTIVATED = asbool(settings.get(
+            'email.notification.activated',
+        ))
         # self.EMAIL_NOTIFICATION_SMTP_SERVER = settings.get(
         #     'email.notification.smtp.server',
         # )

tracim/lib/core/content.py

 from sqlalchemy import or_
 from sqlalchemy.sql.elements import and_
 from tracim.lib.utils.utils import cmp_to_key
-# from tracim.lib.notifications import NotifierFactory
+from tracim.lib.core.notifications import NotifierFactory
 from tracim.exceptions import SameValueError
 from tracim.lib.utils.utils import current_date_for_filename
 from tracim.models.revision_protection import new_revision
             self,
             session: Session,
             current_user: typing.Optional[User],
+            config,
             show_archived=False,
             show_deleted=False,
             show_temporary=False,
     ):
         self._session = session
         self._user = current_user
+        self._config = config
         self._user_id = current_user.user_id if current_user else None
         self._show_archived = show_archived
         self._show_deleted = show_deleted
         if do_notify:
             self.do_notify(content)
 
-    # TODO - G.M - 28-03-2018 - [Notification] Re-enable notification
     def do_notify(self, content: Content):
-         pass
-    #     """
-    #     Allow to force notification for a given content. By default, it is
-    #     called during the .save() operation
-    #     :param content:
-    #     :return:
-    #     """
-    #     NotifierFactory.create(self._user).notify_content_update(content)
+        """
+        Allow to force notification for a given content. By default, it is
+        called during the .save() operation
+        :param content:
+        :return:
+        """
+        NotifierFactory.create(
+            self._config,
+            self._user
+        ).notify_content_update(content)
 
     def get_keywords(self, search_string, search_string_separators=None) -> [str]:
         """

tracim/lib/core/notifications.py

+# -*- coding: utf-8 -*-
+
+from tracim.lib.utils.logger import logger
+from tracim.models.auth import User
+from tracim.models.data import Content
+
+
+class INotifier(object):
+    """
+    Interface for Notifier instances
+    """
+    def __init__(self, config, current_user: User=None):
+        pass
+
+    def notify_content_update(self, content: Content):
+        raise NotImplementedError
+
+
+class NotifierFactory(object):
+
+    @classmethod
+    def create(cls, config, current_user: User=None) -> INotifier:
+        if not config.EMAIL_NOTIFICATION_ACTIVATED:
+            return DummyNotifier(config, current_user)
+        return EmailNotifier(config, current_user)
+
+
+class DummyNotifier(INotifier):
+    send_count = 0
+
+    def __init__(self, config, current_user: User=None):
+        INotifier.__init__(config, current_user)
+        logger.info(self, 'Instantiating Dummy Notifier')
+
+    def notify_content_update(self, content: Content):
+        type(self).send_count += 1
+        logger.info(
+            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/tests/__init__.py

             'test', {'depot.backend': 'depot.io.memory.MemoryFileStorage'}
         )
         settings = self.config.get_settings()
-
+        self.app_config = CFG(settings)
         from tracim.models import (
             get_engine,
             get_session_factory,
         content_api = ContentApi(
             current_user=None,
             session=self.session,
+            config=self.app_config,
         )
         eq_(
             1,

tracim/tests/library/test_content_api.py

     def test_delete(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(current_user=None,session=self.session)
         api = ContentApi(
             current_user=user,
             session=self.session,
+            config=self.app_config,
         )
         item = api.create(ContentType.Folder, workspace, None,
                           'not_deleted', True)
         user = uapi.get_one(uid)
         workspace_api = WorkspaceApi(current_user=user, session=self.session)
         workspace = workspace_api.get_one(wid)
-        api = ContentApi(current_user=user, session=self.session)
+        api = ContentApi(
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
+        )
         items = api.get_all(None, ContentType.Any, workspace)
         eq_(2, len(items))
 
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         items = api.get_all(None, ContentType.Any, workspace)
         eq_(1, len(items))
         api = ContentApi(
             current_user=user,
             session=self.session,
-            show_deleted=True
+            config=self.app_config,
+            show_deleted=True,
         )
         items = api.get_all(None, ContentType.Any, workspace)
         eq_(2, len(items))
     def test_archive(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(current_user=None, session=self.session)
         api = ContentApi(
             current_user=user,
             session=self.session,
+            config=self.app_config,
         )
         item = api.create(ContentType.Folder, workspace, None,
                           'not_archived', True)
         api = ContentApi(
             session=self.session,
             current_user=user,
+            config=self.app_config,
         )
 
         items = api.get_all(None, ContentType.Any, workspace)
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
 
         items = api.get_all(None, ContentType.Any, workspace)
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
 
         # Test that the item is still available if "show deleted" is activated
         api = ContentApi(
             current_user=None,
             session=self.session,
-            show_archived=True
+            config=self.app_config,
+            show_archived=True,
         )
         items = api.get_all(None, ContentType.Any, workspace)
         eq_(2, len(items))
     def test_get_all_with_filter(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(current_user=None, session=self.session)
         api = ContentApi(
             current_user=user,
             session=self.session,
+            config=self.app_config,
         )
         item = api.create(ContentType.Folder, workspace, None,
                           'thefolder', True)
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user, 
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
 
         items = api.get_all(None, ContentType.Any, workspace)
     def test_get_all_with_parent_id(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(current_user=None, session=self.session)
         ).create_workspace('test workspace', save_now=True)
         api = ContentApi(
             current_user=user, 
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         item = api.create(
             ContentType.Folder,
         workspace = workspace_api.get_one(wid)
         api = ContentApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
 
         items = api.get_all(None, ContentType.Any, workspace)
     def test_set_status_unknown_status(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         )
         api = ContentApi(
             current_user=user, 
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         c = api.create(ContentType.Folder, workspace, None, 'parent', True)
         with new_revision(
     def test_set_status_ok(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
             save_now=True
         )
         api = ContentApi(
-            current_user=user, 
-            session=self.session
+            current_user=user,
+            session=self.session,
+            config=self.app_config,
         )
         c = api.create(ContentType.Folder, workspace, None, 'parent', True)
         with new_revision(
     def test_create_comment_ok(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
 
         api = ContentApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         p = api.create(ContentType.Page, workspace, None, 'this_is_a_page')
         c = api.create_comment(workspace, p, 'this is the comment', True)
     def test_unit_copy_file_different_label_different_parent_ok(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         )
         api = ContentApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         foldera = api.create(
             ContentType.Folder,
             )
 
         api.save(text_file, ActionDescription.CREATION)
-        api2 = ContentApi(current_user=user2, session=self.session)
+        api2 = ContentApi(
+            current_user=user2,
+            session=self.session,
+            config=self.app_config,
+        )
         workspace2 = WorkspaceApi(
             current_user=user2,
             session=self.session,
     def test_unit_copy_file__same_label_different_parent_ok(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         )
         api = ContentApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         foldera = api.create(
             ContentType.Folder,
         api2 = ContentApi(
             current_user=user2,
             session=self.session,
+            config=self.app_config,
         )
         workspace2 = WorkspaceApi(
             current_user=user2,
     def test_unit_copy_file_different_label_same_parent_ok(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         )
         api = ContentApi(
             current_user=user,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         foldera = api.create(
             ContentType.Folder,
             text_file,
             ActionDescription.CREATION
         )
-        api2 = ContentApi(current_user=user2, session=self.session)
+        api2 = ContentApi(
+            current_user=user2,
+            session=self.session,
+            config=self.app_config,
+        )
 
         api2.copy(
             item=text_file,
     def test_mark_read__workspace(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         cont_api_a = ContentApi(
             current_user=user_a,
             session=self.session,
+            config=self.app_config,
         )
         cont_api_b = ContentApi(
             current_user=user_b,
             session=self.session,
+            config=self.app_config,
         )
 
         # Creates page_1 & page_2 in workspace 1
     def test_mark_read(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         cont_api_a = ContentApi(
             current_user=user_a,
             session=self.session,
+            config=self.app_config,
         )
         cont_api_b = ContentApi(
             current_user=user_b,
             session=self.session,
+            config=self.app_config,
         )
 
         page_1 = cont_api_a.create(ContentType.Page, workspace, None,
     def test_mark_read__all(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(current_user=None, session=self.session)
         cont_api_a = ContentApi(
             current_user=user_a,
             session=self.session,
+            config=self.app_config,
         )
         cont_api_b = ContentApi(
             current_user=user_b,
             session=self.session,
+            config=self.app_config,
         )
 
         page_2 = cont_api_a.create(
     def test_update(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(current_user=None, session=self.session)
         api = ContentApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         )
 
         p = api.create(ContentType.Page, workspace, None,
         api = ContentApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         )
 
         content = api.get_one(pcid, ContentType.Any, workspace)
 
         u2 = UserApi(
             session=self.session,
-            config=self.config,
+            config=self.app_config,
             current_user=None,
         ).get_one(u2id)
         api2 = ContentApi(
             current_user=u2,
             session=self.session,
+            config=self.app_config,
         )
         content2 = api2.get_one(pcid, ContentType.Any, workspace)
         with new_revision(
         api = ContentApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
         )
 
         updated = api.get_one(pcid, ContentType.Any, workspace)
     def test_update_no_change(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         )
         api = ContentApi(
             current_user=user1,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         with self.session.no_autoflush:
             page = api.create(
         api2 = ContentApi(
             current_user=user2,
             session=self.session,
+            config=self.app_config,
         )
         content2 = api2.get_one(page.content_id, ContentType.Any, workspace)
         with new_revision(
     def test_update_file_data(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         # Test starts here
         api = ContentApi(
             current_user=user1,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         p = api.create(ContentType.File, workspace, None,
                        'this_is_a_page', True)
         user1 = uapi.get_one(u1id)
         workspace_api2 = WorkspaceApi(current_user=user1, session=self.session)
         workspace = workspace_api2.get_one(wid)
-        api = ContentApi(current_user=user1, session=self.session)
+        api = ContentApi(
+            current_user=user1,
+            session=self.session,
+            config=self.app_config,
+        )
 
         content = api.get_one(pcid, ContentType.Any, workspace)
         eq_(u1id, content.owner_id)
         u2 = UserApi(
             current_user=None,
             session=self.session,
-            config=self.config,
+            config=self.app_config,
         ).get_one(u2id)
         api2 = ContentApi(
             current_user=u2,
             session=self.session,
+            config=self.app_config,
         )
         content2 = api2.get_one(pcid, ContentType.Any, workspace)
         with new_revision(
     def test_update_no_change(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
             with_notif=False,
             flush=True
         )
-        api = ContentApi(current_user=user1, session=self.session)
+        api = ContentApi(
+            current_user=user1,
+            session=self.session,
+            config=self.app_config,
+        )
         with self.session.no_autoflush:
             page = api.create(
                 content_type=ContentType.Page,
         api.save(page, ActionDescription.CREATION, do_notify=True)
         transaction.commit()
 
-        api2 = ContentApi(current_user=user2, session=self.session)
+        api2 = ContentApi(
+            current_user=user2,
+            session=self.session,
+            config=self.app_config,
+        )
         content2 = api2.get_one(page.content_id, ContentType.Any, workspace)
         with new_revision(
             session=self.session,
     def test_archive_unarchive(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(current_user=None, session=self.session)
             current_user=user1,
             session=self.session,
             show_archived=True,
+            config=self.app_config,
         )
         p = api.create(ContentType.File, workspace, None,
                        'this_is_a_page', True)
         # refresh after commit
         user1 = UserApi(
             current_user=None,
-            config=self.config,
+            config=self.app_config,
             session=self.session
         ).get_one(u1id)
         workspace = WorkspaceApi(
 
         u2api = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         u2 = u2api.get_one(u2id)
         api2 = ContentApi(
             current_user=u2,
             session=self.session,
-            show_archived=True
+            config=self.app_config,
+            show_archived=True,
         )
         content2 = api2.get_one(pcid, ContentType.Any, workspace)
         with new_revision(
         user1 = UserApi(
             current_user=None,
             session=self.session,
-            config=self.config,
+            config=self.app_config,
         ).get_one(u1id)
         workspace = WorkspaceApi(
             current_user=user1,
         u2 = UserApi(
             current_user=None,
             session=self.session,
-            config=self.config
+            config=self.app_config,
         ).get_one(u2id)
         api = ContentApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
             show_archived=True,
         )
         api2 = ContentApi(
             current_user=u2,
             session=self.session,
+            config=self.app_config,
             show_archived=True,
         )
 
     def test_delete_undelete(self):
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
         api = ContentApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
             show_deleted=True,
         )
         p = api.create(ContentType.File, workspace, None,
         user1 = UserApi(
             current_user=None,
             session=self.session,
-            config=self.config,
+            config=self.app_config,
         ).get_one(u1id)
         workspace = WorkspaceApi(
             current_user=user1,
         u2 = UserApi(
             current_user=None,
             session=self.session,
-            config=self.config,
+            config=self.app_config,
         ).get_one(u2id)
         api2 = ContentApi(
             current_user=u2,
             session=self.session,
+            config=self.app_config,
             show_deleted=True,
         )
         content2 = api2.get_one(pcid, ContentType.Any, workspace)
         user1 = UserApi(
             current_user=None,
             session=self.session,
-            config=self.config,
+            config=self.app_config,
         ).get_one(u1id)
         workspace = WorkspaceApi(
             current_user=user1,
         api = ContentApi(
             current_user=user1,
             session=self.session,
+            config=self.app_config,
             show_deleted=True,
         )
         u2 = UserApi(
             current_user=None,
             session=self.session,
-            config=self.config,
+            config=self.app_config,
         ).get_one(u2id)
         api2 = ContentApi(
             current_user=u2,
             session=self.session,
+            config=self.app_config,
             show_deleted=True
         )
 
         # at root of a workspace (eg a folder)
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
 
         api = ContentApi(
             current_user=user, 
-            session=self.session
+            session=self.session,
+            config=self.app_config,
+
         )
         a = api.create(ContentType.Folder, workspace, None,
                        'this is randomized folder', True)
 
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(
 
         api = ContentApi(
             current_user=user, 
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         a = api.create(ContentType.Folder, workspace, None,
                        'this is randomized folder', True)
 
         uapi = UserApi(
             session=self.session,
-            config=CFG(self.config.get_settings()),
+            config=self.app_config,
             current_user=None,
         )
         group_api = GroupApi(current_user=None, session=self.session)
 
         api = ContentApi(
             current_user=user, 
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         )
         a = api.create(ContentType.Folder, workspace, None,
                        'this is randomized folder', True)
         api = ContentApi(
             current_user=admin,
             session=self.session,
+            config=self.app_config,
         )
 
         foo_result = api.search(['foo']).all()
 
         bob_page = ContentApi(
             current_user=bob,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create(
             content_type=ContentType.Page,
             workspace=bob_workspace,
 
         admin_page = ContentApi(
             current_user=admin,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).create(
             content_type=ContentType.Page,
             workspace=admin_workspace,
 
         bob_viewable = ContentApi(
             current_user=bob,
-            session=self.session
+            session=self.session,
+            config=self.app_config,
         ).get_all()
         eq_(1, len(bob_viewable), 'Bob should view only one content')
         eq_(

tracim/tests/library/test_notification.py

+# -*- coding: utf-8 -*-
+import os
+import re
+
+from nose.tools import eq_
+from nose.tools import ok_
+
+from tracim.lib.core.notifications import DummyNotifier
+from tracim.lib.core.notifications import EmailNotifier
+from tracim.lib.core.notifications import NotifierFactory
+from tracim.models.auth import User
+from tracim.models.data import Content
+from tracim.tests import DefaultTest
+
+
+class TestDummyNotifier(DefaultTest):
+
+    def test_dummy_notifier__notify_content_update(self):
+        c = Content()
+        notifier = DummyNotifier(self.app_config)
+        notifier.notify_content_update(c)
+        # INFO - D.A. - 2014-12-09 -
+        # Old notification_content_update raised an exception
+
+
+class TestNotifierFactory(DefaultTest):
+    def test_notifier_factory_method(self):
+        u = User()
+
+        self.app_config.EMAIL_NOTIFICATION_ACTIVATED = True
+        notifier = NotifierFactory.create(self.app_config, u)
+        eq_(EmailNotifier, notifier.__class__)
+
+        self.app_config.EMAIL_NOTIFICATION_ACTIVATED = False
+        notifier = NotifierFactory.create(self.app_config, u)
+        eq_(DummyNotifier, notifier.__class__)
+
+
+class TestEmailNotifier(DefaultTest):
+    # TODO - G.M - 04-03-2017 -  [emailNotif] - Restore test for email Notif
+    pass

tracim/tests/library/test_workspace.py

         content_api = ContentApi(
             session=self.session,
             current_user=admin,
+            config=self.app_config,
         )
         folder = content_api.get_canonical_query().filter(
             Content.label == 'folder_1'

tracim/tests/models/test_content.py

         user_admin = self.session.query(User)\
             .filter(User.email == 'admin@admin.admin').one()
 
-        api = ContentApi(current_user=None, session=self.session)
+        api = ContentApi(
+            current_user=None,
+            session=self.session,
+            config=self.app_config,
+        )
 
         content1_from_api = api.get_one(
             content1.id,

tracim/views/default.py

 @view_config(route_name='home', renderer='../templates/mytemplate.jinja2')
 def test_config(request):
     try:
-        project = request.config().WEBSITE_TITLE
+        project = request.app_config().WEBSITE_TITLE
     except Exception as e:
         return Response(e, content_type='text/plain', status=500)
     return {'project': project}
 
 # @view_config(route_name='home', renderer='../templates/mytemplate.jinja2')
 # def my_view(request):
-#     try:
-#         query = request.dbsession.query(MyModel)
+#     try:#         query = request.dbsession.query(MyModel)
 #         one = query.filter(MyModel.name == 'one').first()
 #     except DBAPIError:
 #         return Response(db_err_msg, content_type='text/plain', status=500)