Merge branch 'master' of https://github.com/tracim/tracim

.gitignore

 wsgidav.conf
 # Temporary files
 *~
+*.sqlite

API.md

+# API documentation
+
+## Authentication
+
+APi not actually implement authentication method. You must use cookies set by
+frontend login.
+
+## Workspaces
+
+### List
+
+    GET /api/workspaces/
+
+Return list of workspaces acessible by current connected user.
+
+#### Response
+
+    {
+       "value_list":[
+          {
+             "id":30,
+             "label":"my calendar",
+             "description":"blablabla",
+             "has_calendar":"true"
+          },
+          {
+             "id":230,
+             "label":"my calendar other",
+             "description":"blablabla 230",
+             "has_calendar":"true"
+          }
+       ]
+    }
+
+## Users
+
+### List
+
+    GET /api/users/
+
+Return list of all users of the tracim instance
+
+#### Response
+
+    {
+      "value_list": [
+        {
+          "id": 0,
+          "name": "Georges Abitbol",
+          "email": "g.abitbol@laclasse.com",
+          "canCreateWs": true,
+          "isAdmin": true,
+          "config": {
+            "sendEmailNotif": true
+          }
+        }, {
+          "id": 145,
+          "name": "Peter",
+          "email": "peter@laclasse.com",
+          "canCreateWs": false,
+          "isAdmin": false,
+          "config": {
+            "sendEmailNotif": false
+        }
+      ]
+    }
+
+## Users_Workspace (Role)
+
+### List
+
+    GET /api/users_workspace/
+
+Return list of all roles of all workspaces the connected user has access to
+
+#### Response
+
+    {
+      "value_list": [
+        {
+          "userId": 0,
+          "workspaceId": 1,
+          "roleId": 8,
+          "subscribedNotif": true
+        }, {
+          "userId": 2,
+          "workspaceId": 2,
+          "roleId": 2,
+          "subscribedNotif": true
+        }, {
+          "userId": 5,
+          "workspaceId": 3,
+          "roleId": 4,
+          "subscribedNotif": false
+        }
+      ]
+    }
+
+## Timezone
+
+### List
+
+    GET /api/timezone/
+
+Return list of all timezone available when creating a user
+
+#### Response
+
+    {
+      "value_list": [
+        "Africa/Abidjan",
+        "Africa/Accra",
+        "Africa/Addis_Ababa",
+        "Africa/Algiers",
+        "Africa/Asmara",
+        ...
+      ]
+    }
+
+## Calendars
+
+### List
+
+    GET /api/calendars/
+
+Return list of calendars accessible by current connected user.
+
+#### Response
+
+    {
+       "value_list":[
+          {
+             "id":30,
+             "label":"my calendar",
+             "description":"blablabla 230",
+             "type": "workspace"
+          },
+          {
+             "id":230,
+             "label":"my other calendar",
+             "description":"blablabla 230",
+             "type": "workspace"
+          },
+          {
+             "id":20,
+             "label":"Name of the user",
+             "description":"my personnal calendar",
+             "type": "user"
+          }
+       ]
+    }

README.md

 The main parameters for notifications are the following ones:
 
     email.notification.activated = true
-    email.notification.from = Tracim Notification <tracim@tmycompany.com>
+    email.notification.from.email = noreply@trac.im
+    email.notification.from.default_label = Tracim Notification
     email.notification.smtp.server = smtp.mycompany.com
     email.notification.smtp.port = 25
     email.notification.smtp.user = username

install/requirements.txt

 sprox==0.9.4
 stevedore==1.1.0
 tg.devtools==2.3.7
-tgapp-resetpassword==0.1.8
+git+https://github.com/algoo/tgapp-resetpassword.git
 tgext.admin==0.6.4
-tgext.asyncjob==0.3.1
 tgext.crud==0.7.3
-tgext.pluggable==0.5.5
+tgext.pluggable==0.6.2
 transaction==1.4.4
 tw2.core==2.2.2
 tw2.forms==2.2.2.1
 -e git+https://github.com/algoo/wsgidav.git@py3#egg=wsgidav
 zope.interface==4.1.3
 zope.sqlalchemy==0.7.6
-
+PyYAML
+redis==2.10.5
+typing==3.5.3.0
+rq==0.7.1
+click==6.7

tracim/development.ini.base

 website.server_name = 127.0.0.1
     
 email.notification.activated = False
-email.notification.from = Tracim Notification <noreply@trac.im>
+email.notification.from.email = noreply@trac.im
+email.notification.from.default_label = Tracim Notifications
 email.notification.content_update.template.html = ./tracim/templates/mail/content_update_body_html.mak
 email.notification.content_update.template.text = ./tracim/templates/mail/content_update_body_text.mak
 email.notification.created_account.template.html = ./tracim/templates/mail/created_account_body_html.mak
 email.notification.smtp.user = your_smtp_user
 email.notification.smtp.password = your_smtp_password
 
+## Email sending configuration
+# processing_mode may be sync or async,
+# with async, please configure redis below
+email.processing_mode = sync
+# email.async.redis.host = localhost
+# email.async.redis.port = 6379
+# email.async.redis.db = 0
+
 ## Radical (CalDav server) configuration
 # radicale.server.host = 0.0.0.0
 # radicale.server.port = 5232
 # radicale.server.realm_message = Tracim Calendar - Password Required
 ## url can be extended like http://127.0.0.1:5232/calendar
 ## in this case, you have to create your own proxy behind this url.
-# radicale.client.base_url = http://127.0.0.1:5232
+## and update following parameters
+# radicale.client.base_url.host = http://127.0.0.1:5232
+# radicale.client.base_url.prefix = /
 
 ## WSGIDAV
 wsgidav.config_path = wsgidav.conf
+## url can be extended like 127.0.0.1/webdav
+## in this case, you have to create your own proxy behind this url.
+## Do not set http:// prefix.
+# wsgidav.client.base_url = 127.0.0.1:<WSGIDAV_PORT>
 
 #####
 #

tracim/migration/env.py

             context.run_migrations()
     finally:
         connection.close()
+        engine.dispose()
 
 if context.is_offline_mode():
     run_migrations_offline()

tracim/migration/versions/15305f71bfda_fill_content_file_extension_column.py

+"""fill content file_extension column
+
+Revision ID: 15305f71bfda
+Revises: e31ddc009b37
+Create Date: 2016-11-25 10:50:01.874820
+
+"""
+
+# revision identifiers, used by Alembic.
+import os
+
+revision = '15305f71bfda'
+down_revision = 'e31ddc009b37'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+content_revision_helper = sa.Table(
+    'content_revisions',
+    sa.MetaData(),
+    sa.Column('revision_id', sa.Integer, primary_key=True),
+    sa.Column('content_id', sa.ForeignKey(u'content.id'), nullable=False),
+    sa.Column('owner_id', sa.ForeignKey(u'users.user_id'), index=True),
+    sa.Column('label', sa.String(1024), nullable=False),
+    sa.Column('description', sa.Text, nullable=False),
+    sa.Column('file_name', sa.String(255), nullable=False),
+    sa.Column('file_extension', sa.String(255), nullable=False),
+    sa.Column('file_mimetype', sa.String(255), nullable=False),
+    sa.Column('file_content', sa.LargeBinary),
+    sa.Column('properties', sa.Text, nullable=False),
+    sa.Column('type', sa.String(32), nullable=False),
+    sa.Column('status', sa.String(32), nullable=False),
+    sa.Column('created', sa.DateTime, nullable=False),
+    sa.Column('updated', sa.DateTime, nullable=False),
+    sa.Column('is_deleted', sa.Boolean, nullable=False),
+    sa.Column('is_archived', sa.Boolean, nullable=False),
+    sa.Column('is_temporary', sa.Boolean, nullable=False),
+    sa.Column('revision_type', sa.String(32), nullable=False),
+    sa.Column('workspace_id', sa.ForeignKey(u'workspaces.workspace_id')),
+    sa.Column('parent_id', sa.ForeignKey(u'content.id'), index=True),
+)
+
+
+def upgrade():
+    connection = op.get_bind()
+
+    for content_revision in connection.execute(
+            content_revision_helper.select()
+    ):
+        # On work with FILE
+        if content_revision.type == 'file':
+            file_name, file_extension = \
+                os.path.splitext(content_revision.file_name)
+
+            # Don't touch label if already set
+            if content_revision.label:
+                new_label = content_revision.label
+            # Label will be file name without extension
+            else:
+                new_label = file_name
+
+            # Update record
+            connection.execute(
+                content_revision_helper.update()
+                .where(
+                    content_revision_helper.c.revision_id ==
+                    content_revision.revision_id
+                ).values(
+                    label=new_label,
+                    file_extension=file_extension,
+                )
+            )
+
+
+def downgrade():
+    pass

tracim/migration/versions/2cd20ff3d23a_user_timezone.py

+"""user_timezone
+
+Revision ID: 2cd20ff3d23a
+Revises: b4b8d57b54e5
+Create Date: 2016-11-08 11:32:00.903232
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '2cd20ff3d23a'
+down_revision = 'b4b8d57b54e5'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('users', sa.Column('timezone', sa.Unicode(length=255), server_default='', nullable=False))
+    ### end Alembic commands ###
+
+
+def downgrade():
+    ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('users', 'timezone')
+    ### end Alembic commands ###

tracim/migration/versions/59fc98c3c965_delete_content_file_name_column.py

+"""delete content file name column
+
+Revision ID: 59fc98c3c965
+Revises: 15305f71bfda
+Create Date: 2016-11-25 14:55:22.176175
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '59fc98c3c965'
+down_revision = '15305f71bfda'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    op.drop_column('content_revisions', 'file_name')
+
+
+def downgrade():
+    op.add_column(
+        'content_revisions',
+        sa.Column(
+            'file_name',
+            sa.VARCHAR(length=255),
+            server_default=sa.text("''::character varying"),
+            autoincrement=False,
+            nullable=False
+        ),
+    )

tracim/migration/versions/c1cea4bbae16_file_extentions_value_for_pages_and_.py

+"""file_extentions value for Pages and Threads
+
+Revision ID: c1cea4bbae16
+Revises: 59fc98c3c965
+Create Date: 2016-11-30 10:41:51.893531
+
+"""
+
+# revision identifiers, used by Alembic.
+
+revision = 'c1cea4bbae16'
+down_revision = '59fc98c3c965'
+
+from alembic import op
+import sqlalchemy as sa
+
+content_revision_helper = sa.Table(
+    'content_revisions',
+    sa.MetaData(),
+    sa.Column('revision_id', sa.Integer, primary_key=True),
+    sa.Column('content_id', sa.ForeignKey(u'content.id'), nullable=False),
+    sa.Column('owner_id', sa.ForeignKey(u'users.user_id'), index=True),
+    sa.Column('label', sa.String(1024), nullable=False),
+    sa.Column('description', sa.Text, nullable=False),
+    sa.Column('file_extension', sa.String(255), nullable=False),
+    sa.Column('file_mimetype', sa.String(255), nullable=False),
+    sa.Column('file_content', sa.LargeBinary),
+    sa.Column('properties', sa.Text, nullable=False),
+    sa.Column('type', sa.String(32), nullable=False),
+    sa.Column('status', sa.String(32), nullable=False),
+    sa.Column('created', sa.DateTime, nullable=False),
+    sa.Column('updated', sa.DateTime, nullable=False),
+    sa.Column('is_deleted', sa.Boolean, nullable=False),
+    sa.Column('is_archived', sa.Boolean, nullable=False),
+    sa.Column('is_temporary', sa.Boolean, nullable=False),
+    sa.Column('revision_type', sa.String(32), nullable=False),
+    sa.Column('workspace_id', sa.ForeignKey(u'workspaces.workspace_id')),
+    sa.Column('parent_id', sa.ForeignKey(u'content.id'), index=True),
+)
+
+
+def upgrade():
+    connection = op.get_bind()
+
+    for content_revision in connection.execute(
+            content_revision_helper.select()
+    ):
+        if content_revision.type in ('page', 'thread'):
+            # Update record
+            connection.execute(
+                content_revision_helper.update()
+                    .where(
+                        content_revision_helper.c.revision_id ==
+                        content_revision.revision_id
+                    ).values(
+                        file_extension='.html',
+                    )
+                )
+
+
+def downgrade():
+    connection = op.get_bind()
+
+    for content_revision in connection.execute(
+            content_revision_helper.select()
+    ):
+        # On work with FILE
+        if content_revision.type in ('page', 'thread'):
+            # Update record
+            connection.execute(
+                content_revision_helper.update()
+                    .where(
+                        content_revision_helper.c.revision_id ==
+                        content_revision.revision_id
+                    ).values(
+                        file_extension='',
+                    )
+                )

tracim/migration/versions/e31ddc009b37_add_content_file_extension_column.py

+"""add_content_file_extension_column
+
+Revision ID: e31ddc009b37
+Revises: 2cd20ff3d23a
+Create Date: 2016-11-25 10:43:23.700867
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = 'e31ddc009b37'
+down_revision = '2cd20ff3d23a'
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    op.add_column(
+        'content_revisions',
+        sa.Column(
+            'file_extension',
+            sa.Unicode(length=255),
+            server_default='',
+            nullable=False,
+        )
+    )
+
+
+def downgrade():
+    op.drop_column(
+        'content_revisions',
+        'file_extension',
+    )

tracim/setup.py

     "python-ldap-test==0.2.1",
     "unicode-slugify==0.1.3",
     "pytz==2014.7",
+    'rq==0.7.1',
     ]
 
 setup(
             'ldap_server = tracim.command.ldap_test_server:LDAPTestServerCommand',
             'user_create = tracim.command.user:CreateUserCommand',
             'user_update = tracim.command.user:UpdateUserCommand',
+            'mail sender = tracim.command.mail:MailSenderCommend',
         ]
     },
     dependency_links=[

tracim/test.ini

 radicale.server.port = 15232
 radicale.client.port = 15232
 radicale.server.filesystem.folder = /tmp/tracim_tests_radicale_fs
+radicale.client.base_url.host = http://localhost:15232
+radicale.client.base_url.prefix = /
+email.notification.activated = false
 
 [server:main]
 use = egg:gearbox#wsgiref
 ldap_group_enabled = False
 use = config:development.ini
 
+[app:nosmtp]
+resetpassword.smtp_host = localhost
+resetpassword.smtp_login = fake
+resetpassword.smtp_passwd =  fake
+use = config:development.ini
+
 [app:radicale]
 sqlalchemy.url = sqlite:///tracim_test.sqlite
 

tracim/tracim/command/mail.py

+# -*- coding: utf-8 -*-
+from rq import Connection, Worker
+
+from tracim.command import AppContextCommand
+
+
+class MailSenderCommend(AppContextCommand):
+    def get_description(self):
+        return '''Run rq worker for mail sending'''
+
+    def take_action(self, parsed_args):
+        super().take_action(parsed_args)
+
+        with Connection():
+            w = Worker(['mail_sender'])
+            w.work()

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):
 
         try:
             user = User(email=login, password=password, **kwargs)
+            user.update_webdav_digest_auth(password)
             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()
     def _update_password_for_login(self, login, password):
         user = self._user_api.get_one_by_email(login)
         user.password = password
+        user.update_webdav_digest_auth(password)
         self._session.flush()
         transaction.commit()
 

tracim/tracim/config/__init__.py

 # -*- coding: utf-8 -*-
 from tg import AppConfig
+from tg.appwrappers.errorpage import ErrorPageApplicationWrapper \
+    as BaseErrorPageApplicationWrapper
 
 from tracim.lib.auth.wrapper import AuthConfigWrapper
+from tracim.lib.utils import ErrorPageApplicationWrapper
 
 
 class TracimAppConfig(AppConfig):
     """
     Tracim specific config processes.
     """
+    def __init__(self, minimal=False, root_controller=None):
+        super().__init__(minimal, root_controller)
+        self._replace_errors_wrapper()
+
+    def _replace_errors_wrapper(self) -> None:
+        """
+        Replace tg ErrorPageApplicationWrapper by ourself
+        """
+        for index, wrapper_class in enumerate(self.application_wrappers):
+            if issubclass(wrapper_class, BaseErrorPageApplicationWrapper):
+                self.application_wrappers[index] = ErrorPageApplicationWrapper
 
     def after_init_config(self, conf):
         AuthConfigWrapper.wrap(conf)

tracim/tracim/config/app_cfg.py

     setting = asbool(global_conf.get('the_setting'))
  
 """
+import imp
+import importlib
 from urllib.parse import urlparse
 
 import tg
 from tgext.pluggable import plug
 from tgext.pluggable import replace_template
 
-from tg.i18n import lazy_ugettext as l_
+from tracim.lib.utils import lazy_ugettext as l_
 
 import tracim
 from tracim import model
 from tracim.config import TracimAppConfig
-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 MailSenderDaemon
 from tracim.lib.daemons import RadicaleDaemon
 from tracim.lib.daemons import WsgiDavDaemon
 from tracim.model.data import ActionDescription
 
     manager.run('radicale', RadicaleDaemon)
     manager.run('webdav', WsgiDavDaemon)
+    manager.run('mail_sender', MailSenderDaemon)
 
 environment_loaded.register(lambda: start_daemons(daemons))
 
         self.WEBSITE_SUBTITLE = tg.config.get('website.home.subtitle', '')
         self.WEBSITE_HOME_BELOW_LOGIN_FORM = tg.config.get('website.home.below_login_form', '')
 
+        if tg.config.get('email.notification.from'):
+            raise Exception(
+                'email.notification.from configuration is deprecated. '
+                'Use instead email.notification.from.email and '
+                'email.notification.from.default_label.'
+            )
 
-        self.EMAIL_NOTIFICATION_FROM = tg.config.get('email.notification.from')
+        self.EMAIL_NOTIFICATION_FROM_EMAIL = \
+            tg.config.get('email.notification.from.email')
+        self.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL = \
+            tg.config.get('email.notification.from.default_label')
         self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_HTML = tg.config.get('email.notification.content_update.template.html')
         self.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_TEXT = tg.config.get('email.notification.content_update.template.text')
         self.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_HTML = tg.config.get(
             ActionDescription.COMMENT,
             ActionDescription.CREATION,
             ActionDescription.EDITION,
-            ActionDescription.REVISION
+            ActionDescription.REVISION,
+            ActionDescription.STATUS_UPDATE
         ]
 
         self.EMAIL_NOTIFICATION_NOTIFIED_CONTENTS = [
             'Tracim Calendar - Password Required',
         )
 
-        self.RADICALE_CLIENT_BASE_URL_TEMPLATE = \
-            tg.config.get('radicale.client.base_url', None)
+        self.RADICALE_CLIENT_BASE_URL_HOST = \
+            tg.config.get('radicale.client.base_url.host', None)
 
-        if not self.RADICALE_CLIENT_BASE_URL_TEMPLATE:
-            self.RADICALE_CLIENT_BASE_URL_TEMPLATE = \
-                'http://{0}:{1}'.format(
-                    self.WEBSITE_SERVER_NAME,
-                    self.RADICALE_SERVER_PORT,
-                )
+        self.RADICALE_CLIENT_BASE_URL_PREFIX = \
+            tg.config.get('radicale.client.base_url.prefix', '/')
+        # Ensure finished by '/'
+        if '/' != self.RADICALE_CLIENT_BASE_URL_PREFIX[-1]:
+            self.RADICALE_CLIENT_BASE_URL_PREFIX += '/'
+        if '/' != self.RADICALE_CLIENT_BASE_URL_PREFIX[0]:
+            self.RADICALE_CLIENT_BASE_URL_PREFIX \
+                = '/' + self.RADICALE_CLIENT_BASE_URL_PREFIX
+
+        if not self.RADICALE_CLIENT_BASE_URL_HOST:
             logger.warning(
                 self,
-                'NOTE: Generated radicale.client.base_url parameter with '
-                'followings parameters: website.server_name, '
-                'radicale.server.port -> {0}'
-                .format(self.RADICALE_CLIENT_BASE_URL_TEMPLATE)
+                'Generated radicale.client.base_url.host parameter with '
+                'followings parameters: website.server_name -> {}'
+                .format(self.WEBSITE_SERVER_NAME)
             )
+            self.RADICALE_CLIENT_BASE_URL_HOST = self.WEBSITE_SERVER_NAME
+
+        self.RADICALE_CLIENT_BASE_URL_TEMPLATE = '{}{}'.format(
+            self.RADICALE_CLIENT_BASE_URL_HOST,
+            self.RADICALE_CLIENT_BASE_URL_PREFIX,
+        )
 
         self.USER_AUTH_TOKEN_VALIDITY = int(tg.config.get(
             'user.auth_token.validity',
             '604800',
         ))
 
-        self.WSGIDAV_CONFIG_PATH = tg.config.get('wsgidav.config_path')
+        self.WSGIDAV_CONFIG_PATH = tg.config.get(
+            'wsgidav.config_path',
+            'wsgidav.conf',
+        )
+        # TODO: Convert to importlib (cf http://stackoverflow.com/questions/41063938/use-importlib-instead-imp-for-non-py-file)
+        self.wsgidav_config = imp.load_source(
+            'wsgidav_config',
+            self.WSGIDAV_CONFIG_PATH,
+        )
+        self.WSGIDAV_PORT = self.wsgidav_config.port
+        self.WSGIDAV_CLIENT_BASE_URL = \
+            tg.config.get('wsgidav.client.base_url', None)
+
+        if not self.WSGIDAV_CLIENT_BASE_URL:
+            self.WSGIDAV_CLIENT_BASE_URL = \
+                '{0}:{1}'.format(
+                    self.WEBSITE_SERVER_NAME,
+                    self.WSGIDAV_PORT,
+                )
+            logger.warning(
+                self,
+                'NOTE: Generated wsgidav.client.base_url parameter with '
+                'followings parameters: website.server_name and '
+                'wsgidav.conf port'.format(
+                    self.WSGIDAV_CLIENT_BASE_URL,
+                )
+            )
+
+        if not self.WSGIDAV_CLIENT_BASE_URL.endswith('/'):
+            self.WSGIDAV_CLIENT_BASE_URL += '/'
+
+        self.EMAIL_PROCESSING_MODE = tg.config.get(
+            'email.processing_mode',
+            'sync',
+        ).upper()
+
+        if self.EMAIL_PROCESSING_MODE not in (
+                self.CST.ASYNC,
+                self.CST.SYNC,
+        ):
+            raise Exception(
+                'email.processing_mode '
+                'can ''be "{}" or "{}", not "{}"'.format(
+                    self.CST.ASYNC,
+                    self.CST.SYNC,
+                    self.EMAIL_PROCESSING_MODE,
+                )
+            )
+
+        self.EMAIL_SENDER_REDIS_HOST = tg.config.get(
+            'email.async.redis.host',
+            'localhost',
+        )
+        self.EMAIL_SENDER_REDIS_PORT = int(tg.config.get(
+            'email.async.redis.port',
+            6379,
+        ))
+        self.EMAIL_SENDER_REDIS_DB = int(tg.config.get(
+            'email.async.redis.db',
+            0,
+        ))
 
     def get_tracker_js_content(self, js_tracker_file_path = None):
         js_tracker_file_path = tg.config.get('js_tracker_path', None)
 base_config.variable_provider = lambda: {
     'CFG': CFG.get_instance()
 }
-
-plug(base_config, 'tgext.asyncjob')

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
+from sqlalchemy.pool import NullPool
 
 __all__ = ['make_app']
 
     
    
     """
+    # Configure NullPool for SQLAlchemy id we are in tests: unknown reason
+    # don't close it's connection during test and exceed postgresql limit.
+    if global_conf.get('test') == 'true':
+        global_conf['sqlalchemy.poolclass'] = NullPool
+
     app = make_base_app(global_conf, full_stack=True, **app_conf)
     
     # Wrap your base TurboGears 2 application with custom middleware here

tracim/tracim/controllers/__init__.py

 # -*- coding: utf-8 -*-
 """Controllers for the tracim application."""
+from sqlalchemy.orm.exc import NoResultFound
+from tg import abort
+from tracim.lib.integrity import PathValidationManager
+from tracim.lib.integrity import render_invalid_integrity_chosen_path
+from tracim.lib.user import CurrentUserGetterApi
 from tracim.lib.workspace import WorkspaceApi
 
 import tg
 from tracim.model.data import Workspace
 
 from tracim.lib.content import ContentApi
-from tracim.lib.user import UserStaticApi
 from tracim.lib.utils import SameValueError
 
 from tracim.model.serializers import Context
 
     @classmethod
     def current_user(cls) -> User:
-        user = UserStaticApi.get_current_user()
+        user = CurrentUserGetterApi.get_current_user()
         tmpl_context.current_user_id = user.user_id if user else None
         tmpl_context.current_user = user if user else None
         return user
 
     @classmethod
     def current_folder(cls) -> Content:
-        content_api = ContentApi(tg.tmpl_context.current_user)
+        content_api = ContentApi(
+            tg.tmpl_context.current_user,
+            show_archived=True,
+            show_deleted=True,
+        )
         folder_id = int(tg.request.controller_state.routing_args.get('folder_id'))
         folder = content_api.get_one(folder_id, ContentType.Folder, tg.tmpl_context.workspace)
 
     TEMPLATE_NEW = 'unknown "template new"'
     TEMPLATE_EDIT = 'unknown "template edit"'
 
+    def __init__(self):
+        super().__init__()
+        self._path_validation = PathValidationManager(
+            is_case_sensitive=False,
+        )
+
     def _before(self, *args, **kw):
         """
         Instantiate the current workspace in tg.tmpl_context
         :param item_id: an item id (item may be normal content or folder
         :return:
         """
-        return ContentApi(tmpl_context.current_user).build_breadcrumb(tmpl_context.workspace, item_id)
+        return ContentApi(
+            tmpl_context.current_user,
+            show_archived=True,
+            show_deleted=True,
+        ).build_breadcrumb(tmpl_context.workspace, item_id)
 
     def _struct_new_serialized(self, workspace_id, parent_id):
         print('values are: ', workspace_id, parent_id)
     /dashboard/workspaces/{}/folders/{}/someitems/{}
     """
     def _before(self, *args, **kw):
-        TIMRestPathContextSetup.current_user()
-        TIMRestPathContextSetup.current_workspace()
-        TIMRestPathContextSetup.current_folder()
-
+        try:
+            TIMRestPathContextSetup.current_user()
+            TIMRestPathContextSetup.current_workspace()
+            TIMRestPathContextSetup.current_folder()
+        except NoResultFound:
+            abort(404)
 
     @property
     def _std_url(self):
             item = api.get_one(int(item_id), self._item_type, workspace)
             with new_revision(item):
                 api.update_content(item, label, content)
+
+                if not self._path_validation.validate_new_content(item):
+                    return render_invalid_integrity_chosen_path(
+                        item.get_label(),
+                    )
+
                 api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)

tracim/tracim/controllers/admin/user.py

 # -*- coding: utf-8 -*-
 import uuid
 
+import pytz
 from tracim import model  as pm
 
 from sprox.tablebase import TableBase
 import tg
 from tg import predicates
 from tg import tmpl_context
-from tg.i18n import ugettext as _, lazy_ugettext as l_
+from tg.i18n import ugettext as _
 
 from sprox.widgets import PropertyMultipleSelectField
 from sprox._compat import unicode_text
 from tracim.lib.email import get_email_manager
 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
 
             tg.redirect(next_url)
 
         user.password = new_password1
+        user.update_webdav_digest_auth(new_password1)
         pm.DBSession.flush()
 
         tg.flash(_('The password has been changed'), CST.STATUS_OK)
             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
         user = api.get_one(id)
 
         dictified_user = Context(CTX.USER).toDict(user, 'user')
-        return DictLikeClass(result = dictified_user)
+        return DictLikeClass(
+            result=dictified_user,
+            timezones=pytz.all_timezones,
+        )
 
     @tg.require(predicates.in_group(Group.TIM_MANAGER_GROUPNAME))
     @tg.expose()
-    def put(self, user_id, name, email, next_url=''):
+    def put(self, user_id, name, email, timezone: str='', next_url=''):
         api = UserApi(tmpl_context.current_user)
 
         user = api.get_one(int(user_id))
-        api.update(user, name, email, True)
+        api.update(user, name, email, True, timezone=timezone)
 
         tg.flash(_('User {} updated.').format(user.get_display_name()), CST.STATUS_OK)
         if next_url:

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.base import BaseController
 from tracim.lib.helpers import on_off_to_boolean
+from tracim.lib.integrity import PathValidationManager
+from tracim.lib.integrity import render_invalid_integrity_chosen_path
 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):
 
      responsible / advanced contributor. / contributor / reader
     """
 
+    def __init__(self):
+        super().__init__()
+        self._path_validation = PathValidationManager(
+            is_case_sensitive=False,
+        )
+
     @property
     def _base_url(self):
         return '/admin/workspaces'
         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()
+        # Display error page to user if chosen label is in conflict
+        if not self._path_validation.workspace_label_is_free(name):
+            return render_invalid_integrity_chosen_path(name)
+
+        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())
         user = tmpl_context.current_user
         workspace_api_controller = WorkspaceApi(user)
         calendar_enabled = on_off_to_boolean(calendar_enabled)
-
         workspace = workspace_api_controller.get_one(id)
+
+        # Display error page to user if chosen label is in conflict
+        if name != workspace.label and \
+                not self._path_validation.workspace_label_is_free(name):
+            return render_invalid_integrity_chosen_path(name)
+
         workspace.label = name
         workspace.description = description
         workspace.calendar_enabled = calendar_enabled
         workspace_api_controller.save(workspace)
 
+        if calendar_enabled:
+            workspace_api_controller.ensure_calendar_exist(workspace)
+
         tg.flash(_('{} workspace updated.').format(workspace.label), CST.STATUS_OK)
         tg.redirect(self.url(workspace.workspace_id))
         return

tracim/tracim/controllers/api.py

+# -*- coding: utf-8 -*-
+from tg import abort
+from tg import expose
+from tg import predicates
+from tg import request
+from tg import tmpl_context
+
+from tracim.lib.base import BaseController
+from tracim.lib.calendar import CalendarManager
+from tracim.lib.utils import api_require
+from tracim.lib.workspace import WorkspaceApi
+from tracim.model.serializers import Context, CTX
+
+"""
+To raise an error, use:
+
+```
+abort(
+    400,
+    detail={
+        'name': 'Parameter required'
+    },
+    comment='Missing data',
+)
+```
+
+"""
+
+
+class APIBaseController(BaseController):
+    def _before(self, *args, **kw):
+        # For be user friendly, we disable hard check of content_type
+        # if request.content_type != 'application/json':
+        #     abort(406, 'Only JSON requests are supported')
+
+        super()._before(*args, **kw)
+
+
+class WorkspaceController(APIBaseController):
+    @expose('json')
+    @api_require(predicates.not_anonymous())
+    def index(self):
+        # NOTE BS 20161025: I can't use tmpl_context.current_user,
+        # I d'ont know why
+        workspace_api = WorkspaceApi(tmpl_context.identity.get('user'))
+        workspaces = workspace_api.get_all()
+        serialized_workspaces = Context(CTX.API_WORKSPACE).toDict(workspaces)
+
+        return {
+            'value_list': serialized_workspaces
+        }
+
+
+class CalendarsController(APIBaseController):
+    @expose('json')
+    @api_require(predicates.not_anonymous())
+    def index(self):
+        # NOTE BS 20161025: I can't use tmpl_context.current_user,
+        # I d'ont know why
+        user = tmpl_context.identity.get('user')
+        calendar_workspaces = CalendarManager\
+            .get_workspace_readable_calendars_for_user(user)
+        calendars = Context(CTX.API_CALENDAR_WORKSPACE)\
+            .toDict(calendar_workspaces)
+
+        # Manually add information about user calendar
+        calendars.append(Context(CTX.API_CALENDAR_USER).toDict(user))
+
+        return {
+            'value_list': calendars
+        }
+
+
+class APIController(BaseController):
+    workspaces = WorkspaceController()
+    calendars = CalendarsController()

tracim/tracim/controllers/calendar.py

 import re
 import tg
 from tg import tmpl_context
+from tg.predicates import not_anonymous
 
 from tracim.lib.base import BaseController
 from tracim.lib.calendar import CalendarManager
     """
 
     @tg.expose('tracim.templates.calendar.iframe_container')
