Closes #87: Ensure Radicale create calendars for new user/workspaces

tracim/tracim/command/user.py

 from sqlalchemy.exc import IntegrityError
 from tg import config
 
-from tracim.command import AppContextCommand, Extender
+from tracim.command import AppContextCommand
+from tracim.command import Extender
 from tracim.lib.auth.ldap import LDAPAuth
+from tracim.lib.daemons import DaemonsManager
+from tracim.lib.daemons import RadicaleDaemon
 from tracim.lib.email import get_email_manager
-from tracim.lib.exception import AlreadyExistError, CommandAbortedError
+from tracim.lib.exception import AlreadyExistError
+from tracim.lib.exception import CommandAbortedError
 from tracim.lib.group import GroupApi
 from tracim.lib.user import UserApi
-from tracim.model import DBSession, User
+from tracim.model import DBSession
+from tracim.model import User
 
 
 class UserCommand(AppContextCommand):
             user = User(email=login, password=password, **kwargs)
             self._session.add(user)
             self._session.flush()
+
+            # We need to enable radicale if it not already done
+            daemons = DaemonsManager()
+            daemons.run('radicale', RadicaleDaemon)
+
+            user_api = UserApi(user)
+            user_api.execute_created_user_actions(user)
         except IntegrityError:
             self._session.rollback()
             raise AlreadyExistError()

tracim/tracim/controllers/admin/user.py

             is_tracim_manager = False
             is_tracim_admin = False
 
-
         api = UserApi(current_user)
 
         if api.user_with_email_exists(email):
             email_manager = get_email_manager()
             email_manager.notify_created_account(user, password=password)
 
+        api.execute_created_user_actions(user)
         tg.flash(_('User {} created.').format(user.get_display_name()), CST.STATUS_OK)
         tg.redirect(self.url())
 
-
     @tg.expose('tracim.templates.admin.user_getone')
     def get_one(self, user_id):
         current_user = tmpl_context.current_user

tracim/tracim/controllers/admin/workspace.py

 from tg.i18n import ugettext as _
 
 from tracim.controllers import TIMRestController
-from tracim.controllers import TIMRestPathContextSetup
 
 
 from tracim.lib import CST
 from tracim.lib.helpers import on_off_to_boolean
 from tracim.lib.user import UserApi
 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
-from tracim.model.data import Content
-from tracim.model.data import ContentType
-from tracim.model.data import Workspace
 from tracim.model.data import UserRoleInWorkspace
 
 from tracim.model.serializers import Context, CTX, DictLikeClass
 
-from tracim.controllers.content import UserWorkspaceFolderRestController
-
-
-
 
 class RoleInWorkspaceRestController(TIMRestController, BaseController):
 
         workspace_api_controller = WorkspaceApi(user)
         calendar_enabled = on_off_to_boolean(calendar_enabled)
 
-        workspace = workspace_api_controller.create_workspace(name, description)
-        workspace.calendar_enabled = calendar_enabled
-        DBSession.flush()
+        workspace = workspace_api_controller.create_workspace(
+            name,
+            description,
+            calendar_enabled=calendar_enabled,
+            save_now=True,
+        )
 
         tg.flash(_('{} workspace created.').format(workspace.label), CST.STATUS_OK)
         tg.redirect(self.url())
         workspace.calendar_enabled = calendar_enabled
         workspace_api_controller.save(workspace)
 
+        if calendar_enabled:
+            workspace_id = workspace.workspace_id
+            workspace_api_controller.ensure_calendar_exist(workspace)
+            # We must reload user because user_api.created_user_actions
+            # commit transaction
+            workspace = workspace_api_controller.get_one_by_id(workspace_id)
+
         tg.flash(_('{} workspace updated.').format(workspace.label), CST.STATUS_OK)
         tg.redirect(self.url(workspace.workspace_id))
         return

tracim/tracim/controllers/user.py

 # -*- coding: utf-8 -*-
 from webob.exc import HTTPForbidden
-
-from tracim import model  as pm
-
-from sprox.tablebase import TableBase
-from sprox.formbase import EditableForm, AddRecordForm
-from sprox.fillerbase import TableFiller, EditFormFiller
-from tw2 import forms as tw2f
 import tg
 from tg import tmpl_context
