Merge pull request #49 from buxx/dev/_/41/radicale

install/requirements.txt

 waitress==0.8.9
 zope.interface==4.1.3
 zope.sqlalchemy==0.7.6
-tgapp-resetpassword==0.1.3
+git+https://github.com/algoo/tgapp-resetpassword.git@master
 lxml
 python-ldap-test==0.2.0
 who-ldap==3.1.0
+unicode-slugify==0.1.3
+Radicale==1.1.1
+icalendar==3.10

tracim/development.ini.base

 email.notification.smtp.user = your_smtp_user
 email.notification.smtp.password = your_smtp_password
 
+## Radical (CalDav server) configuration
+# radicale.server.host = 0.0.0.0
+# radicale.server.port = 5232
+# radicale.server.ssl = false
+# radicale.server.filesystem.folder = ~/.config/radicale/collections
+## If '', current host will be used
+# radicale.client.host = ''
+# radicale.client.port = 5232
+# radicale.client.ssl = false
 
 #####
 #

tracim/migration/versions/534c4594ed29_add_calendar_enabled_column_to_workspace.py

+"""Add calendar_enabled column to Workspace
+
+Revision ID: 534c4594ed29
+Revises: da12239d9da0
+Create Date: 2016-05-31 13:02:28.301984
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '534c4594ed29'
+down_revision = 'da12239d9da0'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('workspaces', sa.Column('calendar_enabled', sa.Boolean(), nullable=False, server_default='0'))
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('workspaces', 'calendar_enabled')
+    ### end Alembic commands ###

tracim/scripts/tst_create_cal.py

+import caldav
+from radicale import ical
+
+#
+# Run it in gearbox command with app context (radicale must running)
+# pip package caldav==0.4.0 must be installed
+# run following
+
+
+client = caldav.DAVClient('http://127.0.0.1:5232',
+                          username='admin@admin.admin',
+                          password='admin@admin.admin')
+
+calendar = caldav.Calendar(
+    parent=client,
+    client=client,
+    id='/user/1.ics/',
+    # url='http://127.0.0.1:5232/user/1.ics/'
+)
+
+calendar.save()
+
+# FOR EACH EVENT IN THIS CALENDAR:
+
+coll = ical.Collection.from_path('/user/1.ics/')[0]
+with coll.filesystem_only():
+    coll.append(name='THE EVENT NAME (ID)', text='THE ICS EVENT RAW')
+
+
+pass

tracim/setup.py

     "repoze.who",
     "who-ldap==3.1.0",
     "python-ldap-test==0.2.0",
+    "unicode-slugify==0.1.3",
     ]
 
 setup(

tracim/test.ini

 error_email_from = turbogears@localhost
 
 [server:main]
-use = egg:gearbox#cherrypy
+use = egg:gearbox#wsgiref
 host = 127.0.0.1
 port = 8080
 

tracim/tracim/config/app_cfg.py

 
 import tg
 from paste.deploy.converters import asbool
+from tg.configuration.milestones import environment_loaded
 
 from tgext.pluggable import plug
 from tgext.pluggable import replace_template
 from tracim.lib import app_globals, helpers
 from tracim.lib.auth.wrapper import AuthConfigWrapper
 from tracim.lib.base import logger
+from tracim.lib.daemons import DaemonsManager
+from tracim.lib.daemons import RadicaleDaemon
 from tracim.model.data import ActionDescription
 from tracim.model.data import ContentType
 
 # flash.js_call -> javascript code which will be run when displaying the flash from javascript. Default is webflash.render(), you can use webflash.payload() to retrieve the message and show it with your favourite library.
 # flash.js_template -> string.Template instance used to replace full javascript support for flash messages. When rendering flash message for javascript usage the following code will be used instead of providing the standard webflash object. If you replace js_template you must also ensure cookie parsing and delete it for already displayed messages. The template will receive: $container_id, $cookie_name, $js_call variables.
 
+base_config['templating.genshi.name_constant_patch'] = True
 
 # Configure the authentication backend
 
 replace_template(base_config, 'resetpassword.templates.index', 'tracim.templates.reset_password_index')
 replace_template(base_config, 'resetpassword.templates.change_password', 'mako:tracim.templates.reset_password_change_password')
 
+daemons = DaemonsManager()
+
+
+def start_daemons(manager: DaemonsManager):
+    """
+    Sart Tracim daemons
+    """
+    manager.run('radicale', RadicaleDaemon)
+
+environment_loaded.register(lambda: start_daemons(daemons))
+
 # Note: here are fake translatable strings that allow to translate messages for reset password email content
 duplicated_email_subject = l_('Password reset request')
 duplicated_email_body = l_('''
             # ContentType.Folder -- Folder is skipped
         ]
 
+        self.RADICALE_SERVER_HOST = tg.config.get('radicale.server.host', '0.0.0.0')
+        self.RADICALE_SERVER_PORT = tg.config.get('radicale.server.port', 5232)
+        # Note: Other parameters needed to work in SSL (cert file, etc)
+        self.RADICALE_SERVER_SSL = asbool(tg.config.get('radicale.server.ssl', False))
+        self.RADICALE_SERVER_FILE_SYSTEM_FOLDER = tg.config.get(
+            'radicale.server.filesystem.folder',
+            '~/.config/radicale/collections'
+        )
+
+        # If None, current host will be used
+        self.RADICALE_CLIENT_HOST = tg.config.get('radicale.client.host', None)
+        self.RADICALE_CLIENT_PORT = tg.config.get('radicale.client.port', 5232)
+        self.RADICALE_CLIENT_SSL = asbool(tg.config.get('radicale.client.ssl', False))
+
 
     def get_tracker_js_content(self, js_tracker_file_path = None):
         js_tracker_file_path = tg.config.get('js_tracker_path', None)

tracim/tracim/config/middleware.py

 
 from tracim.config.app_cfg import base_config
 from tracim.config.environment import load_environment
-
+from tracim.lib.daemons import DaemonsManager
+from tracim.lib.daemons import RadicaleDaemon
 
 __all__ = ['make_app']
 
     app = make_base_app(global_conf, full_stack=True, **app_conf)
     
     # Wrap your base TurboGears 2 application with custom middleware here
-    
+
     return app

tracim/tracim/controllers/admin/workspace.py

 from tracim.lib.userworkspace import RoleApi
 from tracim.lib.content import ContentApi
 from tracim.lib.workspace import WorkspaceApi
+from tracim.model import DBSession
 
 from tracim.model.auth import Group
 from tracim.model.data import NodeTreeItem
         return dict(result = dictified_workspace, fake_api = fake_api)
 
     @tg.expose()
-    def post(self, name, description):
+    def post(self, name, description, calendar_enabled=False):
         # FIXME - Check user profile
         user = tmpl_context.current_user
         workspace_api_controller = WorkspaceApi(user)
 
         workspace = workspace_api_controller.create_workspace(name, description)
+        workspace.calendar_enabled = calendar_enabled
+        DBSession.flush()
 
         tg.flash(_('{} workspace created.').format(workspace.label), CST.STATUS_OK)
         tg.redirect(self.url())
         return DictLikeClass(result = dictified_workspace)
 
     @tg.expose('tracim.templates.workspace.edit')
-    def put(self, id, name, description):
+    def put(self, id, name, description, calendar_enabled):
         user = tmpl_context.current_user
         workspace_api_controller = WorkspaceApi(user)
 
         workspace = workspace_api_controller.get_one(id)
         workspace.label = name
         workspace.description = description
+        workspace.calendar_enabled = calendar_enabled
         workspace_api_controller.save(workspace)
 
         tg.flash(_('{} workspace updated.').format(workspace.label), CST.STATUS_OK)

tracim/tracim/controllers/root.py

 from tracim.controllers.help import HelpController
 from tracim.controllers.user import UserRestController
 from tracim.controllers.workspace import UserWorkspaceRestController
+from tracim.lib.utils import replace_reset_password_templates
 
 from tracim.model.data import ContentType
 from tracim.model.serializers import DictLikeClass
     workspaces = UserWorkspaceRestController()
     user = UserRestController()
 
+    def _render_response(self, tgl, controller, response):
+        replace_reset_password_templates(controller.decoration.engines)
+        return super()._render_response(tgl, controller, response)
+
     def _before(self, *args, **kw):
         super(RootController, self)._before(args, kw)
         tmpl_context.project_name = "tracim"

tracim/tracim/controllers/workspace.py

         # ,
         #                      sub_items=Context(CTX.FOLDER_CONTENT_LIST).toDict(dictified_folders))
 
-        fake_api.sub_items = Context(CTX.FOLDER_CONTENT_LIST).toDict(workspace.get_valid_children())
+        fake_api.sub_items = Context(CTX.FOLDER_CONTENT_LIST).toDict(
+            workspace.get_valid_children(ContentApi.DISPLAYABLE_CONTENTS)
+        )
 
         dictified_workspace = Context(CTX.WORKSPACE).toDict(workspace, 'workspace')
 

tracim/tracim/lib/calendar.py

+import re
+import transaction
+
+from icalendar import Event as iCalendarEvent
+
+from tracim.lib.content import ContentApi
+from tracim.lib.exceptions import UnknownCalendarType
+from tracim.lib.exceptions import NotFound
+from tracim.lib.user import UserApi
+from tracim.lib.workspace import UnsafeWorkspaceApi
+from tracim.model import User
+from tracim.model import DBSession
+from tracim.model import new_revision
+from tracim.model.data import ActionDescription
+from tracim.model.data import Content
+from tracim.model.data import ContentType
+from tracim.model.organisational import Calendar
+from tracim.model.organisational import UserCalendar
+from tracim.model.organisational import WorkspaceCalendar
+
+CALENDAR_USER_PATH_RE = 'user\/([0-9]+).ics'
+CALENDAR_WORKSPACE_PATH_RE = 'workspace\/([0-9]+).ics'
+
+CALENDAR_TYPE_USER = UserCalendar
+CALENDAR_TYPE_WORKSPACE = WorkspaceCalendar
+
+CALENDAR_USER_URL_TEMPLATE = \
+    '{proto}://{domain}:{port}/user/{id}.ics#{slug}'
+CALENDAR_WORKSPACE_URL_TEMPLATE = \
+    '{proto}://{domain}:{port}/workspace/{id}.ics#{slug}'
+
+
+class CalendarManager(object):
+    def __init__(self, user: User):
+        self._user = user
+
+    def get_type_for_path(self, path: str) -> str:
+        """
+        Return calendar type for given path. Raise
+        tracim.lib.exceptions.UnknownCalendarType if unknown type.
+        :param path: path representation like user/42--foo.ics
+        :return: Type of calendar, can be one of CALENDAR_TYPE_USER,
+        CALENDAR_TYPE_WORKSPACE
+        """
+        if re.match(CALENDAR_USER_PATH_RE, path):
+            return CALENDAR_TYPE_USER
+
+        if re.match(CALENDAR_WORKSPACE_PATH_RE, path):
+            return CALENDAR_TYPE_WORKSPACE
+
+        raise UnknownCalendarType(
+            'No match for calendar path "{0}"'.format(path)
+        )
+
+    def get_id_for_path(self, path: str, type: str) -> int:
+        """
+        Return related calendar id for given path. Raise
+        tracim.lib.exceptions.UnknownCalendarType if unknown type.
+        :param path: path representation like user/42--foo.ics
+        :param type: Type of calendar, can be one of CALENDAR_TYPE_USER,
+        CALENDAR_TYPE_WORKSPACE
+        :return: ID of related calendar object. For UserCalendar it will be
+        user id, for WorkspaceCalendar it will be Workspace id.
+        """
+        if type == CALENDAR_TYPE_USER:
+            return re.search(CALENDAR_USER_PATH_RE, path).group(1)
+        elif type == CALENDAR_TYPE_WORKSPACE:
+            return re.search(CALENDAR_WORKSPACE_PATH_RE, path).group(1)
+        raise UnknownCalendarType('Type "{0}" is not implemented'.format(type))
+
+    def find_calendar_with_path(self, path: str) -> Calendar:
+        """
+        Return calendar for given path. Raise tracim.lib.exceptions.NotFound if
+        calendar cannot be found.
+        :param path: path representation like user/42--foo.ics
+        :return: Calendar corresponding to path
+        """
+        try:
+            type = self.get_type_for_path(path)
+            id = self.get_id_for_path(path, type)
+        except UnknownCalendarType as exc:
+            raise NotFound(str(exc))
+
+        return self.get_calendar(type, id, path)
+
+    def get_calendar(self, type: str, id: str, path: str) -> Calendar:
+        """
+        Return tracim.model.organisational.Calendar instance for given
+        parameters.
+        :param type: Type of calendar, can be one of CALENDAR_TYPE_USER,
+        CALENDAR_TYPE_WORKSPACE
+        :param id: related calendar object id
+        :param path: path representation like user/42--foo.ics
+        :return: a calendar.
+        """
+        if type == CALENDAR_TYPE_USER:
+            user = UserApi(self._user).get_one_by_id(id)
+            return UserCalendar(user, path=path)
+
+        if type == CALENDAR_TYPE_WORKSPACE:
+            workspace = UnsafeWorkspaceApi(self._user).get_one(id)
+            return WorkspaceCalendar(workspace, path=path)
+
+        raise UnknownCalendarType('Type "{0}" is not implemented'.format(type))
+
+    def add_event(
+            self,
+            calendar: Calendar,
+            event: iCalendarEvent,
+            event_name: str,
+            owner: User,
+    ) -> Content:
+        """
+        Create Content event type.
+        :param calendar: Event calendar owner
+        :param event: ICS event
+        :param event_name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :param owner: Event Owner
+        :return: Created Content
+        """
+        workspace = None
+        if isinstance(calendar, WorkspaceCalendar):
+            workspace = calendar.related_object
+        elif isinstance(calendar, UserCalendar):
+            pass
+        else:
+            raise UnknownCalendarType('Type "{0}" is not implemented'
+                                      .format(type(calendar)))
+
+        content = ContentApi(owner).create(
+            content_type=ContentType.Event,
+            workspace=workspace,
+            do_save=False
+        )
+        self.populate_content_with_event(
+            content,
+            event,
+            event_name
+        )
+        content.revision_type = ActionDescription.CREATION
+        DBSession.add(content)
+        DBSession.flush()
+        transaction.commit()
+
+        return content
+
+    def update_event(
+            self,
+            calendar: Calendar,
+            event: iCalendarEvent,
+            event_name: str,
+            current_user: User,
+    ) -> Content:
+        """
+        Update Content Event
+        :param calendar: Event calendar owner
+        :param event: ICS event
+        :param event_name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :param current_user: Current modification asking user
+        :return: Updated Content
+        """
+        workspace = None
+        if isinstance(calendar, WorkspaceCalendar):
+            workspace = calendar.related_object
+        elif isinstance(calendar, UserCalendar):
+            pass
+        else:
+            raise UnknownCalendarType('Type "{0}" is not implemented'
+                                      .format(type(calendar)))
+
+        content_api = ContentApi(
+            current_user,
+            force_show_all_types=True,
+            disable_user_workspaces_filter=True
+        )
+        content = content_api.find_one_by_unique_property(
+            property_name='name',
+            property_value=event_name,
+            workspace=workspace
+        )
+
+        with new_revision(content):
+            self.populate_content_with_event(
+                content,
+                event,
+                event_name
+            )
+            content.revision_type = ActionDescription.EDITION
+
+        DBSession.flush()
+        transaction.commit()
+
+        return content
+
+    def delete_event_with_name(self, event_name: str, current_user: User)\
+            -> Content:
+        """
+        Delete Content Event
+        :param event_name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :param current_user: Current deletion asking user
+        :return: Deleted Content
+        """
+        content_api = ContentApi(current_user, force_show_all_types=True)
+        content = content_api.find_one_by_unique_property(
+            property_name='name',
+            property_value=event_name,
+            workspace=None
+        )
+
+        with new_revision(content):
+            content_api.delete(content)
+
+        DBSession.flush()
+        transaction.commit()
+
+        return content
+
+    def populate_content_with_event(
+            self,
+            content: Content,
+            event: iCalendarEvent,
+            event_name: str,
+    ) -> Content:
+        content.label = event.get('summary')
+        content.description = event.get('description')
+        content.properties = {
+            'name': event_name,
+            'location': event.get('location'),
+            'raw': event.to_ical().decode("utf-8"),
+            'start': event.get('dtend').dt.strftime('%Y-%m-%d %H:%M:%S%z'),
+            'end': event.get('dtstart').dt.strftime('%Y-%m-%d %H:%M:%S%z'),
+        }

tracim/tracim/lib/content.py

     SEARCH_SEPARATORS = ',| '
     SEARCH_DEFAULT_RESULT_NB = 50
 
-
-    def __init__(self, current_user: User, show_archived=False, show_deleted=False, all_content_in_treeview=True):
+    DISPLAYABLE_CONTENTS = (
+        ContentType.Folder,
+        ContentType.File,
+        ContentType.Comment,
+        ContentType.Thread,
+        ContentType.Page,
+    )
+
+    def __init__(
+            self,
+            current_user: User,
+            show_archived=False,
+            show_deleted=False,
+            all_content_in_treeview=True,
+            force_show_all_types=False,
+            disable_user_workspaces_filter=False,
+    ):
         self._user = current_user
         self._user_id = current_user.user_id if current_user else None
         self._show_archived = show_archived
         self._show_deleted = show_deleted
         self._show_all_type_of_contents_in_treeview = all_content_in_treeview
+        self._force_show_all_types = force_show_all_types
+        self._disable_user_workspaces_filter = disable_user_workspaces_filter
 
     @classmethod
     def get_revision_join(cls):
     def __real_base_query(self, workspace: Workspace=None):
         result = self.get_canonical_query()
 
+        # Exclude non displayable types
+        if not self._force_show_all_types:
+            result = result.filter(Content.type.in_(self.DISPLAYABLE_CONTENTS))
+
         if workspace:
             result = result.filter(Content.workspace_id==workspace.workspace_id)
 
-        if self._user:
+        if self._user and not self._disable_user_workspaces_filter:
             user = DBSession.query(User).get(self._user_id)
             # Filter according to user workspaces
             workspace_ids = [r.workspace_id for r in user.roles \
     def __revisions_real_base_query(self, workspace: Workspace=None):
         result = DBSession.query(ContentRevisionRO)
 
+        # Exclude non displayable types
+        if not self._force_show_all_types:
+            result = result.filter(Content.type.in_(self.DISPLAYABLE_CONTENTS))
+
         if workspace:
             result = result.filter(ContentRevisionRO.workspace_id==workspace.workspace_id)
 
             if content.parent.parent:
                 return self.content_under_archived(content.parent)
         return False
+
+    def find_one_by_unique_property(
+            self,
+            property_name: str,
+            property_value: str,
+            workspace: Workspace=None,
+    ) -> Content:
+        """
+        Return Content who contains given property.
+        Raise sqlalchemy.orm.exc.MultipleResultsFound if more than one Content
+        contains this property value.
+        :param property_name: Name of property
+        :param property_value: Value of property
+        :param workspace: Workspace who contains Content
+        :return: Found Content
+        """
+        # TODO - 20160602 - Bastien: Should be JSON type query
+        # see https://www.compose.io/articles/using-json-extensions-in-\
+        # postgresql-from-python-2/
+        query = self._base_query(workspace=workspace).filter(
+            Content._properties.like(
+                '%"{property_name}": "{property_value}"%'.format(
+                    property_name=property_name,
+                    property_value=property_value,
+                )
+            )
+        )
+        return query.one()

tracim/tracim/lib/daemons.py

+import threading
+from wsgiref.simple_server import make_server
+
+import signal
+
+from radicale import Application as RadicaleApplication
+from radicale import HTTPServer as RadicaleHTTPServer
+from radicale import HTTPSServer as RadicaleHTTPSServer
+from radicale import RequestHandler as RadicaleRequestHandler
+from radicale import config as radicale_config
+from tg import TGApp
+
+from tracim.lib.base import logger
+from tracim.lib.exceptions import AlreadyRunningDaemon
+from tracim.lib.utils import add_signal_handler
+
+
+class DaemonsManager(object):
+    def __init__(self):
+        self._running_daemons = {}
+        add_signal_handler(signal.SIGTERM, self.stop_all)
+        add_signal_handler(signal.SIGINT, self.stop_all)
+
+    def run(self, name: str, daemon_class: object, **kwargs) -> None:
+        """
+        Start a daemon with given daemon class.
+        :param name: Name of runned daemon. It's not possible to start two
+        daemon with same name. In the opposite case, raise
+        tracim.lib.exceptions.AlreadyRunningDaemon
+        :param daemon_class: Daemon class to use for daemon instance.
+        :param kwargs: Other kwargs will be given to daemon class
+        instantiation.
+        """
+        if name in self._running_daemons:
+            raise AlreadyRunningDaemon(
+                'Daemon with name "{0}" already running'.format(name)
+            )
+
+        logger.info(self, 'Starting daemon with name "{0}" and class "{1}" ...'
+                          .format(name, daemon_class))
+        daemon = daemon_class(name=name, kwargs=kwargs, daemon=True)
+        daemon.start()
+        self._running_daemons[name] = daemon
+
+    def stop(self, name: str) -> None:
+        """
+        Stop daemon with his name and wait for him.
+        Where name is given name when daemon started
+        with run method.
+        :param name:
+        """
+        if name in self._running_daemons:
+            logger.info(self, 'Stopping daemon with name "{0}" ...'
+                              .format(name))
+            self._running_daemons[name].stop()
+            self._running_daemons[name].join()
+            del self._running_daemons[name]
+            logger.info(self, 'Stopping daemon with name "{0}": OK'
+                              .format(name))
+
+    def stop_all(self, *args, **kwargs) -> None:
+        """
+        Stop all started daemons and w<ait for them.
+        """
+        logger.info(self, 'Stopping all daemons')
+        for name, daemon in self._running_daemons.items():
+            logger.info(self, 'Stopping daemon "{0}" ...'.format(name))
+            daemon.stop()
+
+        for name, daemon in self._running_daemons.items():
+            daemon.join()
+            logger.info(self, 'Stopping daemon "{0}" OK'.format(name))
+
+        self._running_daemons = {}
+
+
+class Daemon(threading.Thread):
+    """
+    Thread who contains daemon. You must implement start and stop methods to
+    manage daemon life correctly.
+    """
+    def run(self):
+        raise NotImplementedError()
+
+    def stop(self):
+        raise NotImplementedError()
+
+
+class RadicaleDaemon(Daemon):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._prepare_config()
+        self._server = None
+
+    def run(self):
+        """
+        To see origin radical server start method, refer to
+        radicale.__main__.run
+        """
+        self._server = self._get_server()
+        self._server.serve_forever()
+
+    def stop(self):
+        self._server.shutdown()
+
+    def _prepare_config(self):
+        from tracim.config.app_cfg import CFG
+        cfg = CFG.get_instance()
+
+        tracim_auth = 'tracim.lib.radicale.auth'
+        tracim_rights = 'tracim.lib.radicale.rights'
+        tracim_storage = 'tracim.lib.radicale.storage'
+        fs_path = cfg.RADICALE_SERVER_FILE_SYSTEM_FOLDER
+
+        radicale_config.set('auth', 'type', 'custom')
+        radicale_config.set('auth', 'custom_handler', tracim_auth)
+
+        radicale_config.set('rights', 'type', 'custom')
+        radicale_config.set('rights', 'custom_handler', tracim_rights)
+
+        radicale_config.set('storage', 'type', 'custom')
+        radicale_config.set('storage', 'custom_handler', tracim_storage)
+        radicale_config.set('storage', 'filesystem_folder', fs_path)
+
+    def _get_server(self):
+        from tracim.config.app_cfg import CFG
+        cfg = CFG.get_instance()
+        return make_server(
+            cfg.RADICALE_SERVER_HOST,
+            cfg.RADICALE_SERVER_PORT,
+            RadicaleApplication(),
+            RadicaleHTTPSServer if cfg.RADICALE_SERVER_SSL else RadicaleHTTPServer,
+            RadicaleRequestHandler
+        )

tracim/tracim/lib/exceptions.py

+class TracimException(Exception):
+    pass
+
+
+class DaemonException(TracimException):
+    pass
+
+
+class AlreadyRunningDaemon(DaemonException):
+    pass
+
+
+class CalendarException(TracimException):
+    pass
+
+
+class UnknownCalendarType(CalendarException):
+    pass
+
+
+class NotFound(TracimException):
+    pass

tracim/tracim/lib/helpers.py

 
 import datetime
 
+import slugify
 from babel.dates import format_date, format_time
 from markupsafe import Markup
 
     if not tg.config.get('auth_instance').is_internal:
         return field_name in tg.config.get('auth_instance').managed_fields
     return False
+
+
+def slug(string):
+    return slugify.slugify(string, only_ascii=True)

tracim/tracim/lib/radicale/auth.py

+from tg import config
+
+from tracim.lib.user import UserApi
+
+
+class Auth(object):
+    """
+    This Auth class is designed to solve following problematic:
+    In tracim.lib.radicale.storage.Collection append, replace and delete
+    methods we don't know wich user is processing. So this Auth singleton
+    store last authenticated user.
+    """
+    current_user = None
+
+    @classmethod
+    def is_authenticated(cls, user, password) -> bool:
+        """
+        :param user: user email
+        :param password: user password
+        :return: True if auth success, False if not
+        """
+        email = config.get('sa_auth').authmetadata.authenticate({}, {
+            'login': user,
+            'password': password
+        })
+        if email:
+            cls.current_user = UserApi(None).get_one_by_email(email)
+
+        return bool(email)
+
+
+def is_authenticated(user: str, password: str) -> bool:
+    """
+    see tracim.lib.radicale.auth.Auth#is_authenticated
+    """
+    return Auth.is_authenticated(user, password)

tracim/tracim/lib/radicale/rights.py

+from tracim.lib.calendar import CalendarManager
+from tracim.lib.exceptions import NotFound
+from tracim.lib.user import UserApi
+from tracim.model.organisational import CALENDAR_PERMISSION_READ
+
+
+def authorized(user, collection, permission):
+    """
+    :param user: radicale given user id, should be email
+    :param collection: Calendar representation
+    :param permission: 'r' or 'w'
+    :return: True if user can access calendar with asked permission
+    """
+    if not user:
+        return False
+    current_user = UserApi(None).get_one_by_email(user)
+    manager = CalendarManager(current_user)
+    try:
+        calendar = manager.find_calendar_with_path(collection.path)
+    except NotFound:
+        return False
+
+    if permission == CALENDAR_PERMISSION_READ:
+        return calendar.user_can_read(current_user)
+    return calendar.user_can_write(current_user)

tracim/tracim/lib/radicale/storage.py

+from contextlib import contextmanager
+
+from radicale.storage.filesystem import Collection as BaseCollection
+from icalendar import Event as iCalendarEvent
+from radicale.ical import Event as RadicaleEvent
+
+from tracim.lib.calendar import CalendarManager
+from tracim.lib.radicale.auth import Auth
+from tracim.model import Content
+
+
+class Collection(BaseCollection):
+    """
+    Radicale use it's own storage system but this override create, update
+    and delete events in our database.
+    """
+
+    def __init__(self, path: str, principal: bool=False):
+        super().__init__(path, principal)
+        self._replacing = False  # See ``replacing`` context manager
+        self._manager = CalendarManager(None)
+
+    @contextmanager
+    def replacing(self):
+        """
+        Radicale filesystem storage make a ``remove`` then an ``append`` to
+        update an item. So to know what we are in update context when
+        ``append`` and ``remove`` functions are called, use this context
+        manager in ``replace`` function.
+        """
+        try:
+            self._replacing = True
+            yield self
+        finally:
+            self._replacing = False
+
+    def replace(self, name: str, text: str) -> None:
+        """
+        Override of parent replace to manage event update action. See
+        ``replacing`` context manager for more informations.
+        :param name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :param text: ICS Event content
+        """
+        with self.replacing():
+            super().replace(name, text)
+        self._update_tracim_event(name, text)
+
+    def remove(self, name: str) -> None:
+        """
+        :param name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        """
+        super().remove(name)
+        if not self._replacing:
+            self._remove_tracim_event(name)
+
+    def append(self, name: str, text: str) -> None:
+        """
+        :param name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :param text: ICS Event content
+        """
+        super().append(name, text)
+        if not self._replacing:
+            self._add_tracim_event(name, text)
+
+    def _add_tracim_event(self, name: str, text: str) -> Content:
+        """
+        Create tracim internal Event (Content) with Radicale given data.
+        :param name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :param text: ICS Event content
+        :return: Created Content
+        """
+        event = self._extract_event(name, text)
+        calendar = self._manager.find_calendar_with_path(self.path)
+        return self._manager.add_event(
+            calendar=calendar,
+            event=event,
+            event_name=name,
+            owner=Auth.current_user
+        )
+
+    def _update_tracim_event(self, name: str, text: str) -> Content:
+        """
+        Update tracim internal Event (Content) with Radicale given data.
+        :param name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :param text: ICS Event content
+        :return: Updated Content
+        """
+        event = self._extract_event(name, text)
+        calendar = self._manager.find_calendar_with_path(self.path)
+        return self._manager.update_event(
+            calendar=calendar,
+            event=event,
+            event_name=name,
+            current_user=Auth.current_user
+        )
+
+    def _remove_tracim_event(self, name: str) -> Content:
+        """
+        Delete internal tracim Event (Content) with given Event name.
+        :param name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :return: Deleted Content
+        """
+        return self._manager.delete_event_with_name(name, Auth.current_user)
+
+    def _extract_event(self, name: str, text: str) -> iCalendarEvent:
+        """
+        Return a icalendar.cal.Event construct with given Radicale ICS data.
+        :param name: Event name (ID) like
+        20160602T083511Z-18100-1001-1-71_Bastien-20160602T083516Z.ics
+        :param text: ICS Event content
+        :return: ICS Event representation
+        """
+        radicale_items = self._parse(text, (RadicaleEvent,), name)
+        for item_name in radicale_items:
+            item = radicale_items[item_name]
+            if isinstance(item, RadicaleEvent):
+                return iCalendarEvent.from_ical(item.text)

tracim/tracim/lib/user.py

     def get_one_by_email(self, email: str):
         return self._base_query().filter(User.email==email).one()
 
+    def get_one_by_id(self, id: int) -> User:
+        return self._base_query().filter(User.user_id==id).one()
+
     def update(self, user: User, name: str=None, email: str=None, do_save=True):
         if name is not None:
             user.display_name = name

tracim/tracim/lib/utils.py

 # -*- coding: utf-8 -*-
 
 import time
+import signal
 
 from tracim.lib.base import logger
 
 
 
 class SameValueError(ValueError):
-    pass
+    pass
+
+
+def replace_reset_password_templates(engines):
+    try:
+        if engines['text/html'][1] == 'resetpassword.templates.index':
+            engines['text/html'] = (
+                'mako',
+                'tracim.templates.reset_password_index',
+                engines['text/html'][2],
+                engines['text/html'][3]
+            )
+
+        if engines['text/html'][1] == 'resetpassword.templates.change_password':
+            engines['text/html'] = (
+                'mako',
+                'tracim.templates.reset_password_change_password',
+                engines['text/html'][2],
+                engines['text/html'][3]
+            )
+    except IndexError:
+        pass
+    except KeyError:
+        pass
+
+
+@property
+def NotImplemented():
+    raise NotImplementedError()
+
+
+def add_signal_handler(signal_id, handler, execute_before=True) -> None:
+    """
+    Add a callback attached to python signal.
+    :param signal_id: signal identifier (eg. signal.SIGTERM)
+    :param handler: callback to execute when signal trig
+    :param execute_before: If True, callback is executed before eventual
+    existing callback on given dignal id.
+    """
+    previous_handler = signal.getsignal(signal_id)
+
+    def call_callback(*args, **kwargs):
+        if not execute_before and callable(previous_handler):
+            previous_handler(*args, **kwargs)
+
+        handler(*args, **kwargs)
+
+        if execute_before and callable(previous_handler):
+            previous_handler(*args, **kwargs)
+
+    signal.signal(signal_id, call_callback)

tracim/tracim/lib/workspace.py

             DBSession.flush()
 
         return workspace
+
+
+class UnsafeWorkspaceApi(WorkspaceApi):
+    def _base_query(self):
+        return DBSession.query(Workspace).filter(Workspace.is_deleted==False)

tracim/tracim/model/auth.py

 import os
 from datetime import datetime
 from hashlib import sha256
+from slugify import slugify
 from sqlalchemy.ext.hybrid import hybrid_property
 from tg.i18n import lazy_ugettext as l_
 
 from sqlalchemy.types import DateTime
 from sqlalchemy.types import Boolean
 from sqlalchemy.orm import relation, relationship, synonym
-
+from tg import request
 from tracim.model import DeclarativeBase, metadata, DBSession
 
 # This is the association table for the many-to-many relationship between
             profile_id = max(group.group_id for group in self.groups)
         return Profile(profile_id)
 
+    @property
+    def calendar_url(self) -> str:
+        # TODO - 20160531 - Bastien: Cyclic import if import in top of file
+        from tracim.config.app_cfg import CFG
+        from tracim.lib.calendar import CALENDAR_USER_URL_TEMPLATE
+        cfg = CFG.get_instance()
+        return CALENDAR_USER_URL_TEMPLATE.format(
+            proto='https' if cfg.RADICALE_CLIENT_SSL else 'http',
+            domain=cfg.RADICALE_CLIENT_HOST or request.domain,
+            port=cfg.RADICALE_CLIENT_PORT,
+            id=self.user_id,
+            slug=slugify(self.get_display_name(
+                remove_email_part=True
+            ), only_ascii=True)
+        )
+
     @classmethod
     def by_email_address(cls, email):
         """Return the user object whose email address is ``email``."""
         hash.update((password + self.password[:64]).encode('utf-8'))
         return self.password[64:] == hash.hexdigest()
 
-    def get_display_name(self):
+    def get_display_name(self, remove_email_part=False):
+        """
+        :param remove_email_part: If True and display name based on email,
+         remove @xxx.xxx part of email in returned value
+        :return: display name based on user name or email.
+        """
         if self.display_name!=None and self.display_name!='':
             return self.display_name
         else:
+            if remove_email_part:
+                at_pos = self.email.index('@')
+                return self.email[0:at_pos]
             return self.email
 
     def get_role(self, workspace: 'Workspace') -> int:

tracim/tracim/model/data.py

 import tg
 from babel.dates import format_timedelta
 from bs4 import BeautifulSoup
+from slugify import slugify
 from sqlalchemy import Column, inspect, Index
 from sqlalchemy import ForeignKey
 from sqlalchemy import Sequence
-from sqlalchemy import func
 from sqlalchemy.ext.associationproxy import association_proxy
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import backref
 
     label   = Column(Unicode(1024), unique=False, nullable=False, default='')
     description = Column(Text(), unique=False, nullable=False, default='')
+    calendar_enabled = Column(Boolean, unique=False, nullable=False, default=False)
 
     #  Default value datetime.utcnow, see: http://stackoverflow.com/a/13370382/801924 (or http://pastebin.com/VLyWktUn)
     created = Column(DateTime, unique=False, nullable=False, default=datetime.utcnow)
         # Return a list of unique revisions parent content
         return list(set([revision.node for revision in self.revisions]))
 
+    @property
+    def calendar_url(self) -> str:
+        # TODO - 20160531 - Bastien: Cyclic import if import in top of file
+        from tracim.config.app_cfg import CFG
+        from tracim.lib.calendar import CALENDAR_WORKSPACE_URL_TEMPLATE
+        cfg = CFG.get_instance()
+        return CALENDAR_WORKSPACE_URL_TEMPLATE.format(
+            proto='https' if cfg.RADICALE_CLIENT_SSL else 'http',
+            domain=cfg.RADICALE_CLIENT_HOST or tg.request.domain,
+            port=cfg.RADICALE_CLIENT_PORT,
+            id=self.workspace_id,
+            slug=slugify(self.label)
+        )
+
     def get_user_role(self, user: User) -> int:
         for role in user.roles:
             if role.workspace.workspace_id==self.workspace_id:
     Comment = 'comment'
     Thread = 'thread'
     Page = 'page'
+    Event = 'event'
 
     # Fake types, used for breadcrumb only
     FAKE_Dashboard = 'dashboard'
         'page': 'fa fa-file-text-o',
         'thread': 'fa fa-comments-o',
         'comment': 'fa fa-comment-o',
+        'event': 'fa fa-calendar-o',
     }
 
     _CSS_ICONS = {
         'file': 'fa fa-paperclip',
         'page': 'fa fa-file-text-o',
         'thread': 'fa fa-comments-o',
-        'comment': 'fa fa-comment-o'
+        'comment': 'fa fa-comment-o',
+        'event': 'fa fa-calendar-o',
     }
 
     _CSS_COLORS = {
         'file': 't-file-color',
         'page': 't-page-color',
         'thread': 't-thread-color',
-        'comment': 't-thread-color'
+        'comment': 't-thread-color',
+        'event': 't-event-color',
     }
 
     _ORDER_WEIGHT = {
         'thread': 2,
         'file': 3,
         'comment': 4,
+        'event': 5,
     }
 
     _LABEL = {
         'page': l_('page'),
         'thread': l_('thread'),
         'comment': l_('comment'),
+        'event': l_('event'),
     }
 
     _DELETE_LABEL = {
         'page': l_('Delete this page'),
         'thread': l_('Delete this thread'),
         'comment': l_('Delete this comment'),
+        'event': l_('Delete this event'),
     }
 
     @classmethod
 
     @classmethod
     def allowed_types(cls):
-        return [cls.Folder, cls.File, cls.Comment, cls.Thread, cls.Page]
+        return [cls.Folder, cls.File, cls.Comment, cls.Thread, cls.Page,
+                cls.Event]
 
     @classmethod
     def allowed_types_for_folding(cls):
                 return False
             if 'threads' not in properties['allowed_content']:
                 return False
+            return True
 
+        if item.type == ContentType.Event:
+            properties = item.properties
+            if 'name' not in properties.keys():
+                return False
+            if 'raw' not in properties.keys():
+                return False
+            if 'start' not in properties.keys():
+                return False
+            if 'end' not in properties.keys():
+                return False
             return True
 
         raise NotImplementedError

tracim/tracim/model/organisational.py

+from tracim.model import User
+from tracim.model.data import UserRoleInWorkspace
+
+
+CALENDAR_PERMISSION_READ = 'r'
+CALENDAR_PERMISSION_WRITE = 'w'
+
+
+class Calendar(object):
+    def __init__(self, related_object, path):
+        self._related_object = related_object
+        self._path = path
+
+    @property
+    def related_object(self):
+        return self._related_object
+
+    def user_can_read(self, user: User) -> bool:
+        raise NotImplementedError()
+
+    def user_can_write(self, user: User) -> bool:
+        raise NotImplementedError()
+
+
+class UserCalendar(Calendar):
+    def user_can_write(self, user: User) -> bool:
+        return self._related_object.user_id == user.user_id
+
+    def user_can_read(self, user: User) -> bool:
+        return self._related_object.user_id == user.user_id
+
+
+class WorkspaceCalendar(Calendar):
+    _workspace_rights = {
+        UserRoleInWorkspace.NOT_APPLICABLE:
+            [],
+        UserRoleInWorkspace.READER:
+            [CALENDAR_PERMISSION_READ],
+        UserRoleInWorkspace.CONTRIBUTOR:
+            [CALENDAR_PERMISSION_READ, CALENDAR_PERMISSION_WRITE],
+        UserRoleInWorkspace.CONTENT_MANAGER:
+            [CALENDAR_PERMISSION_READ, CALENDAR_PERMISSION_WRITE],
+        UserRoleInWorkspace.WORKSPACE_MANAGER:
+            [CALENDAR_PERMISSION_READ, CALENDAR_PERMISSION_WRITE],
+    }
+
+    def user_can_write(self, user: User) -> bool:
+        role = user.get_role(self._related_object)
+        return CALENDAR_PERMISSION_WRITE in self._workspace_rights[role]
+
+    def user_can_read(self, user: User) -> bool:
+        role = user.get_role(self._related_object)
+        return CALENDAR_PERMISSION_READ in self._workspace_rights[role]

tracim/tracim/model/serializers.py

     result['roles'] = context.toDict(user.roles)
     result['enabled'] = user.is_active
     result['profile'] = user.profile
+    result['calendar_url'] = user.calendar_url
 
     return result
 
     result['members'] = context.toDict(workspace.roles)
     result['member_nb'] = len(workspace.roles)
     result['allowed_content_types'] = context.toDict(workspace.get_allowed_content_types())
+    result['calendar_enabled'] = workspace.calendar_enabled
+    result['calendar_url'] = workspace.calendar_url
 
     return result
 

tracim/tracim/templates/admin/workspace_getall.mak

                                         <textarea name="description" class="form-control" id="workspaceDescription" placeholder="${_('You may add a description of the workspace')}"></textarea>
                                     </div>
                                     <div class="form-group">
+                                        <label for="workspaceCalendarEnabled">${_('Calendar enabled')}</label>
+                                        <input id="workspaceCalendarEnabled" name="calendar_enabled" class="form-control" type="checkbox" checked />
+                                    </div>
+                                    <div class="form-group">
                                         <p class="form-control-static">${_('<u>Note</u>: members will be added during next step.')|n}</p>
                                     </div>
                                         

tracim/tracim/templates/user_workspace_forms.mak

                 % endif
                 <input name="email" type="text" class="form-control" id="email" placeholder="${_('Name')}" value="${user.email}" ${'readonly="readonly"' if h.is_user_externalized_field('email') else '' | n}>
             </div>
+            <div class="form-group">
+                <label for="calendar">${_('Personal calendar')}</label>
+                <span class="info readonly">${_('This calendar URL will work with CalDav compatibles clients')}</span>
+                <input id="calendar" type="text" class="form-control"  disabled="disabled" value="${user.calendar_url}" />
+            </div>
         </div>
         <div class="modal-footer">
             <span class="pull-right t-modal-form-submit-button">

tracim/tracim/templates/workspace/edit.mak

             <label for="workspaceDescription">${_('Description')}</label>
             <textarea name="description" class="form-control" id="workspaceDescription" placeholder="${_('You may add a description of the workspace')}">${result.workspace.description}</textarea>
         </div>
+        <div class="form-group">
+            <label for="workspaceCalendarEnabled">${_('Calendar enabled')}</label>
+            <input id="workspaceCalendarEnabled" name="calendar_enabled" class="form-control" type="checkbox" ${'checked' if result.workspace.calendar_enabled else ''} />
+        </div>
+        <div class="form-group calendar-url">
+            <label for="workspaceCalendarUrl">${_('Calendar URL')}</label>
+            <input id="workspaceCalendarUrl" type="text" class="form-control"  disabled="disabled" value="${result.workspace.calendar_url}" />
+        </div>
     </div>
     <div class="modal-footer">
         <span class="pull-right" style="margin-top: 0.5em;">

tracim/tracim/templates/workspace/getone.mak

         % else:
             <p class="t-less-visible">${_('No description available')}</p>
         % endif
+        % if result.workspace.calendar_enabled:
+            <p>
+                ${_('Calendar URL')}: ${result.workspace.calendar_url}
+            </p>
+        % endif
 
         <% member_nb = len(result.workspace.members) %>
         % if member_nb<=0:

tracim/tracim/tests/library/test_serializers.py

         eq_(True, res['children'])
 
         for curtype in ContentType.all():
-            if curtype not in (ContentType.Folder, ContentType.Comment):
+            if curtype not in (
+                    ContentType.Folder,
+                    ContentType.Comment,
+                    ContentType.Event
+            ):
                 item = Content()
                 item.type = curtype
                 item.label = 'item'