+    @tg.require(not_anonymous())
     def index(self):
         user = tmpl_context.identity.get('user')
         dictified_current_user = Context(CTX.CURRENT_USER).toDict(user)
 
     @tg.expose('tracim.templates.calendar.config')
     def index(self):
+        from tracim.config.app_cfg import CFG
+        cfg = CFG.get_instance()
+
         # TODO BS 20160720: S'assurer d'être identifié !
         user = tmpl_context.identity.get('user')
         dictified_current_user = Context(CTX.CURRENT_USER).toDict(user)
         workspace_calendar_urls = CalendarManager\
             .get_workspace_readable_calendars_urls_for_user(user)
         base_href_url = \
-            re.sub(r"^http[s]?://", '', CalendarManager.get_base_url())
+            re.sub(r"^http[s]?://", '', cfg.RADICALE_CLIENT_BASE_URL_HOST)
 
         # Template will use User.auth_token, ensure it's validity
         user.ensure_auth_token()

tracim/tracim/controllers/content.py

 # -*- coding: utf-8 -*-
-import sys
-
 __author__ = 'damien'
 
-from cgi import FieldStorage
+import sys
+import traceback
 
+from cgi import FieldStorage
 import tg
 from tg import tmpl_context
 from tg.i18n import ugettext as _
 from tg.predicates import not_anonymous
 
-import traceback
-
 from tracim.controllers import TIMRestController
 from tracim.controllers import TIMRestPathContextSetup
 from tracim.controllers import TIMRestControllerWithBreadcrumb
 from tracim.controllers import TIMWorkspaceContentRestController
-
 from tracim.lib import CST
 from tracim.lib.base import BaseController
 from tracim.lib.base import logger
 from tracim.lib.utils import SameValueError
+from tracim.lib.utils import get_valid_header_file_name
+from tracim.lib.utils import str_as_bool
 from tracim.lib.content import ContentApi
 from tracim.lib.helpers import convert_id_into_instances
 from tracim.lib.predicates import current_user_is_reader
 from tracim.lib.predicates import current_user_is_contributor
 from tracim.lib.predicates import current_user_is_content_manager
 from tracim.lib.predicates import require_current_user_is_owner
-
 from tracim.model.serializers import Context, CTX, DictLikeClass
 from tracim.model.data import ActionDescription
 from tracim.model import new_revision
+from tracim.model import DBSession
 from tracim.model.data import Content
 from tracim.model.data import ContentType
 from tracim.model.data import UserRoleInWorkspace
 from tracim.model.data import Workspace
+from tracim.lib.integrity import render_invalid_integrity_chosen_path
+
 
 class UserWorkspaceFolderThreadCommentRestController(TIMRestController):
 
         return tg.url('/workspaces/{}/folders/{}')
 
     @property
+    def _err_url(self):
+        return tg.url('/dashboard/workspaces/{}/folders/{}/file/{}')
+
+    @property
     def _item_type(self):
         return ContentType.File
 
         file_id = int(file_id)
         user = tmpl_context.current_user
         workspace = tmpl_context.workspace
-        workspace_id = tmpl_context.workspace_id
 
         current_user_content = Context(CTX.CURRENT_USER,
                                        current_user=user).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
-        content_api = ContentApi(user)
+        content_api = ContentApi(
+            user,
+            show_archived=True,
+            show_deleted=True,
+        )
         if revision_id:
             file = content_api.get_one_from_revision(file_id,  self._item_type, workspace, revision_id)
         else:
             tg.response.headers['Content-type'] = str(revision_to_send.file_mimetype)
 
         tg.response.headers['Content-Type'] = content_type
-        tg.response.headers['Content-Disposition'] = str('attachment; filename="{}"'.format(revision_to_send.file_name))
+        file_name = get_valid_header_file_name(revision_to_send.file_name)
+        tg.response.headers['Content-Disposition'] = \
+            str('attachment; filename="{}"'.format(file_name))
         return revision_to_send.file_content
 
 
     def post(self, label='', file_data=None):
         # TODO - SECURE THIS
         workspace = tmpl_context.workspace
+        folder = tmpl_context.folder
 
         api = ContentApi(tmpl_context.current_user)
-
-        file = api.create(ContentType.File, workspace, tmpl_context.folder, label)
-        api.update_file_data(file, file_data.filename, file_data.type, file_data.file.read())
+        with DBSession.no_autoflush:
+            file = api.create(ContentType.File, workspace, folder, label)
+            api.update_file_data(file, file_data.filename, file_data.type, file_data.file.read())
+
+            # Display error page to user if chosen label is in conflict
+            if not self._path_validation.validate_new_content(file):
+                return render_invalid_integrity_chosen_path(
+                    file.get_label_as_file(),
+                )
         api.save(file, ActionDescription.CREATION)
 
         tg.flash(_('File created'), CST.STATUS_OK)
 
     @tg.require(current_user_is_contributor())
     @tg.expose()
-    def put(self, item_id, file_data=None, comment=None, label=''):
+    def put(self, item_id, file_data=None, comment=None, label=None):
         # TODO - SECURE THIS
         workspace = tmpl_context.workspace
 
         try:
-            item_saved = False
             api = ContentApi(tmpl_context.current_user)
             item = api.get_one(int(item_id), self._item_type, workspace)
+            label_changed = False
+            if label is not None and label != item.label:
+                label_changed = True
+
+            if label is None:
+                label = ''
 
             # TODO - D.A. - 2015-03-19
             # refactor this method in order to make code easier to understand
 
             with new_revision(item):
 
-                if comment and label:
+                if (comment and label) or (not comment and label_changed):
                     updated_item = api.update_content(
                         item, label if label else item.label,
                         comment if comment else ''
                     )
+
+                    # Display error page to user if chosen label is in conflict
+                    if not self._path_validation.validate_new_content(
+                        updated_item,
+                    ):
+                        return render_invalid_integrity_chosen_path(
+                            updated_item.get_label_as_file(),
+                        )
+
                     api.save(updated_item, ActionDescription.EDITION)
 
                     # This case is the default "file title and description update"
 
                     if isinstance(file_data, FieldStorage):
                         api.update_file_data(item, file_data.filename, file_data.type, file_data.file.read())
+
+                        # Display error page to user if chosen label is in
+                        # conflict
+                        if not self._path_validation.validate_new_content(
+                            item,
+                        ):
+                            return render_invalid_integrity_chosen_path(
+                                item.get_label_as_file(),
+                            )
+
                         api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)
         current_user_content = Context(CTX.CURRENT_USER).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
-        content_api = ContentApi(user)
+        content_api = ContentApi(
+            user,
+            show_deleted=True,
+            show_archived=True,
+        )
         if revision_id:
             page = content_api.get_one_from_revision(page_id, ContentType.Page, workspace, revision_id)
         else:
 
         api = ContentApi(tmpl_context.current_user)
 
-        page = api.create(ContentType.Page, workspace, tmpl_context.folder, label)
-        page.description = content
+        with DBSession.no_autoflush:
+            page = api.create(ContentType.Page, workspace, tmpl_context.folder, label)
+            page.description = content
+
+            if not self._path_validation.validate_new_content(page):
+                return render_invalid_integrity_chosen_path(
+                    page.get_label(),
+                )
+
         api.save(page, ActionDescription.CREATION, do_notify=True)
 
         tg.flash(_('Page created'), CST.STATUS_OK)
             item = api.get_one(int(item_id), self._item_type, workspace)
             with new_revision(item):
                 api.update_content(item, label, content)
+
+                if not self._path_validation.validate_new_content(item):
+                    return render_invalid_integrity_chosen_path(
+                        item.get_label(),
+                    )
+
                 api.save(item, ActionDescription.REVISION)
 
             msg = _('{} updated').format(self._item_type_label)
 
         api = ContentApi(tmpl_context.current_user)
 