-from tg.i18n import ugettext as _, lazy_ugettext as l_
-
-from sprox.widgets import PropertyMultipleSelectField
-from sprox._compat import unicode_text
-
-from formencode import Schema
-from formencode.validators import FieldsMatch
+from tg.i18n import ugettext as _
 
 from tracim.controllers import TIMRestController
-from tracim.lib import helpers as h
 from tracim.lib.user import UserApi
-from tracim.lib.group import GroupApi
-from tracim.lib.user import UserStaticApi
-from tracim.lib.userworkspace import RoleApi
 from tracim.lib.workspace import WorkspaceApi
-
-from tracim.model import DBSession
-from tracim.model.auth import Group, User
-from tracim.model.serializers import Context, CTX, DictLikeClass
+from tracim.model.serializers import Context
+from tracim.model.serializers import CTX
+from tracim.model.serializers import DictLikeClass
+from tracim import model as pm
 
 
 class UserWorkspaceRestController(TIMRestController):

tracim/tracim/lib/calendar.py

+import caldav
 import os
 
 import re
 
 from icalendar import Event as iCalendarEvent
 from sqlalchemy.orm.exc import NoResultFound
+from tg import tmpl_context
 from tg.i18n import ugettext as _
 
 from tracim.lib.content import ContentApi
         :return: True if given collection path is an discover path
         """
         return path in ('user', 'workspace')
+
+    def create_then_remove_fake_event(
+            self,
+            calendar_class,
+            related_object_id,
+    ) -> None:
+        radicale_base_url = self.get_base_url()
+        client = caldav.DAVClient(
+            radicale_base_url,
+            username=self._user.email,
+            password=self._user.auth_token,
+        )
+        if calendar_class == WorkspaceCalendar:
+            calendar_url = self.get_workspace_calendar_url(related_object_id)
+        elif calendar_class == UserCalendar:
+            calendar_url = self.get_user_calendar_url(related_object_id)
+        else:
+            raise Exception('Unknown calendar type {0}'.format(calendar_class))
+
+        user_calendar = caldav.Calendar(
+            parent=client,
+            client=client,
+            url=calendar_url
+        )
+
+        event_ics = """BEGIN:VCALENDAR
+VERSION:2.0
+PRODID:-//Example Corp.//CalDAV Client//EN
+BEGIN:VEVENT
+UID:{uid}
+DTSTAMP:20100510T182145Z
+DTSTART:20100512T170000Z
+DTEND:20100512T180000Z
+SUMMARY:This is an event
+LOCATION:Here
+END:VEVENT
+END:VCALENDAR
+""".format(uid='{0}FAKEEVENT'.format(related_object_id))
+        event = user_calendar.add_event(event_ics)
+        event.delete()
+

tracim/tracim/lib/content.py

         if workspace:
             result = result.filter(Content.workspace_id==workspace.workspace_id)
 
-        if self._user and not self._disable_user_workspaces_filter:
+        if self._user and workspace 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 \

tracim/tracim/lib/radicale/auth.py

 from tg import config
 
 from tracim.lib.user import UserApi
+from tracim.model import DBSession
 
 
 class Auth(object):
     """
     see tracim.lib.radicale.auth.Auth#is_authenticated
     """
+    DBSession.expire_all()
     return Auth.is_authenticated(user, password)

tracim/tracim/lib/user.py

 # -*- coding: utf-8 -*-
-
-__author__ = 'damien'
+import transaction
 
 import tg
 
 
 from tracim.model import auth as pbma
 from tracim.model import DBSession
-import tracim.model.data as pmd
+
+__author__ = 'damien'
+
 
 class UserApi(object):
 
     def save(self, user: User):
         DBSession.flush()
 
+    def execute_created_user_actions(self, created_user: User) -> None:
+        """
+        Execute actions when user just been created
+        :return:
+        """
+        # NOTE: Cyclic import
+        from tracim.lib.calendar import CalendarManager
+        from tracim.model.organisational import UserCalendar
+
+        created_user.ensure_auth_token()
+
+        # Ensure database is up-to-date
+        DBSession.flush()
+        transaction.commit()
+
+        calendar_manager = CalendarManager(created_user)
+        calendar_manager.create_then_remove_fake_event(
+            calendar_class=UserCalendar,
+            related_object_id=created_user.user_id,
+        )
+
 
 class UserStaticApi(object):
 

tracim/tracim/lib/workspace.py

 # -*- coding: utf-8 -*-
-
-__author__ = 'damien'
-
-import os
-from datetime import datetime
-from hashlib import sha256
-
-from sqlalchemy import Table, ForeignKey, Column
-from sqlalchemy.types import Unicode, Integer, DateTime, Text
-from sqlalchemy.orm import relation, synonym, contains_eager
-from sqlalchemy.orm import joinedload_all
-import sqlalchemy.orm as sqlao
-import sqlalchemy as sqla
-
-import tg
+import transaction
 
 from tracim.lib.userworkspace import RoleApi
 from tracim.model.auth import Group
 from tracim.model.auth import User
 from tracim.model.data import Workspace
 from tracim.model.data import UserRoleInWorkspace
-
-from tracim.model import auth as pbma
 from tracim.model import DBSession
 
+__author__ = 'damien'
+
 
 class WorkspaceApi(object):
 
             filter(UserRoleInWorkspace.user_id==self._user.user_id).\
             filter(Workspace.is_deleted==False)
 
-    def create_workspace(self, label: str, description: str='', save_now:bool=False) -> Workspace:
+    def create_workspace(
+            self,
+            label: str,
+            description: str='',
+            calendar_enabled: bool=False,
+            save_now: bool=False,
+    ) -> Workspace:
         workspace = Workspace()
         workspace.label = label
         workspace.description = description
+        workspace.calendar_enabled = calendar_enabled
 
         # By default, we force the current user to be the workspace manager
         # And to receive email notifications
         if save_now:
             DBSession.flush()
 
+        if calendar_enabled:
+            self.execute_created_workspace_actions(workspace)
+
         return workspace
 
     def get_one(self, id):
 
         return workspace
 
+    def execute_created_workspace_actions(self, workspace: Workspace) -> None:
+        self.ensure_calendar_exist(workspace)
+
+    def ensure_calendar_exist(self, workspace: Workspace) -> None:
+        # Note: Cyclic imports
+        from tracim.lib.calendar import CalendarManager
+        from tracim.model.organisational import WorkspaceCalendar
+
+        if workspace.calendar_enabled:
+            self._user.ensure_auth_token()
+
+            # Ensure database is up-to-date
+            DBSession.flush()
+            transaction.commit()
+
+            calendar_manager = CalendarManager(self._user)
+            calendar_manager.create_then_remove_fake_event(
+                calendar_class=WorkspaceCalendar,
+                related_object_id=workspace.workspace_id,
+            )
+
 
 class UnsafeWorkspaceApi(WorkspaceApi):
     def _base_query(self):

tracim/tracim/model/__init__.py

 
 # Global session manager: DBSession() returns the Thread-local
 # session object appropriate for the current web request.
-maker = sessionmaker(autoflush=True, autocommit=False,
-                     extension=ZopeTransactionExtension())
+maker = sessionmaker(
+    autoflush=True,
+    autocommit=False,
+    extension=ZopeTransactionExtension(),
+    expire_on_commit=False,
+)
 DBSession = scoped_session(maker)
 
 # Base class for all of our model classes: By default, the data model is

tracim/tracim/tests/__init__.py

         return thread
 
 
-class TestCalendar(TestController):
+class TestCalendar(TracimTestController):
     fixtures = [BaseFixture, TestFixture]
     application_under_test = 'radicale'
 

tracim/tracim/tests/functional/test_calendar.py

+import os
 import time
 
 import caldav
 import transaction
 from caldav.lib.error import AuthorizationError
+from collections import OrderedDict
 from nose.tools import eq_
 from nose.tools import ok_
 from nose.tools import raises
 import requests
 from requests.exceptions import ConnectionError
 from sqlalchemy.orm.exc import NoResultFound
+from tg import config
 
 from tracim.config.app_cfg import daemons
 from tracim.lib.calendar import CalendarManager
 from tracim.tests import not_raises
 from tracim.model.auth import User
 from tracim.model.data import Content
+from tracim.model.data import Workspace
 
 
 class TestCalendar(BaseTestCalendar):
         eq_(event.properties['location'], 'Here')
         eq_(event.properties['start'], '2010-05-12 18:00:00+0000')
         eq_(event.properties['end'], '2010-05-12 17:00:00+0000')
+
+    def test_created_user_radicale_calendar(self):
+        self._connect_user(
+            'admin@admin.admin',
+            'admin@admin.admin',
+        )
+
+        user_count = DBSession.query(User)\
+            .filter(User.email == 'an-other-email@test.local').count()
+        eq_(0, user_count, 'User should not exist yet')
+
+        radicale_users_folder = '{0}/user'\
+            .format(config.get('radicale.server.filesystem.folder'))
+        eq_(
+            False,
+            os.path.isdir(radicale_users_folder),
+            'Radicale users folder should not exist yet',
+        )
+
+        # Create a new user, his calendar should be created to
+        try_post_user = self.app.post(
+            '/admin/users',
+            OrderedDict([
+                ('name', 'TEST'),
+                ('email', 'an-other-email@test.local'),
+                ('password', 'an-other-email@test.local'),
+                ('is_tracim_manager', 'off'),
+                ('is_tracim_admin', 'off'),
+                ('send_email', 'off'),
+            ])
+        )
+
+        eq_(try_post_user.status_code, 302,
+            "Code should be 302, but is %d" % try_post_user.status_code)
+
+        users_calendars = len([
+            name for name in os.listdir(radicale_users_folder)
+            if name.endswith('.ics')
+        ])
+
+        user = DBSession.query(User) \
+            .filter(User.email == 'an-other-email@test.local').one()
+
+        eq_(1, users_calendars, 'Radicale user path should list 1 calendar')
+        user_calendar = '{0}/{1}.ics'.format(
+            radicale_users_folder,
+            user.user_id,
+        )
+        user_calendar_exist = os.path.isfile(user_calendar)
+        eq_(True, user_calendar_exist, 'User calendar should be created')
+
+    def test_created_workspace_radicale_calendar(self):
+        self._connect_user(
+            'admin@admin.admin',
+            'admin@admin.admin',
+        )
+
+        workspaces_count = DBSession.query(Workspace)\
+            .filter(Workspace.label == 'WTESTCAL').count()
+        eq_(0, workspaces_count, 'Workspace should not exist yet !')
+
+        radicale_workspaces_folder = '{0}/workspace'\
+            .format(config.get('radicale.server.filesystem.folder'))
+        eq_(
+            False,
+            os.path.isdir(radicale_workspaces_folder),
+            'Radicale workskpaces folder should not exist yet',
+        )
+
+        # Create a new workspace, his calendar should be created to
+        try_post_workspace = self.app.post(
+            '/admin/workspaces',
+            OrderedDict([
+                ('name', 'WTESTCAL'),
+                ('description', 'WTESTCALDESCR'),
+                ('calendar_enabled', 'on'),
+            ])
+        )
+
+        eq_(try_post_workspace.status_code, 302,
+            "Code should be 302, but is %d" % try_post_workspace.status_code)
+
+        workspaces_calendars = len([
+            name for name in os.listdir(radicale_workspaces_folder)
+            if name.endswith('.ics')
+        ])
+
+        workspace = DBSession.query(Workspace) \
+            .filter(Workspace.label == 'WTESTCAL').one()
+
+        eq_(
+            1,
+            workspaces_calendars,
+            'Radicale workspace path should list 1 calendar',
+        )
+        workspace_calendar = '{0}/{1}.ics'.format(
+            radicale_workspaces_folder,
+            workspace.workspace_id,
+        )
+        workspace_calendar_exist = os.path.isfile(workspace_calendar)
+        eq_(
+            True,
+            workspace_calendar_exist,
+            'Workspace calendar should be created',
+        )