-        thread = api.create(ContentType.Thread, workspace, tmpl_context.folder, label)
-        # FIXME - DO NOT DUPLCIATE FIRST MESSAGE thread.description = content
-        api.save(thread, ActionDescription.CREATION, do_notify=False)
+        with DBSession.no_autoflush:
+            thread = api.create(ContentType.Thread, workspace, tmpl_context.folder, label)
+            # FIXME - DO NOT DUPLCIATE FIRST MESSAGE thread.description = content
+            api.save(thread, ActionDescription.CREATION, do_notify=False)
+
+            comment = api.create(ContentType.Comment, workspace, thread, label)
+            comment.label = ''
+            comment.description = content
+
+            if not self._path_validation.validate_new_content(thread):
+                return render_invalid_integrity_chosen_path(
+                    thread.get_label(),
+                )
 
-        comment = api.create(ContentType.Comment, workspace, thread, label)
-        comment.label = ''
-        comment.description = content
         api.save(comment, ActionDescription.COMMENT, do_notify=False)
         api.do_notify(thread)
 
 
     @tg.require(current_user_is_reader())
     @tg.expose('tracim.templates.thread.getone')
-    def get_one(self, thread_id):
+    def get_one(self, thread_id, **kwargs):
+        """
+        :param thread_id: content_id of Thread
+        :param inverted: fill with True equivalent to invert order of comments
+                         NOTE: This parameter is in kwargs because prevent URL
+                         changes.
+        """
+        inverted = kwargs.get('inverted')
         thread_id = int(thread_id)
         user = tmpl_context.current_user
         workspace = tmpl_context.workspace
         current_user_content = Context(CTX.CURRENT_USER).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
-        content_api = ContentApi(user)
+        content_api = ContentApi(
+            user,
+            show_deleted=True,
+            show_archived=True,
+        )
         thread = content_api.get_one(thread_id, ContentType.Thread, workspace)
 
         fake_api_breadcrumb = self.get_breadcrumb(thread_id)
         fake_api = Context(CTX.FOLDER).toDict(fake_api_content)
 
         dictified_thread = Context(CTX.THREAD).toDict(thread, 'thread')
-        return DictLikeClass(result = dictified_thread, fake_api=fake_api)
+
+        if inverted:
+          dictified_thread.thread.history = reversed(dictified_thread.thread.history)
+
+        return DictLikeClass(
+            result=dictified_thread,
+            fake_api=fake_api,
+            inverted=inverted,
+        )
 
 
 
 
     @tg.require(current_user_is_reader())
     @tg.expose('tracim.templates.folder.getone')
-    def get_one(self, folder_id):
+    def get_one(self, folder_id, **kwargs):
+        """
+        :param folder_id: Displayed folder id
+        :param kwargs:
+          * show_deleted: bool: Display deleted contents or hide them if False
+          * show_archived: bool: Display archived contents or hide them
+            if False
+        """
+        show_deleted = str_as_bool(kwargs.get('show_deleted', ''))
+        show_archived = str_as_bool(kwargs.get('show_archived', ''))
         folder_id = int(folder_id)
         user = tmpl_context.current_user
         workspace = tmpl_context.workspace
-        workspace_id = tmpl_context.workspace_id
 
         current_user_content = Context(CTX.CURRENT_USER,
                                        current_user=user).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
-        content_api = ContentApi(user)
-        folder = content_api.get_one(folder_id, ContentType.Folder, workspace)
+        content_api = ContentApi(
+            user,
+            show_deleted=show_deleted,
+            show_archived=show_archived,
+        )
+        with content_api.show(show_deleted=True, show_archived=True):
+            folder = content_api.get_one(
+                folder_id,
+                ContentType.Folder,
+                workspace,
+            )
 
         fake_api_breadcrumb = self.get_breadcrumb(folder_id)
         fake_api_subfolders = self.get_all_fake(workspace, folder.content_id).result
 
         fake_api = Context(CTX.FOLDER).toDict(fake_api_content)
 
-        fake_api.sub_items = Context(CTX.FOLDER_CONTENT_LIST).toDict(
-            folder.get_valid_children([ContentType.Folder,
-                                       ContentType.File,
-                                       ContentType.Page,
-                                       ContentType.Thread]))
+        sub_items = content_api.get_children(
+            parent_id=folder.content_id,
+            content_types=[
+                ContentType.Folder,
+                ContentType.File,
+                ContentType.Page,
+                ContentType.Thread,
+            ],
+
+        )
+        fake_api.sub_items = Context(CTX.FOLDER_CONTENT_LIST).toDict(sub_items)
 
         fake_api.content_types = Context(CTX.DEFAULT).toDict(
-            content_api.get_all_types())
+            content_api.get_all_types()
+        )
 
         dictified_folder = Context(CTX.FOLDER).toDict(folder, 'folder')
-        return DictLikeClass(result = dictified_folder, fake_api=fake_api)
+        return DictLikeClass(
+            result=dictified_folder,
+            fake_api=fake_api,
+            show_deleted=show_deleted,
+            show_archived=show_archived,
+        )
 
 
     def get_all_fake(self, context_workspace: Workspace, parent_id=None):
         """
         workspace = context_workspace
         content_api = ContentApi(tmpl_context.current_user)
-        parent_folder = content_api.get_one(parent_id, ContentType.Folder)
+        with content_api.show(show_deleted=True, show_archived=True):
+            parent_folder = content_api.get_one(parent_id, ContentType.Folder)
         folders = content_api.get_child_folders(parent_folder, workspace)
 
         folders = Context(CTX.FOLDERS).toDict(folders)
             parent = None
             if parent_id:
                 parent = api.get_one(int(parent_id), ContentType.Folder, workspace)
-            folder = api.create(ContentType.Folder, workspace, parent, label)
 
-            subcontent = dict(
-                folder = True if can_contain_folders=='on' else False,
-                thread = True if can_contain_threads=='on' else False,
-                file = True if can_contain_files=='on' else False,
-                page = True if can_contain_pages=='on' else False
-            )
-            api.set_allowed_content(folder, subcontent)
+            with DBSession.no_autoflush:
+                folder = api.create(ContentType.Folder, workspace, parent, label)
+
+                subcontent = dict(
+                    folder = True if can_contain_folders=='on' else False,
+                    thread = True if can_contain_threads=='on' else False,
+                    file = True if can_contain_files=='on' else False,
+                    page = True if can_contain_pages=='on' else False
+                )
+                api.set_allowed_content(folder, subcontent)
+
+                if not self._path_validation.validate_new_content(folder):
+                    return render_invalid_integrity_chosen_path(
+                        folder.get_label(),
+                    )
+
             api.save(folder)
 
             tg.flash(_('Folder created'), CST.STATUS_OK)
                     # TODO - D.A. - 2015-05-25 - Allow to set folder description
                     api.update_content(folder, label, folder.description)
                 api.set_allowed_content(folder, subcontent)
+
+                if not self._path_validation.validate_new_content(folder):
+                    return render_invalid_integrity_chosen_path(
+                        folder.get_label(),
+                    )
+
                 api.save(folder)
 
             tg.flash(_('Folder updated'), CST.STATUS_OK)
             back_url = self._parent_url.format(item.workspace_id, item.parent_id)
             msg = _('{} not un-deleted: {}').format(self._item_type_label, str(e))
             tg.flash(msg, CST.STATUS_ERROR)
-            tg.redirect(back_url)
+            tg.redirect(back_url)

tracim/tracim/controllers/root.py

 # -*- coding: utf-8 -*-
-
+import tg
 from tg import expose
 from tg import flash
 from tg import lurl
 from tg import url
 
 from tg.i18n import ugettext as _
+from tracim.controllers.api import APIController
 
 from tracim.lib import CST
 from tracim.lib.base import logger
-from tracim.lib.user import UserStaticApi
+from tracim.lib.user import CurrentUserGetterApi
 from tracim.lib.content import ContentApi
 
 from tracim.controllers import StandardController
     workspaces = UserWorkspaceRestController()
     user = UserRestController()
 
+    # api
+    api = APIController()
+
     def _render_response(self, tgl, controller, response):
         replace_reset_password_templates(controller.decoration.engines)
         return super()._render_response(tgl, controller, response)
             redirect(url('/login'),
                 params=dict(came_from=came_from, __logins=login_counter))
 
-        user = UserStaticApi.get_current_user()
+        user = CurrentUserGetterApi.get_current_user()
 
         flash(_('Welcome back, %s!') % user.get_display_name())
         redirect(came_from)

tracim/tracim/controllers/user.py

 # -*- coding: utf-8 -*-
+import pytz
+from sqlalchemy.orm.exc import NoResultFound
+from tracim.lib import CST
 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):
             tg.redirect(redirect_url)
 
         current_user.password = new_password1
-        current_user.webdav_left_digest_response_hash = '%s:/:%s' % (current_user.email, new_password1)
+        current_user.update_webdav_digest_auth(new_password1)
         pm.DBSession.flush()
 
         tg.flash(_('Your password has been changed'))
 
         dictified_user = Context(CTX.USER).toDict(current_user, 'user')
         fake_api = DictLikeClass(next_url=next_url)
-        return DictLikeClass(result=dictified_user, fake_api=fake_api)
+        return DictLikeClass(
+            result=dictified_user,
+            fake_api=fake_api,
+            timezones=pytz.all_timezones,
+        )
 
     @tg.expose('tracim.templates.workspace.edit')
-    def put(self, user_id, name, email, next_url=None):
+    def put(self, user_id, name, email, timezone, next_url=None):
         user_id = tmpl_context.current_user.user_id
         current_user = tmpl_context.current_user
+        user_api = UserApi(current_user)
         assert user_id==current_user.user_id
+        if next_url:
+            next = tg.url(next_url)
+        else:
+            next = self.url()
+
+        try:
+            email_user = user_api.get_one_by_email(email)
+            if email_user != current_user:
+                tg.flash(_('Email already in use'), CST.STATUS_ERROR)
+                tg.redirect(next)
+        except NoResultFound:
+            pass
 
         # Only keep allowed field update
         updated_fields = self._clean_update_fields({
             'name': name,
-            'email': email
+            'email': email,
+            'timezone': timezone,
         })
 
         api = UserApi(tmpl_context.current_user)
         api.update(current_user, do_save=True, **updated_fields)
         tg.flash(_('profile updated.'))
-        if next_url:
-            tg.redirect(tg.url(next_url))
-        tg.redirect(self.url())
+        tg.redirect(next)
 
     def _clean_update_fields(self, fields: dict):
         """

tracim/tracim/controllers/workspace.py

 
 from tracim.lib.helpers import convert_id_into_instances
 from tracim.lib.content import ContentApi
+from tracim.lib.utils import str_as_bool
 from tracim.lib.workspace import WorkspaceApi
 
 from tracim.model.data import NodeTreeItem
         tg.redirect(tg.url('/home'))
 
     @tg.expose('tracim.templates.workspace.getone')
-    def get_one(self, workspace_id):
+    def get_one(self, workspace_id, **kwargs):
+        """
+        :param workspace_id: Displayed workspace id
+        :param kwargs:
+          * show_deleted: bool: Display deleted contents or hide them if False
+          * show_archived: bool: Display archived contents or hide them
+            if False
+        """
+        show_deleted = str_as_bool(kwargs.get('show_deleted', False))
+        show_archived = str_as_bool(kwargs.get('show_archived', ''))
         user = tmpl_context.current_user
 
         current_user_content = Context(CTX.CURRENT_USER).toDict(user)
         )
 
         fake_api.sub_items = Context(CTX.FOLDER_CONTENT_LIST).toDict(
-            workspace.get_valid_children(ContentApi.DISPLAYABLE_CONTENTS)
+            # TODO BS 20161209: Is the correct way to grab folders? No use API?
+            workspace.get_valid_children(
+                ContentApi.DISPLAYABLE_CONTENTS,
+                show_deleted=show_deleted,
+                show_archived=show_archived,
+            )
         )
 
         dictified_workspace = Context(CTX.WORKSPACE).toDict(workspace, 'workspace')
-
-        return DictLikeClass(result = dictified_workspace, fake_api=fake_api)
-
+        webdav_url = CFG.get_instance().WSGIDAV_CLIENT_BASE_URL
+
+        return DictLikeClass(
+            result=dictified_workspace,
+            fake_api=fake_api,
+            webdav_url=webdav_url,
+            show_deleted=show_deleted,
+            show_archived=show_archived,
+        )
 
     @tg.expose('json')
     def treeview_root(self, id='#',

tracim/tracim/fixtures/content.py

+# -*- coding: utf-8 -*-
+from tracim import model
+from tracim.fixtures import Fixture
+from tracim.fixtures.users_and_groups import Test
+from tracim.lib.content import ContentApi
+from tracim.lib.userworkspace import RoleApi
+from tracim.lib.workspace import WorkspaceApi
+from tracim.model.data import ContentType
+from tracim.model.data import UserRoleInWorkspace
+
+
+class Content(Fixture):
+    require = [Test]
+
+    def insert(self):
+        admin = self._session.query(model.User) \
+            .filter(model.User.email == 'admin@admin.admin') \
+            .one()
+        bob = self._session.query(model.User) \
+            .filter(model.User.email == 'bob@fsf.local') \
+            .one()
+        workspace_api = WorkspaceApi(admin)
+        content_api = ContentApi(admin)
+        role_api = RoleApi(admin)
+
+        # Workspaces
+        w1 = workspace_api.create_workspace('w1', save_now=True)
+        w2 = workspace_api.create_workspace('w2', save_now=True)
+        w3 = workspace_api.create_workspace('w3', save_now=True)
+
+        # Workspaces roles
+        role_api.create_one(
+            user=bob,
+            workspace=w1,
+            role_level=UserRoleInWorkspace.CONTENT_MANAGER,
+            with_notif=False,
+        )
+        role_api.create_one(
+            user=bob,
+            workspace=w2,
+            role_level=UserRoleInWorkspace.CONTENT_MANAGER,
+            with_notif=False,
+        )
+
+        # Folders
+        w1f1 = content_api.create(
+            content_type=ContentType.Folder,
+            workspace=w1,
+            label='w1f1',
+            do_save=True,
+        )
+        w1f2 = content_api.create(
+            content_type=ContentType.Folder,
+            workspace=w1,
+            label='w1f2',
+            do_save=True,
+        )
+
+        w2f1 = content_api.create(
+            content_type=ContentType.Folder,
+            workspace=w2,
+            label='w2f1',
+            do_save=True,
+        )
+        w2f2 = content_api.create(
+            content_type=ContentType.Folder,
+            workspace=w2,
+            label='w2f2',
+            do_save=True,
+        )
+
+        w3f1 = content_api.create(
+            content_type=ContentType.Folder,
+            workspace=w3,
+            label='w3f3',
+            do_save=True,
+        )
+
+        # Pages, threads, ..
+        w1f1p1 = content_api.create(
+            content_type=ContentType.Page,
+            workspace=w1,
+            parent=w1f1,
+            label='w1f1p1',
+            do_save=True,
+        )
+        w1f1t1 = content_api.create(
+            content_type=ContentType.Thread,
+            workspace=w1,
+            parent=w1f1,
+            label='w1f1t1',
+            do_save=False,
+        )
+        w1f1t1.description = 'w1f1t1 description'
+        self._session.add(w1f1t1)
+        w1f1d1_txt = content_api.create(
+            content_type=ContentType.File,
+            workspace=w1,
+            parent=w1f1,
+            label='w1f1d1',
+            do_save=False,
+        )
+        w1f1d1_txt.file_extension = '.txt'
+        w1f1d1_txt.file_content = b'w1f1d1 content'
+        self._session.add(w1f1d1_txt)
+        w1f1d2_html = content_api.create(
+            content_type=ContentType.File,
+            workspace=w1,
+            parent=w1f1,
+            label='w1f1d2',
+            do_save=False,
+        )
+        w1f1d2_html.file_extension = '.html'
+        w1f1d2_html.file_content = b'<p>w1f1d2 content</p>'
+        self._session.add(w1f1d2_html)
+        w1f1f1 = content_api.create(
+            content_type=ContentType.Folder,
+            workspace=w1,
+            label='w1f1f1',
+            parent=w1f1,
+            do_save=True,
+        )
+
+        w2f1p1 = content_api.create(
+            content_type=ContentType.Page,
+            workspace=w2,
+            parent=w2f1,
+            label='w2f1p1',
+            do_save=True,
+        )
+        self._session.flush()

tracim/tracim/lib/__init__.py

 # -*- coding: utf-8 -*-
-from tg.i18n import lazy_ugettext as l_
+
 
 class NotFoundError(Exception):
     pass

tracim/tracim/lib/app_globals.py

 from markupsafe import escape_silent as escape
 
 import tg
-from tg.i18n import ugettext as _, lazy_ugettext as l_
+from tracim.lib.utils import lazy_ugettext as l_
 from tg.flash import TGFlash
 
 """The application's Globals object"""
         pass
 
     VERSION_NUMBER = '1.0.3'
-    LONG_DATE_FORMAT = '%A, the %d of %B %Y at %H:%M'
     SHORT_DATE_FORMAT = l_('%B %d at %I:%M%p')
 
 

tracim/tracim/lib/calendar.py

+import caldav
 import os
 
 import re
 import transaction
+from caldav.lib.error import PutError
 
 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
 from tracim.lib.exceptions import UnknownCalendarType
 
 class CalendarManager(object):
     @classmethod
-    def get_base_url(cls):
+    def get_personal_calendar_description(cls) -> str:
+        return _('My personal calendar')
+
+    @classmethod
+    def get_base_url(cls, low_level: bool=False) -> str:
+        """
+        :param low_level: If True, use local ip address with radicale port.
+        :return: Radical address base url.
+        """
         from tracim.config.app_cfg import CFG
         cfg = CFG.get_instance()
-        return cfg.RADICALE_CLIENT_BASE_URL_TEMPLATE
+
+        if not low_level:
+            return cfg.RADICALE_CLIENT_BASE_URL_TEMPLATE
+
+        return 'http://127.0.0.1:{0}'.format(cfg.RADICALE_SERVER_PORT)
 
     @classmethod
     def get_user_base_url(cls):
         return os.path.join(cfg.RADICALE_CLIENT_BASE_URL_TEMPLATE, 'workspace/')
 
     @classmethod
-    def get_user_calendar_url(cls, user_id: int):
+    def get_user_calendar_url(
+            cls,
+            user_id: int,
+            low_level: bool=False,
+    ):
         user_path = CALENDAR_USER_URL_TEMPLATE.format(id=str(user_id))
-        return os.path.join(cls.get_base_url(), user_path)
+        return os.path.join(
+            cls.get_base_url(low_level=low_level),
+            user_path,
+        )
 
     @classmethod
-    def get_workspace_calendar_url(cls, workspace_id: int):
+    def get_workspace_calendar_url(
+            cls,
+            workspace_id: int,
+            low_level: bool=False,
+    ):
         workspace_path = CALENDAR_WORKSPACE_URL_TEMPLATE.format(
             id=str(workspace_id)
         )
-        return os.path.join(cls.get_base_url(), workspace_path)
+        return os.path.join(
+            cls.get_base_url(low_level=low_level),
+            workspace_path,
+        )
 
     def __init__(self, user: User):
         self._user = user
     def get_workspace_readable_calendars_urls_for_user(cls, user: User)\
             -> [str]:
         calendar_urls = []
+        for workspace in cls.get_workspace_readable_calendars_for_user(user):
+            calendar_urls.append(cls.get_workspace_calendar_url(
+                workspace_id=workspace.workspace_id,
+            ))
+
+        return calendar_urls
+
+    @classmethod
+    def get_workspace_readable_calendars_for_user(cls, user: User)\
+            -> ['Workspace']:
+        workspaces = []
         workspace_api = WorkspaceApi(user)
-        for workspace in workspace_api.get_all_for_user(user):
+
+        for workspace in workspace_api.get_all():
             if workspace.calendar_enabled:
-                calendar_urls.append(cls.get_workspace_calendar_url(
-                    workspace_id=workspace.workspace_id,
-                ))
+                workspaces.append(workspace)
 
-        return calendar_urls
+        return workspaces
 
     def is_discovery_path(self, path: str) -> bool:
         """
         :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(low_level=True)
+        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,
+                low_level=True,
+            )
+        elif calendar_class == UserCalendar:
+            calendar_url = self.get_user_calendar_url(
+                related_object_id,
+                low_level=True,
+            )
+        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))
+        try:
+            event = user_calendar.add_event(event_ics)
+            event.delete()
+        except PutError:
+            pass  # TODO BS 20161128: Radicale is down. Record this event ?
+

tracim/tracim/lib/content.py

 # -*- coding: utf-8 -*-
+from contextlib import contextmanager
+
+import os
+
+from operator import itemgetter
+from sqlalchemy import func
+from sqlalchemy.orm import Query
+
 __author__ = 'damien'
 
 import datetime
         self._force_show_all_types = force_show_all_types
         self._disable_user_workspaces_filter = disable_user_workspaces_filter
 
+    @contextmanager
+    def show(
+            self,
+            show_archived: bool=False,
+            show_deleted: bool=False,
+            show_temporary: bool=False,
+    ):
+        """
+        Use this method as context manager to update show_archived,
+        show_deleted and show_temporary properties during context.
+        :param show_archived: show archived contents
+        :param show_deleted:  show deleted contents
+        :param show_temporary:  show temporary contents
+        """
+        previous_show_archived = self._show_archived
+        previous_show_deleted = self._show_deleted
+        previous_show_temporary = self._show_temporary
+
+        try:
+            self._show_archived = show_archived
+            self._show_deleted = show_deleted
+            self._show_temporary = show_temporary
+            yield self
+        finally:
+            self._show_archived = previous_show_archived
+            self._show_deleted = previous_show_deleted
+            self._show_temporary = previous_show_temporary
+
     @classmethod
     def get_revision_join(cls):
         """
         if workspace:
             result = result.filter(Content.workspace_id==workspace.workspace_id)
 
+        # Security layer: if user provided, filter
+        # with user workspaces privileges
         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 \
                              if r.role>=UserRoleInWorkspace.READER]
-            result = result.filter(Content.workspace_id.in_(workspace_ids))
+            result = result.filter(or_(
+                Content.workspace_id.in_(workspace_ids),
+                # And allow access to non workspace document when he is owner
+                and_(
+                    Content.workspace_id == None,
+                    Content.owner_id == self._user_id,
+                )
+            ))
 
         return result
 
 
         return result
 
+    def get_base_query(self, workspace: Workspace) -> Query:
+        return self._base_query(workspace)
+
     def get_child_folders(self, parent: Content=None, workspace: Workspace=None, filter_by_allowed_content_types: list=[], removed_item_ids: list=[], allowed_node_types=None) -> [Content]:
         """
         This method returns child items (folders or items) for left bar treeview.
 
     def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', do_save=False, is_temporary: bool=False) -> Content:
         assert content_type in ContentType.allowed_types()
+
+        if content_type == ContentType.Folder and not label:
+            label = self.generate_folder_label(workspace, parent)
+
         content = Content()
         content.owner = self._user
         content.parent = parent
         content.is_temporary = is_temporary
         content.revision_type = ActionDescription.CREATION
 
+        if content.type in (
+                ContentType.Page,
+                ContentType.Thread,
+        ):
+            content.file_extension = '.html'
+
         if do_save:
             DBSession.add(content)
             self.save(content, ActionDescription.CREATION)
 
         return revision
 
-    def get_one_by_label_and_parent(self, content_label: str, content_parent: Content = None,
-                                    workspace: Workspace = None) -> Content:
+    def get_one_by_label_and_parent(
+            self,
+            content_label: str,
+            content_parent: Content=None,
+    ) -> Content:
         """
         This method let us request the database to obtain a Content with its name and parent
         :param content_label: Either the content's label or the content's filename if the label is None
         :param workspace: The workspace's content
         :return The corresponding Content
         """
-        assert content_label is not None# DYN_REMOVE
-
-        resultset = self._base_query(workspace)
-
+        workspace = content_parent.workspace if content_parent else None
+        query = self._base_query(workspace)
         parent_id = content_parent.content_id if content_parent else None
+        query = query.filter(Content.parent_id == parent_id)
+
+        file_name, file_extension = os.path.splitext(content_label)
+
+        return query.filter(
+            or_(
+                and_(
+                    Content.type == ContentType.File,
+                    Content.label == file_name,
+                    Content.file_extension == file_extension,
+                ),
+                and_(
+                    Content.type == ContentType.Thread,
+                    Content.label == file_name,
+                ),
+                and_(
+                    Content.type == ContentType.Page,
+                    Content.label == file_name,
+                ),
+                and_(
+                    Content.type == ContentType.Folder,
+                    Content.label == content_label,
+                ),
+            )
+        ).one()
 
-        resultset = resultset.filter(Content.parent_id == parent_id)
+    def get_one_by_label_and_parent_labels(
+            self,
+            content_label: str,
+            workspace: Workspace,
+            content_parent_labels: [str]=None,
+    ):
+        """
+        Return content with it's label, workspace and parents labels (optional)
+        :param content_label: label of content (label or file_name)
+        :param workspace: workspace containing all of this
+        :param content_parent_labels: Ordered list of labels representing path
+            of folder (without workspace label).
+        E.g.: ['foo', 'bar'] for complete path /Workspace1/foo/bar folder
+        :return: Found Content
+        """
+        query = self._base_query(workspace)
+        parent_folder = None
+
+        # Grab content parent folder if parent path given
+        if content_parent_labels:
+            parent_folder = self.get_folder_with_workspace_path_labels(
+                content_parent_labels,
+                workspace,
+            )
 
-        return resultset.filter(or_(
-            Content.label == content_label,
-            Content.file_name == content_label,
-            Content.label == re.sub(r'\.[^.]+$', '', content_label)
-        )).one()
+        # Build query for found content by label
+        content_query = self.filter_query_for_content_label_as_path(
+            query=query,
+            content_label_as_file=content_label,
+        )
 
-    def get_one_by_label_and_parent_label(self, content_label: str, content_parent_label: [str]=None, workspace: Workspace=None):
-        assert content_label is not None  # DYN_REMOVE
-        resultset = self._base_query(workspace)
+        # Modify query to apply parent folder filter if any
+        if parent_folder:
+            content_query = content_query.filter(
+                Content.parent_id == parent_folder.content_id,
+            )
+        else:
+            content_query = content_query.filter(
+                Content.parent_id == None,
+            )
 
-        res =  resultset.filter(or_(
-            Content.label == content_label,
-            Content.file_name == content_label,
-            Content.label == re.sub(r'\.[^.]+$', '', content_label)
-        )).all()
+        # Filter with workspace
+        content_query = content_query.filter(
+            Content.workspace_id == workspace.workspace_id,
+        )
 
-        if content_parent_label:
-            tmp = dict()
-            for content in res:
-                tmp[content] = content.parent
+        # Return the content
+        return content_query\
+            .order_by(
+                Content.revision_id.desc(),
+            )\
+            .one()
 
-            for parent_label in reversed(content_parent_label):
-                a = []
-                tmp = {content: parent.parent for content, parent in tmp.items()
-                       if parent and parent.label == parent_label}
+    def get_folder_with_workspace_path_labels(
+            self,
+            path_labels: [str],
+            workspace: Workspace,
+    ) -> Content:
+        """
+        Return a Content folder for given relative path.
+        TODO BS 20161124: Not safe if web interface allow folder duplicate names
+        :param path_labels: List of labels representing path of folder
+        (without workspace label).
+        E.g.: ['foo', 'bar'] for complete path /Workspace1/foo/bar folder
+        :param workspace: workspace of folders
+        :return: Content folder
+        """
+        query = self._base_query(workspace)
+        folder = None
+
+        for label in path_labels:
+            # Filter query on label
+            folder_query = query \
+                .filter(
+                    Content.type == ContentType.Folder,
+                    Content.label == label,
+                    Content.workspace_id == workspace.workspace_id,
+                )
 
-                if len(tmp) == 1:
-                    content, last_parent = tmp.popitem()
-                    return content
-                elif len(tmp) == 0:
-                    return None
+            # Search into parent folder (if already deep)
+            if folder:
+                folder_query = folder_query\
+                    .filter(
+                        Content.parent_id == folder.content_id,
+                    )
+            else:
+                folder_query = folder_query \
+                    .filter(Content.parent_id == None)
 
-            for content, parent_content in tmp.items():
-                if not parent_content:
-                    return content
+            # Get thirst corresponding folder
+            folder = folder_query \
+                .order_by(Content.revision_id.desc()) \
+                .one()
 
-            return None
-        return res[0]
+        return folder
+
+    def filter_query_for_content_label_as_path(
+            self,
+            query: Query,
+            content_label_as_file: str,
+            is_case_sensitive: bool = False,
+    ) -> Query:
+        """
+        Apply normalised filters to found Content corresponding as given label.
+        :param query: query to modify
+        :param content_label_as_file: label in this
+        FILE version, use Content.get_label_as_file().
+        :param is_case_sensitive: Take care about case or not
+        :return: modified query
+        """
+        file_name, file_extension = os.path.splitext(content_label_as_file)
+
+        label_filter = Content.label == content_label_as_file
+        file_name_filter = Content.label == file_name
+        file_extension_filter = Content.file_extension == file_extension
+
+        if not is_case_sensitive:
+            label_filter = func.lower(Content.label) == \
+                           func.lower(content_label_as_file)
+            file_name_filter = func.lower(Content.label) == \
+                               func.lower(file_name)
+            file_extension_filter = func.lower(Content.file_extension) == \
+                                    func.lower(file_extension)
+
+        return query.filter(or_(
+            and_(
+                Content.type == ContentType.File,
+                file_name_filter,
+                file_extension_filter,
+            ),
+            and_(
+                Content.type == ContentType.Thread,
+                file_name_filter,
+                file_extension_filter,
+            ),
+            and_(
+                Content.type == ContentType.Page,
+                file_name_filter,
+                file_extension_filter,
+            ),
+            and_(
+                Content.type == ContentType.Folder,
+                label_filter,
+            ),
+        ))
 
     def get_all(self, parent_id: int=None, content_type: str=ContentType.Any, workspace: Workspace=None) -> [Content]:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
 
         return resultset.all()
 
+    def get_children(self, parent_id: int, content_types: list, workspace: Workspace=None) -> [Content]:
+        """
+        Return parent_id childs of given content_types
+        :param parent_id: parent id
+        :param content_types: list of types
+        :param workspace: workspace filter
+        :return: list of content
+        """
+        resultset = self._base_query(workspace)
+        resultset = resultset.filter(Content.type.in_(content_types))
+
+        if parent_id:
+            resultset = resultset.filter(Content.parent_id==parent_id)
+        if parent_id is False:
+            resultset = resultset.filter(Content.parent_id == None)
+
+        return resultset.all()
+
     # TODO find an other name to filter on is_deleted / is_archived
     def get_all_with_filter(self, parent_id: int=None, content_type: str=ContentType.Any, workspace: Workspace=None) -> [Content]:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
             .filter(~ContentRevisionRO.revision_id.in_(read_revision_ids)) \
             .subquery()
 
-        not_read_content_ids = DBSession.query(
-            distinct(not_read_revisions.c.content_id)).all()
+        not_read_content_ids_query = DBSession.query(
+            distinct(not_read_revisions.c.content_id)
+        )
+        not_read_content_ids = list(map(
+            itemgetter(0),
+            not_read_content_ids_query,
+        ))
 
         not_read_contents = self._base_query(workspace) \
             .filter(Content.content_id.in_(not_read_content_ids)) \
             )
         )
         return query.one()
+
+    def generate_folder_label(
+            self,
+            workspace: Workspace,
+            parent: Content=None,
+    ) -> str:
+        """
+        Generate a folder label
+        :param workspace: Future folder workspace
+        :param parent: Parent of foture folder (can be None)
+        :return: Generated folder name
+        """
+        query = self._base_query(workspace=workspace)\
+            .filter(Content.label.ilike('{0}%'.format(
+                _('New folder'),
+            )))
+        if parent:
+            query = query.filter(Content.parent == parent)
+
+        return _('New folder {0}').format(
+            query.count() + 1,
+        )

tracim/tracim/lib/daemons.py

 import signal
 
 import collections
-import transaction
 
 from radicale import Application as RadicaleApplication
 from radicale import HTTPServer as BaseRadicaleHTTPServer
 from radicale import HTTPSServer as BaseRadicaleHTTPSServer
 from radicale import RequestHandler as RadicaleRequestHandler
 from radicale import config as radicale_config
+from rq import Connection as RQConnection
+from rq import Worker as BaseRQWorker
+from redis import Redis
 
 from tracim.lib.base import logger
 from tracim.lib.exceptions import AlreadyRunningDaemon
     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:
         """
         raise NotImplementedError()
 
 
+class MailSenderDaemon(Daemon):
+    # NOTE: use *args and **kwargs because parent __init__ use strange
+    # * parameter
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.worker = None  # type: RQWorker
+
+    def append_thread_callback(self, callback: collections.Callable) -> None:
+        logger.warning('MailSenderDaemon not implement append_thread_callback')
+        pass
+
+    def stop(self) -> None:
+        self.worker.request_stop('TRACIM STOP', None)
+
+    def run(self) -> None:
+        from tracim.config.app_cfg import CFG
+        cfg = CFG.get_instance()
+
+        with RQConnection(Redis(
+            host=cfg.EMAIL_SENDER_REDIS_HOST,
+            port=cfg.EMAIL_SENDER_REDIS_PORT,
+            db=cfg.EMAIL_SENDER_REDIS_DB,
+        )):
+            self.worker = RQWorker(['mail_sender'])
+            self.worker.work()
+
+
+class RQWorker(BaseRQWorker):
+    def _install_signal_handlers(self):
+        # TODO BS 20170126: RQ WWorker is designed to work in main thread
+        # So we have to disable these signals (we implement server stop in
+        # MailSenderDaemon.stop method). When bug
+        # https://github.com/tracim/tracim/issues/166 will be fixed, ensure
+        # This worker terminate correctly.
+        pass
+
+
 class RadicaleHTTPSServer(TracimSocketServerMixin, BaseRadicaleHTTPSServer):
     pass
 
         radicale_config.set('storage', 'filesystem_folder', fs_path)
 
         radicale_config.set('server', 'realm', realm_message)
+        radicale_config.set(
+            'server',
+            'base_prefix',
+            cfg.RADICALE_CLIENT_BASE_URL_PREFIX,
+        )
 
         try:
             radicale_config.add_section('headers')
 from inspect import isfunction
 import traceback
 
+from wsgidav.server.cherrypy import wsgiserver
+from wsgidav.server.cherrypy.wsgiserver.wsgiserver3 import CherryPyWSGIServer
+
 DEFAULT_CONFIG_FILE = "wsgidav.conf"
 PYTHON_VERSION = "%s.%s.%s" % (sys.version_info[0], sys.version_info[1], sys.version_info[2])
 
             print(
                 "WARNING: Could not import lxml: using xml instead (slower). Consider installing lxml from http://codespeak.net/lxml/.")
         from wsgidav.dir_browser import WsgiDavDirBrowser
-        from wsgidav.debug_filter import WsgiDavDebugFilter
         from tracim.lib.webdav.tracim_http_authenticator import TracimHTTPAuthenticator
         from wsgidav.error_printer import ErrorPrinter
+        from tracim.lib.webdav.utils import TracimWsgiDavDebugFilter
 
-        config['middleware_stack'] = [ WsgiDavDirBrowser, TracimHTTPAuthenticator, ErrorPrinter, WsgiDavDebugFilter ]
+        config['middleware_stack'] = [
+            WsgiDavDirBrowser,
+            TracimHTTPAuthenticator,
+            ErrorPrinter,
+            TracimWsgiDavDebugFilter,
+        ]
 
         config['provider_mapping'] = {
             config['root_path']: Provider(
-                show_archived=config['show_archived'],
-                show_deleted=config['show_deleted'],
-                show_history=config['show_history'],
+                # TODO: Test to Re enabme archived and deleted
+                show_archived=False,  # config['show_archived'],
+                show_deleted=False,  # config['show_deleted'],
+                show_history=False,  # config['show_history'],
                 manage_locks=config['manager_locks']
             )
         }
         app = WsgiDAVApp(self.config)
 
         # Try running WsgiDAV inside the following external servers:
-        self._runCherryPy(app, self.config, "cherrypy-bundled")
+        self._runCherryPy(app, self.config)
 
-    def _runCherryPy(self, app, config, mode):
-        """Run WsgiDAV using cherrypy.wsgiserver, if CherryPy is installed."""
-        assert mode in ("cherrypy", "cherrypy-bundled")
-
-        try:
-            from wsgidav.server.cherrypy import wsgiserver
-
-            version = "WsgiDAV/%s %s Python/%s" % (
-                __version__,
-                wsgiserver.CherryPyWSGIServer.version,
-                PYTHON_VERSION)
+    def _runCherryPy(self, app, config):
+        version = "WsgiDAV/%s %s Python/%s" % (
+            __version__,
+            wsgiserver.CherryPyWSGIServer.version,
+            PYTHON_VERSION
+        )
 
-            wsgiserver.CherryPyWSGIServer.version = version
+        wsgiserver.CherryPyWSGIServer.version = version
 
-            protocol = "http"
+        protocol = "http"
 
-            if config["verbose"] >= 1:
-                print("Running %s" % version)
-                print("Listening on %s://%s:%s ..." % (protocol, config["host"], config["port"]))
-            self._server = wsgiserver.CherryPyWSGIServer(
-                (config["host"], config["port"]),
-                app,
-                server_name=version,
-            )
+        if config["verbose"] >= 1:
+            print("Running %s" % version)
+            print("Listening on %s://%s:%s ..." % (protocol, config["host"], config["port"]))
+        self._server = CherryPyWSGIServer(
+            (config["host"], config["port"]),
+            app,
+            server_name=version,
+        )
 
-            self._server.start()
-        except ImportError as e:
-            if config["verbose"] >= 1:
-                print("Could not import wsgiserver.CherryPyWSGIServer.")
-            return False
-        return True
+        self._server.start()
 
     def stop(self):
         self._server.stop()

tracim/tracim/lib/email.py

 # -*- coding: utf-8 -*-
-
-from email.mime.multipart import MIMEMultipart
 import smtplib
+from email.message import Message
+from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 
+import typing
 from mako.template import Template
-from tgext.asyncjob import asyncjob_perform
+from redis import Redis
+from rq import Queue
 from tg.i18n import ugettext as _
 
 from tracim.lib.base import logger
 from tracim.model import User
 
 
+def send_email_through(
+        send_callable: typing.Callable[[Message], None],
+        message: Message,
+) -> None:
+    """
+    Send mail encapsulation to send it in async or sync mode.
+    TODO BS 20170126: A global mail/sender management should be a good
+                      thing. Actually, this method is an fast solution.
+    :param send_callable: A callable who get message on first parameter
+    :param message: The message who have to be sent
+    """
+    from tracim.config.app_cfg import CFG
+    cfg = CFG.get_instance()
+
+    if cfg.EMAIL_PROCESSING_MODE == CFG.CST.SYNC:
+        send_callable(message)
+    elif cfg.EMAIL_PROCESSING_MODE == CFG.CST.ASYNC:
+        queue = Queue('mail_sender', connection=Redis(
+            host=cfg.EMAIL_SENDER_REDIS_HOST,
+            port=cfg.EMAIL_SENDER_REDIS_PORT,
+            db=cfg.EMAIL_SENDER_REDIS_DB,
+        ))
+        queue.enqueue(send_callable, message)
+    else:
+        raise NotImplementedError(
+            'Mail sender processing mode {} is not implemented'.format(
+                cfg.EMAIL_PROCESSING_MODE,
+            )
+        )
+
+
 class SmtpConfiguration(object):
     """
     Container class for SMTP configuration used in Tracim
             )
         message = MIMEMultipart('alternative')
         message['Subject'] = subject
-        message['From'] = self._global_config.EMAIL_NOTIFICATION_FROM
+        message['From'] = '{0} <{1}>'.format(
+            self._global_config.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL,
+            self._global_config.EMAIL_NOTIFICATION_FROM_EMAIL,
+        )
         message['To'] = user.email
 
         text_template_file_path = self._global_config.EMAIL_NOTIFICATION_CREATED_ACCOUNT_TEMPLATE_TEXT  # nopep8
         message.attach(part1)
         message.attach(part2)
 
-        asyncjob_perform(async_email_sender.send_mail, message)
-
-        # Note: The following action allow to close the SMTP connection.
-        # This will work only if the async jobs are done in the right order
-        asyncjob_perform(async_email_sender.disconnect)
+        send_email_through(async_email_sender.send_mail, message)
 
     def _render(self, mako_template_filepath: str, context: dict):
         """

tracim/tracim/lib/helpers.py

 
 import datetime
 
+import pytz
 import slugify
-from babel.dates import format_date, format_time
+from babel.dates import format_date
+from babel.dates import format_time
 from markupsafe import Markup
 
 import tg
+from tg import tmpl_context
 from tg.i18n import ugettext as _
 
 from tracim.lib import app_globals as plag
 from tracim.lib.content import ContentApi
 from tracim.lib.userworkspace import RoleApi
 from tracim.lib.workspace import WorkspaceApi
-from tracim.model import User
 
 from tracim.model.data import ContentStatus
 from tracim.model.data import Content
 from tracim.model.data import UserRoleInWorkspace
 from tracim.model.data import Workspace
 
+
+def get_with_timezone(
+        datetime_object: datetime.datetime,
+        to_timezone: str='',
+        default_from_timezone: str='UTC',
+) -> datetime.datetime:
+    """
+    Change timezone of a date
+    :param datetime_object: datetime to update
+    :param to_timezone: timezone name, if equal to '',
+    try to grap current user timezone. If no given timezone name and no
+    current user timezone, return original date time
+    :param default_from_timezone: datetime original timezone if datetime
+    object is naive
+    :return: datetime updated
+    """
+    # If no to_timezone, try to grab from current user
+    if not to_timezone and tmpl_context.current_user:
+        to_timezone = tmpl_context.current_user.timezone
+
+    # If no to_timezone, return original datetime
+    if not to_timezone:
+        return datetime_object
+
+    # If datetime_object have not timezone, set new from default_from_timezone
+    if not datetime_object.tzinfo:
+        from_tzinfo = pytz.timezone(default_from_timezone)
+        datetime_object = from_tzinfo.localize(datetime_object)
+
+    new_tzinfo = pytz.timezone(to_timezone)
+    return datetime_object.astimezone(new_tzinfo)
+
+
 def date_time_in_long_format(datetime_object, format=''):
 
     current_locale = tg.i18n.get_lang()[0]
   now = datetime.datetime.now()
   return now.strftime('%Y')
 
-def formatLongDateAndTime(datetime_object, format=''):
-    """ OBSOLETE
-    :param datetime_object:
-    :param format:
-    :return:
-    """
-    if not format:
-        format = plag.Globals.LONG_DATE_FORMAT
-    return datetime_object.strftime(format)
-
-
 
 def icon(icon_name, white=False):
     if (white):
     try:
         content_data = content_str.split(CST.TREEVIEW_MENU.ID_SEPARATOR)
         content_id = int(content_data[1])
-        content = ContentApi(tg.tmpl_context.current_user).get_one(content_id, ContentType.Any)
+        content = ContentApi(
+            tg.tmpl_context.current_user,
+            show_archived=True,
+            show_deleted=True,
+        ).get_one(content_id, ContentType.Any)
     except (IndexError, ValueError) as e:
         content = None
 

tracim/tracim/lib/integrity.py

+# -*- coding: utf-8 -*-
+import os
+
+from sqlalchemy import func
+from tg import tmpl_context
+from tg.render import render
+from tracim.lib.content import ContentApi
+from tracim.lib.workspace import UnsafeWorkspaceApi
+from tracim.model.data import Workspace
+from tracim.model.data import Content
+from tracim.model.serializers import DictLikeClass, Context, CTX
+
+
+class PathValidationManager(object):
+    def __init__(self, is_case_sensitive: bool=False):
+        """
+        :param is_case_sensitive: If True, consider name with different
+        case as different.
+        """
+        self._is_case_sensitive = is_case_sensitive
+        self._workspace_api = UnsafeWorkspaceApi(None)
+        self._content_api = ContentApi(None)
+
+    def workspace_label_is_free(self, workspace_name: str) -> bool:
+        """
+        :param workspace_name: Workspace name
+        :return: True if workspace is available
+        """
+        query = self._workspace_api.get_base_query()
+
+        label_filter = Workspace.label == workspace_name
+        if not self._is_case_sensitive:
+            label_filter = func.lower(Workspace.label) == \
+                           func.lower(workspace_name)
+
+        return not bool(query.filter(label_filter).count())
+
+    def content_label_is_free(
+            self,
+            content_label_as_file,
+            workspace: Workspace,
+            parent: Content=None,
+            exclude_content_id: int=None,
+    ) -> bool:
+        """
+        :param content_label_as_file:
+        :param workspace:
+        :param parent:
+        :return: True if content label is available
+        """
+        query = self._content_api.get_base_query(workspace)
+
+        if parent:
+            query = query.filter(Content.parent_id == parent.content_id)
+
+        if exclude_content_id:
+            query = query.filter(Content.content_id != exclude_content_id)
+
+        query = query.filter(Content.workspace_id == workspace.workspace_id)
+
+        return not \
+            bool(
+                self._content_api.filter_query_for_content_label_as_path(
+                    query=query,
+                    content_label_as_file=content_label_as_file,
+                    is_case_sensitive=self._is_case_sensitive,
+                ).count()
+            )
+
+    def validate_new_content(self, content: Content) -> bool:
+        """
+        :param content: Content with label to test
+        :return: True if content label is not in conflict with existing
+        resource
+        """
+        return self.content_label_is_free(
+            content_label_as_file=content.get_label_as_file(),
+            workspace=content.workspace,
+            parent=content.parent,
+            exclude_content_id=content.content_id,
+        )
+
+
+def render_invalid_integrity_chosen_path(invalid_label: str) -> str:
+    """
+    Return html page code of error about invalid label choice.
+    :param invalid_label: the invalid label
+    :return: html page code
+    """
+    user = tmpl_context.current_user
+    fake_api_content = DictLikeClass(
+        current_user=user,
+    )
+    fake_api = Context(CTX.USER).toDict(fake_api_content)
+
+    return render(
+        template_vars=dict(
+            invalid_label=invalid_label,
+            fake_api=fake_api,
+        ),
+        template_engine='mako',
+        template_name='tracim.templates.errors.label_invalid_path',
+    )

tracim/tracim/lib/notifications.py

 
 from mako.template import Template
 
-from tg.i18n import lazy_ugettext as l_
-from tg.i18n import ugettext as _
-
 from tracim.lib.base import logger
 from tracim.lib.email import SmtpConfiguration
+from tracim.lib.email import send_email_through
 from tracim.lib.email import EmailSender
 from tracim.lib.user import UserApi
 from tracim.lib.workspace import WorkspaceApi
-
+from tracim.lib.utils import lazy_ugettext as l_
 from tracim.model.serializers import Context
 from tracim.model.serializers import CTX
 from tracim.model.serializers import DictLikeClass
 from tracim.model.auth import User
 
 
-from tgext.asyncjob import asyncjob_perform
-
 class INotifier(object):
     """
     Interface for Notifier instances
 
 
 class DummyNotifier(INotifier):
+    send_count = 0
+
     def __init__(self, current_user: User=None):
         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 email-notification for update of content {}'.format(content.content_id))
 
 
                 # TODO - D.A - 2014-11-06
                 # This feature must be implemented in order to be able to scale to large communities
                 raise NotImplementedError('Sending emails through ASYNC mode is not working yet')
-                asyncjob_perform(EmailNotifier(self._smtp_config, global_config).notify_content_update, self._user.user_id, content.content_id)
             else:
                 logger.info(self, 'Sending email in SYNC mode')
                 EmailNotifier(self._smtp_config, global_config).notify_content_update(self._user.user_id, content.content_id)
         self._smtp_config = smtp_config
         self._global_config = global_config
 
+    def _get_sender(self, user: User=None) -> str:
+        """
+        Return sender string like "Bob Dylan
+            (via Tracim) <notification@mail.com>"
+        :param user: user to extract display name
+        :return: sender string
+        """
+        if user is None:
+            return '{0} <{1}>'.format(
+                self._global_config.EMAIL_NOTIFICATION_FROM_DEFAULT_LABEL,
+                self._global_config.EMAIL_NOTIFICATION_FROM_EMAIL,
+            )
+
+        # We add a suffix to email to prevent client like Thunderbird to
+        # display personal adressbook label.
+        email = self._global_config.EMAIL_NOTIFICATION_FROM_EMAIL
+        email_name, domain = email.split('@')
+        arranged_email = '{0}+{1}@{2}'.format(
+            email_name,
+            str(user.user_id),
+            domain,
+        )
+
+        return '{0} {1} <{2}>'.format(
+            user.display_name,
+            'via Tracim',
+            arranged_email,
+        )
 
     def notify_content_update(self, event_actor_id: int, event_content_id: int):
         """
             subject = self._global_config.EMAIL_NOTIFICATION_CONTENT_UPDATE_SUBJECT
             subject = subject.replace(EST.WEBSITE_TITLE, self._global_config.WEBSITE_TITLE.__str__())
             subject = subject.replace(EST.WORKSPACE_LABEL, main_content.workspace.label.__str__())
-            subject = subject.replace(EST.CONTENT_LABEL, main_content.label.__str__() if main_content.label else main_content.file_name.__str__())
+            subject = subject.replace(EST.CONTENT_LABEL, main_content.label.__str__())
             subject = subject.replace(EST.CONTENT_STATUS_LABEL, main_content.get_status().label.__str__())
 
             message = MIMEMultipart('alternative')
             message['Subject'] = subject
-            message['From'] = self._global_config.EMAIL_NOTIFICATION_FROM
+            message['From'] = self._get_sender(user)
             message['To'] = to_addr
 
             body_text = self._build_email_body(self._global_config.EMAIL_NOTIFICATION_CONTENT_UPDATE_TEMPLATE_TEXT, role, content, user)
             message.attach(part1)
             message.attach(part2)
 
-            message_str = message.as_string()
-            asyncjob_perform(async_email_sender.send_mail, message)
-            # s.send_message(message)
-
-        # Note: The following action allow to close the SMTP connection.
-        # This will work only if the async jobs are done in the right order
-        asyncjob_perform(async_email_sender.disconnect)
-
+            send_email_through(async_email_sender.send_mail, message)
 
     def _build_email_body(self, mako_template_filepath: str, role: UserRoleInWorkspace, content: Content, actor: User) -> str:
         """
 
         action = content.get_last_action().id
         if ActionDescription.COMMENT == action:
-            content_intro = _('<span id="content-intro-username">{}</span> added a comment:').format(actor.display_name)
+            content_intro = l_('<span id="content-intro-username">{}</span> added a comment:').format(actor.display_name)
             content_text = content.description
-            call_to_action_text = _('Answer')
+            call_to_action_text = l_('Answer')
 
         elif ActionDescription.CREATION == action:
 
             # Default values (if not overriden)
             content_text = content.description
-            call_to_action_text = _('View online')
+            call_to_action_text = l_('View online')
 
             if ContentType.Thread == content.type:
-                call_to_action_text = _('Answer')
-                content_intro = _('<span id="content-intro-username">{}</span> started a thread entitled:').format(actor.display_name)
+                call_to_action_text = l_('Answer')
+                content_intro = l_('<span id="content-intro-username">{}</span> started a thread entitled:').format(actor.display_name)
                 content_text = '<p id="content-body-intro">{}</p>'.format(content.label) + \
                                content.get_last_comment_from(actor).description
 
             elif ContentType.File == content.type:
-                content_intro = _('<span id="content-intro-username">{}</span> added a file entitled:').format(actor.display_name)
+                content_intro = l_('<span id="content-intro-username">{}</span> added a file entitled:').format(actor.display_name)
                 if content.description:
                     content_text = content.description
-                elif content.label:
-                    content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
                 else:
-                    content_text = '<span id="content-body-only-title">{}</span>'.format(content.file_name)
-
+                    content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
 
             elif ContentType.Page == content.type:
-                content_intro = _('<span id="content-intro-username">{}</span> added a page entitled:').format(actor.display_name)
+                content_intro = l_('<span id="content-intro-username">{}</span> added a page entitled:').format(actor.display_name)
                 content_text = '<span id="content-body-only-title">{}</span>'.format(content.label)
 
         elif ActionDescription.REVISION == action:
             content_text = content.description
-            call_to_action_text = _('View online')
+            call_to_action_text = l_('View online')
 
             if ContentType.File == content.type:
-                content_intro = _('<span id="content-intro-username">{}</span> uploaded a new revision.').format(actor.display_name)
+                content_intro = l_('<span id="content-intro-username">{}</span> uploaded a new revision.').format(actor.display_name)
                 content_text = ''
 
             elif ContentType.Page == content.type:
-                content_intro = _('<span id="content-intro-username">{}</span> updated this page.').format(actor.display_name)
+                content_intro = l_('<span id="content-intro-username">{}</span> updated this page.').format(actor.display_name)
                 previous_revision = content.get_previous_revision()
                 title_diff = ''
                 if previous_revision.label != content.label:
                     title_diff = htmldiff(previous_revision.label, content.label)
-                content_text = _('<p id="content-body-intro">Here is an overview of the changes:</p>')+ \
+                content_text = str(l_('<p id="content-body-intro">Here is an overview of the changes:</p>'))+ \
                     title_diff + \
                     htmldiff(previous_revision.description, content.description)
 
             elif ContentType.Thread == content.type:
-                content_intro = _('<span id="content-intro-username">{}</span> updated the thread description.').format(actor.display_name)
+                content_intro = l_('<span id="content-intro-username">{}</span> updated the thread description.').format(actor.display_name)
                 previous_revision = content.get_previous_revision()
                 title_diff = ''
                 if previous_revision.label != content.label:
                     title_diff = htmldiff(previous_revision.label, content.label)
-                content_text = _('<p id="content-body-intro">Here is an overview of the changes:</p>')+ \
+                content_text = str(l_('<p id="content-body-intro">Here is an overview of the changes:</p>'))+ \
                     title_diff + \
                     htmldiff(previous_revision.description, content.description)
 
             # elif ContentType.Thread == content.type:
-            #     content_intro = _('<span id="content-intro-username">{}</span> updated this page.').format(actor.display_name)
+            #     content_intro = l_('<span id="content-intro-username">{}</span> updated this page.').format(actor.display_name)
             #     previous_revision = content.get_previous_revision()
-            #     content_text = _('<p id="content-body-intro">Here is an overview of the changes:</p>')+ \
+            #     content_text = l_('<p id="content-body-intro">Here is an overview of the changes:</p>')+ \
             #         htmldiff(previous_revision.description, content.description)
 
         elif ActionDescription.EDITION == action:
-            call_to_action_text = _('View online')
+            call_to_action_text = l_('View online')
 
             if ContentType.File == content.type:
-                content_intro = _('<span id="content-intro-username">{}</span> updated the file description.').format(actor.display_name)
+                content_intro = l_('<span id="content-intro-username">{}</span> updated the file description.').format(actor.display_name)
                 content_text = '<p id="content-body-intro">{}</p>'.format(content.get_label()) + \
                     content.description
 
         from tracim.config.app_cfg import CFG
         body_content = template.render(
             base_url=self._global_config.WEBSITE_BASE_URL,
-            _=_,
+            _=l_,
             h=helpers,
             user_display_name=role.user.display_name,
             user_role_label=role.role_as_label(),

tracim/tracim/lib/predicates.py

 from tg import abort
 from tg import request
 from tg import tmpl_context
-from tg.i18n import lazy_ugettext as l_
+from tracim.lib.utils import lazy_ugettext as l_
 from tg.i18n import ugettext as _
 from tg.predicates import Predicate
 

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/radicale/storage.py

     def __init__(self, path: str, principal: bool=False):
         super().__init__(path, principal)
         self._replacing = False  # See ``replacing`` context manager
-        self._manager = CalendarManager(None)
+        self._manager = CalendarManager(Auth.current_user)
 
     @contextmanager
     def replacing(self):

tracim/tracim/lib/user.py

 # -*- coding: utf-8 -*-
+import threading
 
-__author__ = 'damien'
-
+import cherrypy
+import transaction
 import tg
+import typing as typing
 
 from tracim.model.auth import User
-
-from tracim.model import auth as pbma
 from tracim.model import DBSession
-import tracim.model.data as pmd
+
+CURRENT_USER_WEB = 'WEB'
+CURRENT_USER_WSGIDAV = 'WSGIDAV'
+
 
 class UserApi(object):
 
     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):
+    def update(
+            self,
+            user: User,
+            name: str=None,
+            email: str=None,
+            do_save=True,
+            timezone: str='',
+    ):
         if name is not None:
             user.display_name = name
 
         if email is not None:
             user.email = email
 
+        user.timezone = timezone
+
         if do_save:
             self.save(user)
 
-        if self._user and user.user_id==self._user.user_id:
+        if email and self._user and user.user_id==self._user.user_id:
             # this is required for the session to keep on being up-to-date
             tg.request.identity['repoze.who.userid'] = email
+            tg.auth_force_login(email)
 
     def user_with_email_exists(self, email: str):
         try:
     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
 
-class UserStaticApi(object):
+        created_user.ensure_auth_token()
 
-    @classmethod
-    def get_current_user(cls) -> User:
+        # 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 CurrentUserGetterInterface(object):
+    def get_current_user(self) -> typing.Union[None, User]:
+        raise NotImplementedError()
+
+
+class BaseCurrentUserGetter(CurrentUserGetterInterface):
+    def __init__(self) -> None:
+        self.api = UserApi(None)
+
+
+class WebCurrentUserGetter(BaseCurrentUserGetter):
+    def get_current_user(self) -> typing.Union[None, User]:
         # HACK - D.A. - 2015-09-02
         # In tests, the tg.request.identity may not be set
         # (this is a buggy case, but for now this is how the software is;)
-        if tg.request != None:
+        if tg.request is not None:
             if hasattr(tg.request, 'identity'):
-                if tg.request.identity != None:
-                    return cls._get_user(tg.request.identity['repoze.who.userid'])
+                if tg.request.identity is not None:
+                    return self.api.get_one_by_email(
+                        tg.request.identity['repoze.who.userid'],
+                    )
+
+        return None
+
+
+class WsgidavCurrentUserGetter(BaseCurrentUserGetter):
+    def get_current_user(self) -> typing.Union[None, User]:
+        if hasattr(cherrypy.request, 'current_user_email'):
+            return self.api.get_one_by_email(
+                cherrypy.request.current_user_email,
+            )
 
         return None
 
+
+class CurrentUserGetterApi(object):
+    thread_local = threading.local()
+    matches = {
+        CURRENT_USER_WEB: WebCurrentUserGetter,
+        CURRENT_USER_WSGIDAV: WsgidavCurrentUserGetter,
+    }
+    default = CURRENT_USER_WEB
+
     @classmethod
-    def _get_user(cls, email) -> User:
-        """
-        Do not use directly in your code.
-        :param email:
-        :return:
-        """
-        return pbma.User.by_email_address(email)
+    def get_current_user(cls) -> User:
+        try:
+            return cls.thread_local.getter.get_current_user()
+        except AttributeError:
+            return cls.factory(cls.default).get_current_user()
+
+    @classmethod
+    def set_thread_local_getter(cls, name) -> None:
+        if not hasattr(cls.thread_local, 'getter'):
+            cls.thread_local.getter = cls.factory(name)
+
+    @classmethod
+    def factory(cls, name: str) -> CurrentUserGetterInterface:
+        return cls.matches[name]()

tracim/tracim/lib/utils.py

 # -*- coding: utf-8 -*-
-
+import os
 import time
 import signal
 
+from tg import config
+from tg import require
+from tg import response
+from tg.controllers.util import abort
+from tg.appwrappers.errorpage import ErrorPageApplicationWrapper \
+    as BaseErrorPageApplicationWrapper
+from tg.i18n import ugettext
+from tg.support.registry import StackedObjectProxy
+from tg.util import LazyString as BaseLazyString
+from tg.util import lazify
+
 from tracim.lib.base import logger
+from webob import Response
+from webob.exc import WSGIHTTPException
+
 
 def exec_time_monitor():
     def decorator_func(func):
     raise NotImplementedError()
 
 
-def add_signal_handler(signal_id, handler, execute_before=True) -> None:
+def add_signal_handler(signal_id, handler) -> 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 _handler(*args, **kwargs):
+        handler()
+        signal.signal(signal_id, signal.SIG_DFL)
+        os.kill(os.getpid(), signal_id)  # Rethrow signal
+
+    signal.signal(signal_id, _handler)
+
+
+class APIWSGIHTTPException(WSGIHTTPException):
+    def json_formatter(self, body, status, title, environ):
+        if self.comment:
+            msg = '{0}: {1}'.format(title, self.comment)
+        else:
+            msg = title
+        return {
+            'code': self.code,
+            'msg': msg,
+            'detail': self.detail,
+        }
+
+
+class api_require(require):
+    def default_denial_handler(self, reason):
+        # Add code here if we have to hide 401 errors (security reasons)
+
+        abort(response.status_int, reason, passthrough='json')
+
+
+class ErrorPageApplicationWrapper(BaseErrorPageApplicationWrapper):
+    # Define here response code to manage in APIWSGIHTTPException
+    api_managed_error_codes = [
+        400, 401, 403, 404,
+    ]
+
+    def __call__(self, controller, environ, context) -> Response:
+        # We only do ou work when it's /api request
+        # TODO BS 20161025: Look at PATH_INFO is not smart, find better way
+        if not environ['PATH_INFO'].startswith('/api'):
+            return super().__call__(controller, environ, context)
+
+        try:
+            resp = self.next_handler(controller, environ, context)
+        except:  # We catch all exception to display an 500 error json response
+            if config.get('debug', False):  # But in debug, we want to see it
+                raise
+            return APIWSGIHTTPException()
+
+        # We manage only specified errors codes
+        if resp.status_int not in self.api_managed_error_codes:
+            return resp
+
+        # Rewrite error in api format
+        return APIWSGIHTTPException(
+            code=resp.status_int,
+            detail=resp.detail,
+            title=resp.title,
+            comment=resp.comment,
+        )
+
+
+def get_valid_header_file_name(file_name: str) -> str:
+    """
+    :param file_name: file name to test
+    :return: Return given string if compatible to header encoding, or
+    download.ext if not.
+    """
+    try:
+        file_name.encode('iso-8859-1')
+        return file_name
+    except UnicodeEncodeError:
+        split_file_name = file_name.split('.')
+        if len(split_file_name) > 1:  # If > 1 so file have extension
+            return 'download.{0}'.format(split_file_name[-1])
+        return 'download'
 
-    def call_callback(*args, **kwargs):
-        if not execute_before and callable(previous_handler):
-            previous_handler(*args, **kwargs)
 
-        handler(*args, **kwargs)
+def str_as_bool(string: str) -> bool:
+    if string == '0':
+        return False
+    return bool(string)
 
-        if execute_before and callable(previous_handler):
-            previous_handler(*args, **kwargs)
 
-    signal.signal(signal_id, call_callback)
+class LazyString(BaseLazyString):
+    pass
+
+
+def _lazy_ugettext(text: str):
+    """
+    This function test if application context is available
+    :param text: String to traduce
+    :return: lazyfied string or string
+    """
+    try:
+        # Test if context is available,
+        # cf. https://github.com/tracim/tracim/issues/173
+        context = StackedObjectProxy(name="context")
+        context.translator
+        return ugettext(text)
+    except TypeError:
+        return text
+
+lazy_ugettext = lazify(_lazy_ugettext)

tracim/tracim/lib/webdav/__init__.py

                 self._file_stream.read()
             )
 
-            self._api.save(self._content, ActionDescription.EDITION)
+            self._api.save(self._content, ActionDescription.REVISION)

tracim/tracim/lib/webdav/design.py

 from tracim.model.data import ContentType
 from tracim.model import data
 
+# FIXME: fix temporaire ...
+style = """
+.title {
+	background:#F5F5F5;
+	padding-right:15px;
+	padding-left:15px;
+	padding-top:10px;
+	border-bottom:1px solid #CCCCCC;
+	overflow:auto;
+} .title h1 { margin-top:0; }
+
+.content {
+	padding: 15px;
+}
+
+#left{ padding:0; }
+
+#right {
+	background:#F5F5F5;
+	border-left:1px solid #CCCCCC;
+	border-bottom: 1px solid #CCCCCC;
+	padding-top:15px;
+}
+@media (max-width: 1200px) {
+	#right {
+		border-top:1px solid #CCCCCC;
+		border-left: none;
+		border-bottom: none;
+	}
+}
+
+body { overflow:auto; }
+
+.btn {
+	text-align: left;
+}
+
+.table tbody tr .my-align {
+	vertical-align:middle;
+}
+
+.title-icon {
+	font-size:2.5em;
+	float:left;
+	margin-right:10px;
+}
+.title.page, .title-icon.page { color:#00CC00; }
+.title.thread, .title-icon.thread { color:#428BCA; }
+
+/* ****************************** */
+.description-icon {
+	color:#999;
+	font-size:3em;
+}
+
+.description {
+	border-left: 5px solid #999;
+	padding-left: 10px;
+	margin-left: 10px;
+	margin-bottom:10px;
+}
+
+.description-text {
+	display:block;
+	overflow:hidden;
+	color:#999;
+}
+
+.comment-row:nth-child(2n) {
+	background-color:#F5F5F5;
+}
+
+.comment-row:nth-child(2n+1) {
+	background-color:#FFF;
+}
+
+.comment-icon {
+	color:#CCC;
+	font-size:3em;
+	display:inline-block;
+	margin-right: 10px;
+	float:left;
+}
+
+.comment-content {
+	display:block;
+	overflow:hidden;
+}
+
+.comment, .comment-revision {
+	padding:10px;
+	border-top: 1px solid #999;
+}
+
+.comment-revision-icon {
+	color:#777;
+	margin-right: 10px;
+}
+
+.title-text {
+	display: inline-block;
+}
+"""
+
+_LABELS = {
+    'archiving': 'Item archived',
+    'content-comment': 'Item commented',
+    'creation': 'Item created',
+    'deletion': 'Item deleted',
+    'edition': 'item modified',
+    'revision': 'New revision',
+    'status-update': 'New status',
+    'unarchiving': 'Item unarchived',
+    'undeletion': 'Item undeleted',
+    'move': 'Item moved',
+    'comment': 'Comment'
+}
+
+
 def create_readable_date(created, delta_from_datetime: datetime = None):
     if not delta_from_datetime:
         delta_from_datetime = datetime.now()
     return aff
 
 def designPage(content: data.Content, content_revision: data.ContentRevisionRO) -> str:
-    f = open('tracim/lib/webdav/style.css', 'r')
-    style = f.read()
-    f.close()
-
     hist = content.get_history()
     histHTML = '<table class="table table-striped table-hover">'
     for event in hist:
         if isinstance(event, VirtualEvent):
             date = event.create_readable_date()
-            _LABELS = {
-                'archiving': 'Item archived',
-                'content-comment': 'Item commented',
-                'creation': 'Item created',
-                'deletion': 'Item deleted',
-                'edition': 'item modified',
-                'revision': 'New revision',
-                'status-update': 'New status',
-                'unarchiving': 'Item unarchived',
-                'undeletion': 'Item undeleted',
-                'move': 'Item moved'
-            }
-
             label = _LABELS[event.type.id]
 
             histHTML += '''
                        label,
                        date,
                        event.owner.display_name,
-                       '<i class="fa fa-caret-left"></i> shown' if event.id == content_revision.revision_id else '''<span><a class="revision-link" href="/.history/%s/(%s - %s) %s.html">(View revision)</a></span>''' % (
-                       content.label, event.id, event.type.id, event.ref_object.label) if event.type.id in ['revision', 'creation', 'edition'] else '')
-
+                       # NOTE: (WABDAV_HIST_DEL_DISABLED) Disabled for beta 1.0
+                       '<i class="fa fa-caret-left"></i> shown'  if event.id == content_revision.revision_id else '' # '''<span><a class="revision-link" href="/.history/%s/(%s - %s) %s.html">(View revision)</a></span>''' % (
+                       # content.label, event.id, event.type.id, event.ref_object.label) if event.type.id in ['revision', 'creation', 'edition'] else '')
+                   )
     histHTML += '</table>'
 
     file = '''
             </div>
             <div class="pull-right">
                 <div class="btn-group btn-group-vertical">
-                    <a class="btn btn-default">
-                        <i class="fa fa-external-link"></i> View in tracim</a>
-                    </a>
+                    <!-- NOTE: Not omplemented yet, don't display not working link
+                     <a class="btn btn-default">
+                         <i class="fa fa-external-link"></i> View in tracim</a>
+                     </a>-->
                 </div>
             </div>
         </div>
             file_location = file_location.replace(/\/[^/]*$/, '')
             file_location = file_location.replace(/\/.history\/[^/]*$/, '')
 
-            $('.revision-link').each(function() {
-                $(this).attr('href', file_location + $(this).attr('href'))
-            });
+            // NOTE: (WABDAV_HIST_DEL_DISABLED) Disabled for beta 1.0
+            // $('.revision-link').each(function() {
+            //    $(this).attr('href', file_location + $(this).attr('href'))
+            // });
         }
     </script>
 </body>
     return file
 
 def designThread(content: data.Content, content_revision: data.ContentRevisionRO, comments) -> str:
-        f = open('tracim/lib/webdav/style.css', 'r')
-        style = f.read()
-        f.close()
-
         hist = content.get_history()
 
         allT = []
                     participants[t.owner.display_name][0] += 1
             else:
                 if isinstance(t, VirtualEvent) and t.type.id != 'comment':
-                    _LABELS = {
-                        'archiving': 'Item archived',
-                        'content-comment': 'Item commented',
-                        'creation': 'Item created',
-                        'deletion': 'Item deleted',
-                        'edition': 'item modified',
-                        'revision': 'New revision',
-                        'status-update': 'New status',
-                        'unarchiving': 'Item unarchived',
-                        'undeletion': 'Item undeleted',
-                        'move': 'Item moved',
-                        'comment' : 'hmmm'
-                    }
-
                     label = _LABELS[t.type.id]
 
                     disc += '''
                            t.owner.display_name,
                            t.create_readable_date(),
                            label,
-                            '<i class="fa fa-caret-left"></i> shown' if t.id == content_revision.revision_id else '''<span><a class="revision-link" href="/.history/%s/%s-%s">(View revision)</a></span>''' % (
-                               content.label,
-                               t.id,
-                               t.ref_object.label) if t.type.id in ['revision', 'creation', 'edition'] else '')
+                            # NOTE: (WABDAV_HIST_DEL_DISABLED) Disabled for beta 1.0
+                            '<i class="fa fa-caret-left"></i> shown' if t.id == content_revision.revision_id else '' # else '''<span><a class="revision-link" href="/.history/%s/%s-%s">(View revision)</a></span>''' % (
+                               # content.label,
+                               # t.id,
+                               # t.ref_object.label) if t.type.id in ['revision', 'creation', 'edition'] else '')
+                           )
 
         page = '''
 <html>
             </div>
             <div class="pull-right">
                 <div class="btn-group btn-group-vertical">
+                    <!-- NOTE: Not omplemented yet, don't display not working link
                     <a class="btn btn-default" onclick="hide_elements()">
-                        <i id="hideshow" class="fa fa-eye-slash"></i> <span id="hideshowtxt" >Hide history</span></a>
-                    </a>
+                       <i id="hideshow" class="fa fa-eye-slash"></i> <span id="hideshowtxt" >Hide history</span></a>
+                    </a>-->
                     <a class="btn btn-default">
                         <i class="fa fa-external-link"></i> View in tracim</a>
                     </a>
             file_location = file_location.replace(/\/[^/]*$/, '')
             file_location = file_location.replace(/\/.history\/[^/]*$/, '')
 
-            $('.revision-link').each(function() {
-                $(this).attr('href', file_location + $(this).attr('href'))
-            });
+            // NOTE: (WABDAV_HIST_DEL_DISABLED) Disabled for beta 1.0
+            // $('.revision-link').each(function() {
+            //     $(this).attr('href', file_location + $(this).attr('href'))
+            // });
         }
 
         function hide_elements() {

tracim/tracim/lib/webdav/sql_dav_provider.py

 # coding: utf8
 
 import re
-from os.path import basename, dirname, normpath
+from os.path import basename, dirname
+from sqlalchemy.orm.exc import NoResultFound
+from tracim.lib.webdav.utils import transform_to_bdd
 
 from wsgidav.dav_provider import DAVProvider
 from wsgidav.lock_manager import LockManager
 from tracim.lib.workspace import WorkspaceApi
 from tracim.model.data import Content, Workspace
 from tracim.model.data import ContentType
+from tracim.lib.webdav.utils import normpath
 
 
 class Provider(DAVProvider):
 
         content_api = ContentApi(
             user,
-            show_archived=self._show_archive,
-            show_deleted=self._show_delete
+            show_archived=False,  # self._show_archive,
+            show_deleted=False,  # self._show_delete
         )
 
         content = self.get_content_from_path(
         if parent_path == root_path or workspace is None:
             return workspace is not None
 
-        content_api = ContentApi(user, show_archived=True, show_deleted=True)
+        # TODO bastien: Arnaud avait mis a True, verif le comportement
+        # lorsque l'on explore les dossiers archive et deleted
+        content_api = ContentApi(user, show_archived=False, show_deleted=False)
 
         revision_id = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) ([^/].+)$', path)
 
         path = self.reduce_path(path)
         parent_path = dirname(path)
 
-        blbl = parent_path.replace('/'+workspace.label, '')
+        relative_parents_path = parent_path[len(workspace.label)+1:]
+        parents = relative_parents_path.split('/')
 
-        parents = blbl.split('/')
-
-        parents.remove('')
-        parents = [self.transform_to_bdd(x) for x in parents]
+        try:
+            parents.remove('')
+        except ValueError:
+            pass
+        parents = [transform_to_bdd(x) for x in parents]
 
         try:
-            return content_api.get_one_by_label_and_parent_label(
-                self.transform_to_bdd(basename(path)),
-                parents,
-                workspace
+            return content_api.get_one_by_label_and_parent_labels(
+                content_label=transform_to_bdd(basename(path)),
+                content_parent_labels=parents,
+                workspace=workspace,
             )
-        except:
+        except NoResultFound:
             return None
 
     def get_content_from_revision(self, revision: ContentRevisionRO, api: ContentApi) -> Content:
         try:
             return api.get_one(revision.content_id, ContentType.Any)
-        except:
+        except NoResultFound:
             return None
 
     def get_parent_from_path(self, path, api: ContentApi, workspace) -> Content:
 
     def get_workspace_from_path(self, path: str, api: WorkspaceApi) -> Workspace:
         try:
-            return api.get_one_by_label(self.transform_to_bdd(path.split('/')[1]))
-        except:
+            return api.get_one_by_label(transform_to_bdd(path.split('/')[1]))
+        except NoResultFound:
             return None
-
-    def transform_to_display(self, string):
-        """
-        As characters that Windows does not support may have been inserted through Tracim in names, before displaying
-        information we update path so that all these forbidden characters are replaced with similar shape character
-        that are allowed so that the user isn't trouble and isn't limited in his naming choice
-        """
-        _TO_DISPLAY = {
-            '/':'⧸',
-            '\\': '⧹',
-            ':': '∶',
-            '*': '∗',
-            '?': 'ʔ',
-            '"': 'ʺ',
-            '<': '❮',
-            '>': '❯',
-            '|': '∣'
-        }
-
-        for key, value in _TO_DISPLAY.items():
-            string = string.replace(key, value)
-
-        return string
-
-    def transform_to_bdd(self, string):
-        """
-        Called before sending request to the database to recover the right names
-        """
-        _TO_BDD = {
-            '⧸': '/',
-            '⧹': '\\',
-            '∶': ':',
-            '∗': '*',
-            'ʔ': '?',
-            'ʺ': '"',
-            '❮': '<',
-            '❯': '>',
-            '∣': '|'
-        }
-
-        for key, value in _TO_BDD.items():
-            string = string.replace(key, value)
-
-        return string

tracim/tracim/lib/webdav/sql_resources.py

 # coding: utf8
+import logging
+
+import os
+
 import transaction
 import re
 from datetime import datetime
 from time import mktime
-from os.path import normpath, dirname, basename
-import mimetypes
+from os.path import dirname, basename
 
 from tracim.lib.content import ContentApi
 from tracim.lib.user import UserApi
 from tracim.lib.webdav import HistoryType
 from tracim.lib.webdav import FakeFileStream
+from tracim.lib.webdav.utils import transform_to_display
+from tracim.lib.webdav.utils import transform_to_bdd
 from tracim.lib.workspace import WorkspaceApi
 from tracim.model import data, new_revision
 from tracim.model.data import Content, ActionDescription
 from wsgidav.dav_error import DAVError, HTTP_FORBIDDEN
 from wsgidav.dav_provider import DAVCollection, DAVNonCollection
 from wsgidav.dav_provider import _DAVResource
+from tracim.lib.webdav.utils import normpath
 
 from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
 
+logger = logging.getLogger()
+
+
 class ManageActions(object):
     """
     This object is used to encapsulate all Deletion/Archiving related method as to not duplicate too much code
         try:
             # When undeleting/unarchiving we except a content with the new name to not exist, thus if we
             # don't get an error and the database request send back a result, we stop the action
-            self.content_api.get_one_by_label_and_parent(self._new_name, self.content.parent, self.content.workspace)
+            self.content_api.get_one_by_label_and_parent(self._new_name, self.content.parent)
             raise DAVError(HTTP_FORBIDDEN)
         except NoResultFound:
             with new_revision(self.content):
         Will create the new name, either by adding '- deleted the [date]' after the name when archiving/deleting or
         removing this string when undeleting/unarchiving
         """
-        new_name = self.content.get_label()
+        new_name = self.content.get_label_as_file()
         extension = ''
 
         # if the content has no label, the last .ext is important
         # thus we want to rename a file from 'file.txt' to 'file - deleted... .txt' and not 'file.txt - deleted...'
         is_file_name = self.content.label == ''
         if is_file_name:
-            extension = re.search(r'(\.[^.]+)$', new_name).group(0)
+            search = re.search(r'(\.[^.]+)$', new_name)
+            if search:
+                extension = search.group(0)
             new_name = re.sub(r'(\.[^.]+)$', '', new_name)
 
         if self._type in [ActionDescription.ARCHIVING, ActionDescription.DELETION]:
         """
         try:
             workspace = self.workspace_api.get_one_by_label(label)
-            workspace_path = '%s%s%s' % (self.path, '' if self.path == '/' else '/', self.provider.transform_to_display(workspace.label))
+            workspace_path = '%s%s%s' % (self.path, '' if self.path == '/' else '/', transform_to_display(workspace.label))
 
             return Workspace(workspace_path, self.environ, workspace)
         except AttributeError:
         self.workspace_api.save(new_workspace)
 
         workspace_path = '%s%s%s' % (
-        self.path, '' if self.path == '/' else '/', self.provider.transform_to_display(new_workspace.label))
+        self.path, '' if self.path == '/' else '/', transform_to_display(new_workspace.label))
 
         transaction.commit()
         return Workspace(workspace_path, self.environ, new_workspace)
             # the purpose is to display .history only if there's at least one content's type that has a history
             if content.type != ContentType.Folder:
                 self._file_count += 1
-            retlist.append(content.get_label())
+            retlist.append(content.get_label_as_file())
 
         return retlist
 
     def getMember(self, content_label: str) -> _DAVResource:
 
         return self.provider.getResourceInst(
-            '%s/%s' % (self.path, self.provider.transform_to_display(content_label)),
+            '%s/%s' % (self.path, transform_to_display(content_label)),
             self.environ
         )
 
         if '/.deleted/' in self.path or '/.archived/' in self.path:
             raise DAVError(HTTP_FORBIDDEN)
 
+        content = None
+
+        # Note: To prevent bugs, check here again if resource already exist
+        path = os.path.join(self.path, file_name)
+        resource = self.provider.getResourceInst(path, self.environ)
+        if resource:
+            content = resource.content
+
         return FakeFileStream(
             file_name=file_name,
             content_api=self.content_api,
             workspace=self.workspace,
-            content=None,
+            content=content,
             parent=self.content,
             path=self.path + '/' + file_name
         )
 
         transaction.commit()
 
-        return Folder('%s/%s' % (self.path, self.provider.transform_to_display(label)),
+        return Folder('%s/%s' % (self.path, transform_to_display(label)),
                       self.environ, folder,
                       self.workspace)
 
         children = self.content_api.get_all(False, ContentType.Any, self.workspace)
 
         for content in children:
-            content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
+            content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
 
             if content.type == ContentType.Folder:
                 members.append(Folder(content_path, self.environ, self.workspace, content))
         return mktime(self.content.created.timetuple())
 
     def getDisplayName(self) -> str:
-        return self.provider.transform_to_display(self.content.get_label())
+        return transform_to_display(self.content.get_label_as_file())
 
     def getLastModified(self) -> float:
         return mktime(self.content.updated.timetuple())
 
         with new_revision(self.content):
             if basename(destpath) != self.getDisplayName():
-                self.content_api.update_content(self.content, self.provider.transform_to_bdd(basename(destpath)))
+                self.content_api.update_content(self.content, transform_to_bdd(basename(destpath)))
                 self.content_api.save(self.content)
             else:
                 if workspace.workspace_id == self.content.workspace.workspace_id:
         )
 
         for content in visible_children:
-            content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
+            content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
 
-            if content.type == ContentType.Folder:
-                members.append(Folder(content_path, self.environ, self.workspace, content))
-            elif content.type == ContentType.File:
-                self._file_count += 1
-                members.append(File(content_path, self.environ, content))
-            else:
-                self._file_count += 1
-                members.append(OtherFile(content_path, self.environ, content))
+            try:
+                if content.type == ContentType.Folder:
+                    members.append(Folder(content_path, self.environ, self.workspace, content))
+                elif content.type == ContentType.File:
+                    self._file_count += 1
+                    members.append(File(content_path, self.environ, content))
+                else:
+                    self._file_count += 1
+                    members.append(OtherFile(content_path, self.environ, content))
+            except Exception as exc:
+                logger.exception(
+                    'Unable to construct member {}'.format(
+                        content_path,
+                    ),
+                    exc_info=True,
+                )
 
         if self._file_count > 0 and self.provider.show_history():
             members.append(
         )
 
         return HistoryFileFolder(
-            path='%s/%s' % (self.path, content.get_label()),
+            path='%s/%s' % (self.path, content.get_label_as_file()),
             environ=self.environ,
             content=content)
 
                 self._is_deleted and content.is_deleted or
                 not (content.is_archived or self._is_archived or content.is_deleted or self._is_deleted))\
                     and content.type != ContentType.Folder:
-                ret.append(content.get_label())
+                ret.append(content.get_label_as_file())
 
         return ret
 
         for content in children:
             if content.is_archived == self._is_archived and content.is_deleted == self._is_deleted:
                 members.append(HistoryFileFolder(
-                    path='%s/%s' % (self.path, content.get_label()),
+                    path='%s/%s' % (self.path, content.get_label_as_file()),
                     environ=self.environ,
                     content=content))
 
         )
 
         return self.provider.getResourceInst(
-            path='%s/%s' % (self.path, self.provider.transform_to_display(content.get_label())),
+            path='%s/%s' % (self.path, transform_to_display(content.get_label_as_file())),
             environ=self.environ
             )
 
 
         for content in children:
             if content.is_deleted:
-                retlist.append(content.get_label())
+                retlist.append(content.get_label_as_file())
 
                 if content.type != ContentType.Folder:
                     self._file_count += 1
 
         for content in children:
             if content.is_deleted:
-                content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
+                content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
 
                 if content.type == ContentType.Folder:
                     members.append(Folder(content_path, self.environ, self.workspace, content))
         )
 
         return self.provider.getResourceInst(
-            path=self.path + '/' + self.provider.transform_to_display(content.get_label()),
+            path=self.path + '/' + transform_to_display(content.get_label_as_file()),
             environ=self.environ
         )
 
 
         for content in self.content_api.get_all_with_filter(
                 self.content if self.content is None else self.content.id, ContentType.Any):
-            retlist.append(content.get_label())
+            retlist.append(content.get_label_as_file())
 
             if content.type != ContentType.Folder:
                 self._file_count += 1
 
         for content in children:
             if content.is_archived:
-                content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
+                content_path = '%s/%s' % (self.path, transform_to_display(content.get_label_as_file()))
 
                 if content.type == ContentType.Folder:
                     members.append(Folder(content_path, self.environ, self.workspace, content))
         return "<DAVCollection: HistoryFileFolder (%s)" % self.content.file_name
 
     def getDisplayName(self) -> str:
-        return self.content.get_label()
+        return self.content.get_label_as_file()
 
     def createCollection(self, name):
         raise DAVError(HTTP_FORBIDDEN)
 
         if self.content.type == ContentType.File:
             return HistoryFile(
-                path='%s%s' % (left_side, self.provider.transform_to_display(revision.file_name)),
+                path='%s%s' % (left_side, transform_to_display(revision.file_name)),
                 environ=self.environ,
                 content=self.content,
                 content_revision=revision)
         else:
             return HistoryOtherFile(
-                path='%s%s' % (left_side, self.provider.transform_to_display(revision.get_label())),
+                path='%s%s' % (left_side, transform_to_display(revision.get_label_as_file())),
                 environ=self.environ,
                 content=self.content,
                 content_revision=revision)
 
             if self.content.type == ContentType.File:
                 members.append(HistoryFile(
-                    path='%s%s' % (left_side, self.provider.transform_to_display(content.file_name)),
+                    path='%s%s' % (left_side, transform_to_display(content.file_name)),
                     environ=self.environ,
                     content=self.content,
                     content_revision=content)
                 )
             else:
                 members.append(HistoryOtherFile(
-                    path='%s%s' % (left_side, self.provider.transform_to_display(content.file_name)),
+                    path='%s%s' % (left_side, transform_to_display(content.file_name)),
                     environ=self.environ,
                     content=self.content,
                     content_revision=content)
         # but i wasn't able to set this property so you'll have to look into it >.>
         # self.setPropertyValue('Win32FileAttributes', '00000021')
 
-    def getPreferredPath(self):
-        fix_txt = '.txt' if self.getContentType() == 'text/plain' else mimetypes.guess_extension(self.getContentType())
-
-        if self.content.label == '' or self.path.endswith(fix_txt):
-            return self.path
-        else:
-            return self.path + fix_txt
-
     def __repr__(self) -> str:
         return "<DAVNonCollection: File (%d)>" % self.content.revision_id
 
         return mktime(self.content.created.timetuple())
 
     def getDisplayName(self) -> str:
-        return self.content.get_label()
+        return self.content.file_name
 
     def getLastModified(self) -> float:
         return mktime(self.content.updated.timetuple())
         return FakeFileStream(
             content=self.content,
             content_api=self.content_api,
-            file_name=self.content.get_label(),
+            file_name=self.content.get_label_as_file(),
             workspace=self.content.workspace,
             path=self.path
         )
 
     def move_file(self, destpath):
 
-        workspace = self.provider.get_workspace_from_path(
-            normpath(destpath),
-            WorkspaceApi(self.user)
-        )
-
-        parent = self.provider.get_parent_from_path(
-            normpath(destpath),
-            self.content_api,
-            workspace
-        )
-
+        workspace = self.content.workspace
+        parent = self.content.parent
 
         with new_revision(self.content):
             if basename(destpath) != self.getDisplayName():
-                self.content_api.update_content(self.content, re.sub('\.[^\.]+$', '', self.provider.transform_to_bdd(basename(destpath))))
+                new_given_file_name = transform_to_bdd(basename(destpath))
+                new_file_name, new_file_extension = \
+                    os.path.splitext(new_given_file_name)
+
+                self.content_api.update_content(
+                    self.content,
+                    new_file_name,
+                )
+                self.content.file_extension = new_file_extension
                 self.content_api.save(self.content)
             else:
+                workspace_api = WorkspaceApi(self.user)
+                content_api = ContentApi(self.user)
+
+                destination_workspace = self.provider.get_workspace_from_path(
+                    destpath,
+                    workspace_api,
+                )
+
+                destination_parent = self.provider.get_parent_from_path(
+                    destpath,
+                    content_api,
+                    workspace,
+                )
+
                 self.content_api.move(
                     item=self.content,
-                    new_parent=parent,
+                    new_parent=destination_parent,
                     must_stay_in_same_workspace=False,
-                    new_workspace=workspace
+                    new_workspace=destination_workspace
                 )
 
         transaction.commit()
 
     def getDisplayName(self) -> str:
         left_side = '(%d - %s) ' % (self.content_revision.revision_id, self.content_revision.revision_type)
-        return '%s%s' % (left_side, self.provider.transform_to_display(self.content_revision.file_name))
+        return '%s%s' % (left_side, transform_to_display(self.content_revision.file_name))
 
     def getContent(self):
         filestream = compat.BytesIO()
             self.path += '.html'
 
     def getDisplayName(self) -> str:
-        return self.content.get_label()
+        return self.content.get_label_as_file()
 
     def getPreferredPath(self):
         return self.path
 
     def getDisplayName(self) -> str:
         left_side = '(%d - %s) ' % (self.content_revision.revision_id, self.content_revision.revision_type)
-        return '%s%s' % (left_side, self.provider.transform_to_display(self.content_revision.get_label()))
+        return '%s%s' % (left_side, transform_to_display(self.content_revision.get_label_as_file()))
 
     def getContent(self):
         filestream = compat.BytesIO()

tracim/tracim/lib/webdav/tracim_http_authenticator.py

+import os
+import re
+
 from wsgidav.http_authenticator import HTTPAuthenticator
 from wsgidav import util
-import re
+import cherrypy
+
+from tracim.lib.user import CurrentUserGetterApi
+from tracim.lib.user import CURRENT_USER_WSGIDAV
 
 _logger = util.getModuleLogger(__name__, True)
 HOTFIX_WINXP_AcceptRootShareLogin = True
 
         environ["http_authenticator.realm"] = realmname
         environ["http_authenticator.username"] = req_username
+
+        # Set request current user email to be able to recognise him later
+        cherrypy.request.current_user_email = req_username
+        CurrentUserGetterApi.set_thread_local_getter(CURRENT_USER_WSGIDAV)
+
         return self._application(environ, start_response)
 
     def tracim_compute_digest_response(self, left_digest_response_hash, method, uri, nonce, cnonce, qop, nc):

tracim/tracim/lib/webdav/utils.py

+# -*- coding: utf-8 -*-
+from xml.etree import ElementTree
+
+import os
+import sys
+import threading
+import time
+from datetime import datetime
+
+import yaml
+from os.path import normpath as base_normpath
+from wsgidav import util
+from wsgidav import compat
+from wsgidav.middleware import BaseMiddleware
+
+
+def transform_to_display(string: str) -> str:
+    """
+    As characters that Windows does not support may have been inserted
+    through Tracim in names, before displaying information we update path
+    so that all these forbidden characters are replaced with similar
+    shape character that are allowed so that the user isn't trouble and
+    isn't limited in his naming choice
+    """
+    _TO_DISPLAY = {
+        '/': '⧸',
+        '\\': '⧹',
+        ':': '∶',
+        '*': '∗',
+        '?': 'ʔ',
+        '"': 'ʺ',
+        '<': '❮',
+        '>': '❯',
+        '|': '∣'
+    }
+
+    for key, value in _TO_DISPLAY.items():
+        string = string.replace(key, value)
+
+    return string
+
+
+def transform_to_bdd(string: str) -> str:
+    """
+    Called before sending request to the database to recover the right names
+    """
+    _TO_BDD = {
+        '⧸': '/',
+        '⧹': '\\',
+        '∶': ':',
+        '∗': '*',
+        'ʔ': '?',
+        'ʺ': '"',
+        '❮': '<',
+        '❯': '>',
+        '∣': '|'
+    }
+
+    for key, value in _TO_BDD.items():
+        string = string.replace(key, value)
+
+    return string
+
+
+class TracimWsgiDavDebugFilter(BaseMiddleware):
+    """
+    COPY PASTE OF wsgidav.debug_filter.WsgiDavDebugFilter
+    WITH ADD OF DUMP RESPONSE & REQUEST
+    """
+    def __init__(self, application, config):
+        self._application = application
+        self._config = config
+        #        self.out = sys.stderr
+        self.out = sys.stdout
+        self.passedLitmus = {}
+        # These methods boost verbose=2 to verbose=3
+        self.debug_methods = config.get("debug_methods", [])
+        # Litmus tests containing these string boost verbose=2 to verbose=3
+        self.debug_litmus = config.get("debug_litmus", [])
+        # Exit server, as soon as this litmus test has finished
+        self.break_after_litmus = [
+            #                                   "locks: 15",
+        ]
+
+        self.last_request_time = '__NOT_SET__'
+
+        # We disable request content dump for moment
+        # if self._config.get('dump_requests'):
+        #     # Monkey patching
+        #     old_parseXmlBody = util.parseXmlBody
+        #     def new_parseXmlBody(environ, allowEmpty=False):
+        #         xml = old_parseXmlBody(environ, allowEmpty)
+        #         self._dump_request(environ, xml)
+        #         return xml
+        #     util.parseXmlBody = new_parseXmlBody
+
+    def __call__(self, environ, start_response):
+        """"""
+        #        srvcfg = environ["wsgidav.config"]
+        verbose = self._config.get("verbose", 2)
+        self.last_request_time = '{0}_{1}'.format(
+            datetime.utcnow().strftime('%Y-%m-%d_%H-%M-%S'),
+            int(round(time.time() * 1000)),
+        )
+
+        method = environ["REQUEST_METHOD"]
+
+        debugBreak = False
+        dumpRequest = False
+        dumpResponse = False
+
+        if verbose >= 3 or self._config.get("dump_requests"):
+            dumpRequest = dumpResponse = True
+
+        # Process URL commands
+        if "dump_storage" in environ.get("QUERY_STRING"):
+            dav = environ.get("wsgidav.provider")
+            if dav.lockManager:
+                dav.lockManager._dump()
+            if dav.propManager:
+                dav.propManager._dump()
+
+        # Turn on max. debugging for selected litmus tests
+        litmusTag = environ.get("HTTP_X_LITMUS",
+                                environ.get("HTTP_X_LITMUS_SECOND"))
+        if litmusTag and verbose >= 2:
+            print("----\nRunning litmus test '%s'..." % litmusTag,
+                  file=self.out)
+            for litmusSubstring in self.debug_litmus:
+                if litmusSubstring in litmusTag:
+                    verbose = 3
+                    debugBreak = True
+                    dumpRequest = True
+                    dumpResponse = True
+                    break
+            for litmusSubstring in self.break_after_litmus:
+                if litmusSubstring in self.passedLitmus and litmusSubstring not in litmusTag:
+                    print(" *** break after litmus %s" % litmusTag,
+                          file=self.out)
+                    sys.exit(-1)
+                if litmusSubstring in litmusTag:
+                    self.passedLitmus[litmusSubstring] = True
+
+        # Turn on max. debugging for selected request methods
+        if verbose >= 2 and method in self.debug_methods:
+            verbose = 3
+            debugBreak = True
+            dumpRequest = True
+            dumpResponse = True
+
+        # Set debug options to environment
+        environ["wsgidav.verbose"] = verbose
+        #        environ["wsgidav.debug_methods"] = self.debug_methods
+        environ["wsgidav.debug_break"] = debugBreak
+        environ["wsgidav.dump_request_body"] = dumpRequest
+        environ["wsgidav.dump_response_body"] = dumpResponse
+
+        # Dump request headers
+        if dumpRequest:
+            print("<%s> --- %s Request ---" % (
+            threading.currentThread().ident, method), file=self.out)
+            for k, v in environ.items():
+                if k == k.upper():
+                    print("%20s: '%s'" % (k, v), file=self.out)
+            print("\n", file=self.out)
+            self._dump_request(environ, xml=None)
+
+        # Intercept start_response
+        #
+        sub_app_start_response = util.SubAppStartResponse()
+
+        nbytes = 0
+        first_yield = True
+        app_iter = self._application(environ, sub_app_start_response)
+
+        for v in app_iter:
+            # Start response (the first time)
+            if first_yield:
+                # Success!
+                start_response(sub_app_start_response.status,
+                               sub_app_start_response.response_headers,
+                               sub_app_start_response.exc_info)
+
+            # Dump response headers
+            if first_yield and dumpResponse:
+                print("<%s> --- %s Response(%s): ---" % (
+                threading.currentThread().ident,
+                method,
+                sub_app_start_response.status),
+                      file=self.out)
+                headersdict = dict(sub_app_start_response.response_headers)
+                for envitem in headersdict.keys():
+                    print("%s: %s" % (envitem, repr(headersdict[envitem])),
+                          file=self.out)
+                print("", file=self.out)
+
+            # Check, if response is a binary string, otherwise we probably have
+            # calculated a wrong content-length
+            assert compat.is_bytes(v), v
+
+            # Dump response body
+            drb = environ.get("wsgidav.dump_response_body")
+            if compat.is_basestring(drb):
+                # Middleware provided a formatted body representation
+                print(drb, file=self.out)
+            elif drb is True:
+                # Else dump what we get, (except for long GET responses)
+                if method == "GET":
+                    if first_yield:
+                        print(v[:50], "...", file=self.out)
+                elif len(v) > 0:
+                    print(v, file=self.out)
+
+            if dumpResponse:
+                self._dump_response(sub_app_start_response, drb)
+
+            drb = environ["wsgidav.dump_response_body"] = None
+
+            nbytes += len(v)
+            first_yield = False
+            yield v
+        if hasattr(app_iter, "close"):
+            app_iter.close()
+
+        # Start response (if it hasn't been done yet)
+        if first_yield:
+            # Success!
+            start_response(sub_app_start_response.status,
+                           sub_app_start_response.response_headers,
+                           sub_app_start_response.exc_info)
+
+        if dumpResponse:
+            print("\n<%s> --- End of %s Response (%i bytes) ---" % (
+            threading.currentThread().ident, method, nbytes), file=self.out)
+        return
+
+    def _dump_response(self, sub_app_start_response, drb):
+        dump_to_path = self._config.get(
+            'dump_requests_path',
+            '/tmp/wsgidav_dumps',
+        )
+        os.makedirs(dump_to_path, exist_ok=True)
+        dump_file = '{0}/{1}_RESPONSE_{2}.yml'.format(
+            dump_to_path,
+            self.last_request_time,
+            sub_app_start_response.status[0:3],
+        )
+        with open(dump_file, 'w+') as f:
+            dump_content = dict()
+            headers = {}
+            for header_tuple in sub_app_start_response.response_headers:
+                headers[header_tuple[0]] = header_tuple[1]
+            dump_content['headers'] = headers
+            if isinstance(drb, str):
+                dump_content['content'] = drb.replace('PROPFIND XML response body:\n', '')
+
+            f.write(yaml.dump(dump_content, default_flow_style=False))
+
+    def _dump_request(self, environ, xml):
+        dump_to_path = self._config.get(
+            'dump_requests_path',
+            '/tmp/wsgidav_dumps',
+        )
+        os.makedirs(dump_to_path, exist_ok=True)
+        dump_file = '{0}/{1}_REQUEST_{2}.yml'.format(
+            dump_to_path,
+            self.last_request_time,
+            environ['REQUEST_METHOD'],
+        )
+        with open(dump_file, 'w+') as f:
+            dump_content = dict()
+            dump_content['path'] = environ.get('PATH_INFO', '')
+            dump_content['Authorization'] = environ.get('HTTP_AUTHORIZATION', '')
+            if xml:
+                dump_content['content'] = ElementTree.tostring(xml, 'utf-8')
+
+            f.write(yaml.dump(dump_content, default_flow_style=False))
+
+
+def normpath(path):
+    if path == b'':
+        path = b'/'
+    elif path == '':
+        path = '/'
+    return base_normpath(path)

tracim/tracim/lib/workspace.py

 # -*- coding: utf-8 -*-
+import transaction
 
-__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
+from sqlalchemy.orm import Query
+from tg.i18n import ugettext as _
 
 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):
 
     def __init__(self, current_user: User):
         self._user = current_user
 
+    def _base_query_without_roles(self):
+        return DBSession.query(Workspace).filter(Workspace.is_deleted==False)
+
     def _base_query(self):
         if self._user.profile.id>=Group.TIM_ADMIN:
-            return DBSession.query(Workspace).filter(Workspace.is_deleted==False)
+            return self._base_query_without_roles()
 
         return DBSession.query(Workspace).\
             join(Workspace.roles).\
             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:
+        if not label:
+            label = self.generate_label()
+
         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,
+            )
+
+    def get_base_query(self) -> Query:
+        return self._base_query()
+
+    def generate_label(self) -> str:
+        """
+        :return: Generated workspace label
+        """
+        query = self._base_query_without_roles() \
+            .filter(Workspace.label.ilike('{0}%'.format(
+                _('Workspace'),
+            )))
+
+        return _('Workspace {}').format(
+            query.count() + 1,
+        )
+
 
 class UnsafeWorkspaceApi(WorkspaceApi):
     def _base_query(self):

tracim/tracim/model/__init__.py

 
     @classmethod
     def remove_from_updatable(cls, revision: 'ContentRevisionRO') -> None:
-        cls._updatable_revisions.remove(revision)
+        if revision in cls._updatable_revisions:
+            cls._updatable_revisions.remove(revision)
 
     @classmethod
     def is_updatable(cls, revision: 'ContentRevisionRO') -> bool:
 
 # 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
 
 def init_model(engine):
     """Call me before using any of the tables or classes in the model."""
-    DBSession.configure(bind=engine)
+    if not DBSession.registry.has():  # Prevent a SQLAlchemy warning
+        DBSession.configure(bind=engine)
 
     # If you are using reflection to introspect your database and create
     # table objects for you, your tables must be defined and mapped inside

tracim/tracim/model/auth.py

 from datetime import datetime
 import time
 from hashlib import sha256
-from slugify import slugify
 from sqlalchemy.ext.hybrid import hybrid_property
-from tg.i18n import lazy_ugettext as l_
+from tracim.lib.utils import lazy_ugettext as l_
 from hashlib import md5
 
 __all__ = ['User', 'Group', 'Permission']
     group_id = Column(Integer, Sequence('seq__groups__group_id'), autoincrement=True, primary_key=True)
     group_name = Column(Unicode(16), unique=True, nullable=False)
     display_name = Column(Unicode(255))
-    created = Column(DateTime, default=datetime.now)
+    created = Column(DateTime, default=datetime.utcnow)
 
     users = relationship('User', secondary=user_group_table, backref='groups')
 
     email = Column(Unicode(255), unique=True, nullable=False)
     display_name = Column(Unicode(255))
     _password = Column('password', Unicode(128))
-    created = Column(DateTime, default=datetime.now)
+    created = Column(DateTime, default=datetime.utcnow)
     is_active = Column(Boolean, default=True, nullable=False)
     imported_from = Column(Unicode(32), nullable=True)
+    timezone = Column(Unicode(255), nullable=False, server_default='')
     _webdav_left_digest_response_hash = Column('webdav_left_digest_response_hash', Unicode(128))
     auth_token = Column(Unicode(255))
     auth_token_created = Column(DateTime)
                                                descriptor=property(_get_hash_digest,
                                                                     _set_hash_digest))
 
+    def update_webdav_digest_auth(self, password) -> None:
+        self.webdav_left_digest_response_hash \
+            = '{username}:/:{password}'.format(
+                username=self.email,
+                password=password,
+            )
+
+
     def validate_password(self, password):
         """
         Check the password against existing credentials.
         validity_seconds = CFG.get_instance().USER_AUTH_TOKEN_VALIDITY
 
         if not self.auth_token or not self.auth_token_created:
-            self.auth_token = uuid.uuid4()
+            self.auth_token = str(uuid.uuid4())
             self.auth_token_created = datetime.utcnow()
             DBSession.flush()
             return

tracim/tracim/model/data.py

 
 import datetime as datetime_root
 import json
+import os
 from datetime import datetime
 
 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.types import LargeBinary
 from sqlalchemy.types import Text
 from sqlalchemy.types import Unicode
-from tg.i18n import lazy_ugettext as l_, ugettext as _
 
+from tracim.lib.utils import lazy_ugettext as l_
 from tracim.lib.exception import ContentRevisionUpdateError
 from tracim.model import DeclarativeBase, RevisionsIntegrity
 from tracim.model.auth import User
     revisions = relationship("ContentRevisionRO")
 
     @hybrid_property
-    def contents(self):
+    def contents(self) -> ['Content']:
         # Return a list of unique revisions parent content
-        return list(set([revision.node for revision in self.revisions]))
+        contents = []
+        for revision in self.revisions:
+            # TODO BS 20161209: This ``revision.node.workspace`` make a lot
+            # of SQL queries !
+            if revision.node.workspace == self and revision.node not in contents:
+                contents.append(revision.node)
+
+        return contents
 
     @property
     def calendar_url(self) -> str:
         # @see Content.get_allowed_content_types()
         return [ContentType('folder')]
 
-    def get_valid_children(self, content_types: list=None):
+    def get_valid_children(
+            self,
+            content_types: list=None,
+            show_deleted: bool=False,
+            show_archived: bool=False,
+    ):
         for child in self.contents:
             # we search only direct children
             if not child.parent \
-                    and not child.is_deleted \
-                    and not child.is_archived:
+                    and (show_deleted or not child.is_deleted) \
+                    and (show_archived or not child.is_archived):
                 if not content_types or child.type in content_types:
                     yield child
 
 
     label = Column(Unicode(1024), unique=False, nullable=False)
     description = Column(Text(), unique=False, nullable=False, default='')
-    file_name = Column(Unicode(255),  unique=False, nullable=False, default='')
+    file_extension = Column(
+        Unicode(255),
+        unique=False,
+        nullable=False,
+        server_default='',
+    )
     file_mimetype = Column(Unicode(255),  unique=False, nullable=False, default='')
     file_content = deferred(Column(LargeBinary(), unique=False, nullable=True))
     properties = Column('properties', Text(), unique=False, nullable=False, default='')
 
     """ List of column copied when make a new revision from another """
     _cloned_columns = (
-        'content_id', 'created', 'description', 'file_content', 'file_mimetype', 'file_name', 'is_archived',
-        'is_deleted', 'label', 'node', 'owner', 'owner_id', 'parent', 'parent_id', 'properties', 'revision_type',
-        'status', 'type', 'updated', 'workspace', 'workspace_id', 'is_temporary',
+        'content_id',
+        'created',
+        'description',
+        'file_content',
+        'file_mimetype',
+        'file_extension',
+        'is_archived',
+        'is_deleted',
+        'label',
+        'node',
+        'owner',
+        'owner_id',
+        'parent',
+        'parent_id',
+        'properties',
+        'revision_type',
+        'status',
+        'type',
+        'updated',
+        'workspace',
+        'workspace_id',
+        'is_temporary',
     )
 
     # Read by must be used like this:
             RevisionReadStatus(user=k, view_datetime=v)
     )
 
+    @property
+    def file_name(self):
+        return '{0}{1}'.format(
+            self.label,
+            self.file_extension,
+        )
+
     @classmethod
     def new_from(cls, revision: 'ContentRevisionRO') -> 'ContentRevisionRO':
         """
             column_value = getattr(revision, column_name)
             setattr(new_rev, column_name, column_value)
 
-        new_rev.updated = datetime.now()
+        new_rev.updated = datetime.utcnow()
 
         return new_rev
 
         return ContentStatus(self.status)
 
     def get_label(self) -> str:
-        return self.label if self.label else self.file_name if self.file_name else ''
+        return self.label or self.file_name or ''
 
     def get_last_action(self) -> ActionDescription:
         return ActionDescription(self.revision_type)
 
         return False
 
+    def get_label_as_file(self):
+        file_extension = self.file_extension or ''
+
+        if self.type == ContentType.Thread:
+            file_extension = '.html'
+        elif self.type == ContentType.Page:
+            file_extension = '.html'
+
+        return '{0}{1}'.format(
+            self.label,
+            file_extension,
+        )
+
+
 Index('idx__content_revisions__owner_id', ContentRevisionRO.owner_id)
 Index('idx__content_revisions__parent_id', ContentRevisionRO.parent_id)
 
 
     @hybrid_property
     def file_name(self) -> str:
-        return self.revision.file_name
+        return '{0}{1}'.format(
+            self.revision.label,
+            self.revision.file_extension,
+        )
 
     @file_name.setter
     def file_name(self, value: str) -> None:
-        self.revision.file_name = value
+        file_name, file_extension = os.path.splitext(value)
+        if not self.revision.label:
+            self.revision.label = file_name
+        self.revision.file_extension = file_extension
 
     @file_name.expression
     def file_name(cls) -> InstrumentedAttribute:
-        return ContentRevisionRO.file_name
+        return ContentRevisionRO.file_name + ContentRevisionRO.file_extension
+
+    @hybrid_property
+    def file_extension(self) -> str:
+        return self.revision.file_extension
+
+    @file_extension.setter
+    def file_extension(self, value: str) -> None:
+        self.revision.file_extension = value
+
+    @file_extension.expression
+    def file_extension(cls) -> InstrumentedAttribute:
+        return ContentRevisionRO.file_extension
 
     @hybrid_property
     def file_mimetype(self) -> str:
     def revision(self) -> ContentRevisionRO:
         return self.get_current_revision()
 
+    @property
+    def is_editable(self) -> bool:
+        return not self.is_archived and not self.is_deleted
+
     def get_current_revision(self) -> ContentRevisionRO:
         if not self.revisions:
             return self.new_revision()
         self._properties = json.dumps(properties_struct)
         ContentChecker.check_properties(self)
 
+    @property
+    def clean_revisions(self):
+        """
+        This property return revisions with really only one of each revisions:
+        Actually, .revisions list give duplicated last revision,
+        see https://github.com/tracim/tracim/issues/126
+        :return: list of revisions
+        """
+        return list(set(self.revisions))
+
     def created_as_delta(self, delta_from_datetime:datetime=None):
         if not delta_from_datetime:
-            delta_from_datetime = datetime.now()
+            delta_from_datetime = datetime.utcnow()
 
         return format_timedelta(delta_from_datetime - self.created,
                                 locale=tg.i18n.get_lang()[0])
     def datetime_as_delta(self, datetime_object,
                           delta_from_datetime:datetime=None):
         if not delta_from_datetime:
-            delta_from_datetime = datetime.now()
+            delta_from_datetime = datetime.utcnow()
         return format_timedelta(delta_from_datetime - datetime_object,
                                 locale=tg.i18n.get_lang()[0])
 
         return child_nb
 
     def get_label(self):
-        return self.label if self.label else self.file_name if self.file_name else ''
+        return self.label or self.file_name or ''
+
+    def get_label_as_file(self) -> str:
+        """
+        :return: Return content label in file representation context
+        """
+        return self.revision.get_label_as_file()
 
     def get_status(self) -> ContentStatus:
         return ContentStatus(self.status, self.type.__str__())
         return last_comment
 
     def get_previous_revision(self) -> 'ContentRevisionRO':
-        rev_ids = [revision.revision_id for revision in self.revisions]
+        rev_ids = [revision.revision_id for revision in self.clean_revisions]
         rev_ids.sort()
 
         if len(rev_ids)>=2:
             revision_rev_id = rev_ids[-2]
 
-            for revision in self.revisions:
+            for revision in self.clean_revisions:
                 if revision.revision_id == revision_rev_id:
                     return revision
 
         events = []
         for comment in self.get_comments():
             events.append(VirtualEvent.create_from_content(comment))
-        for revision in self.revisions:
+        for revision in self.clean_revisions:
             events.append(VirtualEvent.create_from_content_revision(revision))
 
         sorted_events = sorted(events,
 
     def created_as_delta(self, delta_from_datetime:datetime=None):
         if not delta_from_datetime:
-            delta_from_datetime = datetime.now()
+            delta_from_datetime = datetime.utcnow()
         return format_timedelta(delta_from_datetime - self.created,
                                 locale=tg.i18n.get_lang()[0])
 
         aff = ''
 
         if not delta_from_datetime:
-            delta_from_datetime = datetime.now()
+            delta_from_datetime = datetime.utcnow()
 
         delta = delta_from_datetime - self.created
         

tracim/tracim/model/serializers.py

 # -*- coding: utf-8 -*-
+import cherrypy
+import os
+
 import types
 
 from bs4 import BeautifulSoup
 from tg.i18n import ugettext as _
 from tg.util import LazyString
 from tracim.lib.base import logger
-from tracim.lib.user import UserStaticApi
-from tracim.lib.utils import exec_time_monitor
+from tracim.lib.user import CurrentUserGetterApi
 from tracim.model.auth import Profile
 from tracim.model.auth import User
 from tracim.model.data import BreadcrumbItem, ActionDescription
     USER = 'USER'
     USERS = 'USERS'
     WORKSPACE = 'WORKSPACE'
+    API_WORKSPACE = 'API_WORKSPACE'
+    API_CALENDAR_WORKSPACE = 'API_CALENDAR_WORKSPACE'
+    API_CALENDAR_USER = 'API_CALENDAR_USER'
 
 
 class DictLikeClass(dict):
         self.context_string = context_string
         self._current_user = current_user  # Allow to define the current user if any
         if not current_user:
-            self._current_user = UserStaticApi.get_current_user()
+            self._current_user = CurrentUserGetterApi.get_current_user()
 
         self._base_url = base_url # real root url like http://mydomain.com:8080
 
     def url(self, base_url='/', params=None, qualified=False) -> str:
-        url = tg.url(base_url, params)
+        # HACK (REF WSGIDAV.CONTEXT.TG.URL) This is a temporary hack who
+        # permit to know we are in WSGIDAV context.
+        if not hasattr(cherrypy.request, 'current_user_email'):
+            url = tg.url(base_url, params)
+        else:
+            url = base_url
 
         if self._base_url:
             url = '{}{}'.format(self._base_url, url)
 def serialize_version_for_page_or_file(version: ContentRevisionRO, context: Context):
     return DictLikeClass(
         id = version.revision_id,
-        label = version.label if version.label else version.file_name,
+        label = version.label,
         owner = context.toDict(version.owner),
         created = version.created,
-        action = context.toDict(version.get_last_action())
+        action = context.toDict(version.get_last_action()),
     )
 
 
 
     result = DictLikeClass(
         id = content.content_id,
-        label = content.label if content.label else content.file_name,
+        label = content.label,
         icon = ContentType.get_icon(content.type),
         status = context.toDict(content.get_status()),
         folder = context.toDict(DictLikeClass(id = content.parent.content_id if content.parent else None)),
     if content.type==ContentType.File:
         result = DictLikeClass(
             id = content.content_id,
-            label = content.label if content.label else content.file_name,
+            label = content.label,
             status = context.toDict(content.get_status()),
             folder = Context(CTX.DEFAULT).toDict(content.parent)
         )
             revisions=context.toDict(sorted(content.revisions, key=lambda v: v.created, reverse=True)),
             selected_revision='latest' if content.revision_to_serialize<=0 else content.revision_to_serialize,
             history=Context(CTX.CONTENT_HISTORY).toDict(content.get_history()),
+            is_editable=content.is_editable,
+            is_deleted=content.is_deleted,
+            is_archived=content.is_archived,
             urls = context.toDict({
                 'mark_read': context.url(Content.format_path('/workspaces/{wid}/folders/{fid}/{ctype}s/{cid}/put_read', content)),
                 'mark_unread': context.url(Content.format_path('/workspaces/{wid}/folders/{fid}/{ctype}s/{cid}/put_unread', content))
         )
 
         if content.type==ContentType.File:
-            result.label = content.label if content.label else content.file_name
+            result.label = content.label
             result['file'] = DictLikeClass(
                 name = data_container.file_name,
                 size = len(data_container.file_content),
             comments = reversed(context.toDict(item.get_comments())),
             is_new=item.has_new_information_for(context.get_user()),
             history = Context(CTX.CONTENT_HISTORY).toDict(item.get_history()),
+            is_editable=item.is_editable,
+            is_deleted=item.is_deleted,
+            is_archived=item.is_archived,
             urls = context.toDict({
                 'mark_read': context.url(Content.format_path('/workspaces/{wid}/folders/{fid}/{ctype}s/{cid}/put_read', item)),
                 'mark_unread': context.url(Content.format_path('/workspaces/{wid}/folders/{fid}/{ctype}s/{cid}/put_unread', item))
                 all = page_nb_all,
                 open = page_nb_open,
             ),
-            content_nb = DictLikeClass(all = content_nb_all)
+            content_nb = DictLikeClass(all = content_nb_all),
+            is_editable=content.is_editable,
         )
 
     return result
                                     open=folder_nb_open),
             page_nb=DictLikeClass(all=page_nb_all,
                                   open=page_nb_open),
-            content_nb=DictLikeClass(all = content_nb_all)
+            content_nb=DictLikeClass(all = content_nb_all),
+            is_archived=content.is_archived,
+            is_deleted=content.is_deleted,
+            is_editable=content.is_editable,
         )
 
     elif content.type==ContentType.Page:
     last_activity_date = content.get_last_activity_date()
     last_activity_date_formatted = format_datetime(last_activity_date,
                                                    locale=tg.i18n.get_lang()[0])
-    last_activity_label = format_timedelta(datetime.now() - last_activity_date,
-                                           locale=tg.i18n.get_lang()[0])
+    last_activity_label = format_timedelta(
+        datetime.utcnow() - last_activity_date,
+        locale=tg.i18n.get_lang()[0],
+    )
     last_activity_label = last_activity_label.replace(' ', '\u00A0') # espace insécable
 
     return DictLikeClass(
         url=ContentType.fill_url(content),
         type=DictLikeClass(content_type.toDict()),
         status=context.toDict(content.get_status()),
+        is_deleted=content.is_deleted,
+        is_archived=content.is_archived,
+        is_editable=content.is_editable,
         last_activity = DictLikeClass({'date': last_activity_date,
                                        'label': last_activity_date_formatted,
                                        'delta': last_activity_label})
     last_activity_date = content.get_last_activity_date()
     last_activity_date_formatted = format_datetime(last_activity_date,
                                                    locale=tg.i18n.get_lang()[0])
-    last_activity_label = format_timedelta(datetime.now() - last_activity_date,
+    last_activity_label = format_timedelta(datetime.utcnow() - last_activity_date,
                                            locale=tg.i18n.get_lang()[0])
     last_activity_label = last_activity_label.replace(' ', '\u00A0') # espace insécable
 
         item = Context(CTX.CONTENT_LIST).toDict(content)
         item.notes = ''
 
+    item.is_deleted = content.is_deleted
+    item.is_archived = content.is_archived
+    item.is_editable = content.is_editable
+
     return item
 
 
         )
 
         if content.type==ContentType.File:
-            result.label = content.label.__str__() if content.label else content.file_name.__str__()
+            result.label = content.label.__str__()
 
         if not result.label or ''==result.label:
             result.label = 'No title'
     result['enabled'] = user.is_active
     result['profile'] = user.profile
     result['has_password'] = user.password!=None
+    result['timezone'] = user.timezone
     return result
 
 
     result['enabled'] = user.is_active
     result['profile'] = user.profile
     result['calendar_url'] = user.calendar_url
+    result['timezone'] = user.timezone
 
     return result
 
             type='workspace',
             state={'opened': True if len(item.children)>0 else False, 'selected': item.is_selected}
         )
+
+
+@pod_serializer(Workspace, CTX.API_WORKSPACE)
+def serialize_api_workspace(item: Workspace, context: Context):
+    return DictLikeClass(
+        id=item.workspace_id,
+        label=item.label,
+        description=item.description,
+        has_calendar=item.calendar_enabled,
+    )
+
+
+@pod_serializer(Workspace, CTX.API_CALENDAR_WORKSPACE)
+def serialize_api_calendar_workspace(item: Workspace, context: Context):
+    return DictLikeClass(
+        id=item.workspace_id,
+        label=item.label,
+        description=item.description,
+        type='workspace',
+    )
+
+
+@pod_serializer(User, CTX.API_CALENDAR_USER)
+def serialize_api_calendar_workspace(item: User, context: Context):
+    from tracim.lib.calendar import CalendarManager  # Cyclic import
+    return DictLikeClass(
+        id=item.user_id,
+        label=item.display_name,
+        description=CalendarManager.get_personal_calendar_description(),
+        type='user',
+    )