Merge branch 'master' into 132/dev/v1.0beta/add_link_to_webdav

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/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/tracim/controllers/__init__.py

 """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.workspace import WorkspaceApi
 
 import tg
     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
             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
         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 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.workspace import WorkspaceApi
      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)
 
+        # 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,
         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

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.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):
 
     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)
                         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)
 
         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
         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,
+        )
 
 
 
             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/workspace.py

         )
 
         fake_api.sub_items = Context(CTX.FOLDER_CONTENT_LIST).toDict(
+            # TODO BS 20161209: Is the correct way to grab folders? No use API?
             workspace.get_valid_children(ContentApi.DISPLAYABLE_CONTENTS)
         )
 

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/i18n/fr/LC_MESSAGES/tracim.po

 msgid "Post a reply..."
 msgstr "Poster une réponse..."
 
+#: tracim/templates/thread/getone.mak:97
+msgid "Invert order"
+msgstr "Inverser l'ordre"
+
 #: tracim/templates/thread/toolbar.mak:16
 msgid "Edit current thread"
 msgstr "Modifier le sujet de discussion"

tracim/tracim/lib/calendar.py

 
 import re
 import transaction
+from caldav.lib.error import PutError
 
 from icalendar import Event as iCalendarEvent
 from sqlalchemy.orm.exc import NoResultFound
 END:VEVENT
 END:VCALENDAR
 """.format(uid='{0}FAKEEVENT'.format(related_object_id))
-        event = user_calendar.add_event(event_ics)
-        event.delete()
+        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 -*-
+import os
+
 from operator import itemgetter
+from sqlalchemy import func
+from sqlalchemy.orm import Query
 
 __author__ = 'damien'
 
 
         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.
         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
+        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)
 
-        resultset = self._base_query(workspace)
+        file_name, file_extension = os.path.splitext(content_label)
 
-        parent_id = content_parent.content_id if content_parent else None
+        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()
+
+    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,
+            )
 
-        resultset = resultset.filter(Content.parent_id == parent_id)
+        # 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,
+        )
 
-        return resultset.filter(or_(
-            Content.label == content_label,
-            Content.file_name == content_label,
-            Content.label == re.sub(r'\.[^.]+$', '', content_label)
-        )).one()
+        # Modify query to apply parent folder filter if any
+        if parent_folder:
+            content_query = content_query.filter(
+                Content.parent_id == parent_folder.content_id,
+            )
 
-    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)
+        # Filter with workspace
+        content_query = content_query.filter(
+            Content.workspace_id == workspace.workspace_id,
+        )
 
-        res =  resultset.filter(or_(
-            Content.label == content_label,
-            Content.file_name == content_label,
-            Content.label == re.sub(r'\.[^.]+$', '', content_label)
-        )).all()
+        # Return the content
+        return content_query\
+            .order_by(
+                Content.revision_id.desc(),
+            )\
+            .one()
 
-        if content_parent_label:
-            tmp = dict()
-            for content in res:
-                tmp[content] = content.parent
+    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,
+                )
 
-            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}
+            # Search into parent folder (if already deep)
+            if folder:
+                folder_query = folder_query\
+                    .filter(
+                        Content.parent_id == folder.content_id,
+                    )
 
-                if len(tmp) == 1:
-                    content, last_parent = tmp.popitem()
-                    return content
-                elif len(tmp) == 0:
-                    return None
+            # Get thirst corresponding folder
+            folder = folder_query \
+                .order_by(Content.revision_id.desc()) \
+                .one()
 
-            for content, parent_content in tmp.items():
-                if not parent_content:
-                    return content
+        return folder
 
-            return None
-        return res[0]
+    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

tracim/tracim/lib/daemons.py

 
         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']
             )
         }

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

             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')
                 content_intro = _('<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)

tracim/tracim/lib/webdav/design.py

                        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>
                            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

 
 import re
 from os.path import basename, dirname, normpath
+from sqlalchemy.orm.exc import NoResultFound
 from tracim.lib.webdav.utils import transform_to_bdd
 
 from wsgidav.dav_provider import 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('')
+        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(
-                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(transform_to_bdd(path.split('/')[1]))
-        except:
+        except NoResultFound:
             return None

tracim/tracim/lib/webdav/sql_resources.py

         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
             # 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
 
         children = self.content_api.get_all(False, ContentType.Any, self.workspace)
 
         for content in children:
-            content_path = '%s/%s' % (self.path, 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 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())
         )
 
         for content in visible_children:
-            content_path = '%s/%s' % (self.path, 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 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, 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, 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 + '/' + 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, 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)
                 content_revision=revision)
         else:
             return HistoryOtherFile(
-                path='%s%s' % (left_side, 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)
         # 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 not fix_txt:
-            fix_txt = ''
-        if self.content and self.path and (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():
+                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,
-                    transform_to_bdd(basename(destpath)),
+                    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()
             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, 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/workspace.py

 # -*- coding: utf-8 -*-
 import transaction
+from sqlalchemy.orm import Query
 
 from tracim.lib.userworkspace import RoleApi
 from tracim.model.auth import Group
                 related_object_id=workspace.workspace_id,
             )
 
+    def get_base_query(self) -> Query:
+        return self._base_query()
+
 
 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:

tracim/tracim/model/data.py

 
 import datetime as datetime_root
 import json
+import os
 from datetime import datetime
 
 import tg
     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:
 
     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':
         """
         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:
         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__())

tracim/tracim/model/serializers.py

 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())
 
     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)
         )
         )
 
         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),
         )
 
         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'

tracim/tracim/public/assets/css/dashboard.css

 .no-padding {
     padding: 0px;
 }
+.threads-history-reverse {
+  float: right;
+  padding: 10px 15px 0 0;
+  font-size: 16px;
+}
+.threads-history-reverse > i {
+  font-size: 12px;
+}

tracim/tracim/public/assets/js/main.js

 
   // add select2 for admin/workspace/<id> for user selection
   if ($('#add-role-from-existing-user-form').length > 0) {
-    $('#user_id').select2();
+    $('#user_id').select2({
+      "language": {
+        "noResults": function () {
+          return "Aucun résultats"
+        }
+      },
+      escapeMarkup: function (markup) {
+        return markup
+      }
+    })
   }
 })

tracim/tracim/templates/admin/workspace_getone.mak

                                     <form role="form" method="POST" action="${tg.url('/admin/workspaces/{}/roles'.format(result.workspace.id))}">
                                         <div class="form-group">
                                             <label for="user_id">${_('User')}</label>
-                                            <select name="user_id" id="user_id" class="form-control">
+                                            <select name="user_id" id="user_id" class="form-control" style="width:100%">
                                                 % for user in fake_api.users:
                                                     % if user.id not in (user.id for user in result.workspace.members):
                                                         <option value="${user.id}">${user.name}</option>

tracim/tracim/templates/errors/__init__.py

+# -*- coding: utf-8 -*-

tracim/tracim/templates/errors/label_invalid_path.mak

+<%inherit file="local:templates.master_authenticated"/>
+
+<div class="row">
+    <div class="col-sm-7 col-sm-offset-3 main">
+        <p>
+            ${_('Chosen label "{0}" is invalid because is in conflict with other resource.').format(invalid_label)}
+        </p>
+
+        <button onclick="goBack()">${_('Go Back')}</button>
+
+        <script>
+        function goBack() {
+            window.history.back();
+        }
+        </script>
+
+    </div>
+</div>

tracim/tracim/templates/file/toolbar.mak

 
     <% download_url = tg.url('/workspaces/{}/folders/{}/files/{}/download?revision_id={}'.format(result.file.workspace.id, result.file.parent.id,result.file.id,result.file.selected_revision)) %>
     <% edit_disabled = ('', 'disabled')[file.selected_revision!='latest' or file.status.id[:6]=='closed'] %>
-    <% delete_or_archive_disabled = ('', 'disabled')[file.selected_revision!='latest'] %> 
+    <% delete_or_archive_disabled = ('', 'disabled')[file.selected_revision!='latest'] %>
     % if h.user_role(user, workspace)>1:
         <div class="btn-group btn-group-vertical">
             <a title="${_('Edit current file')}" class="btn btn-default ${edit_disabled}" data-toggle="modal" data-target="#file-edit-modal-dialog" data-remote="${tg.url('/workspaces/{}/folders/{}/files/{}/edit'.format(file.workspace.id, file.parent.id, file.id))}" >${ICON.FA_FW('fa fa-edit t-less-visible')} ${_('Edit')}</a>
         </div>
         <p></p>
     % endif
-    
+
     <div class="btn-group btn-group-vertical">
         <a href="${download_url}" role="button" class="btn btn-default" data-toggle="modal" title="${_('Download the file')}">${ICON.FA('fa fa-download t-less-visible')} ${_('Download')}</a>
         <a href="#file-versions" role="button" class="btn btn-default" data-toggle="modal" title="${_('View versions of the file')}">${ICON.FA('fa fa-history t-less-visible')} ${_('Revisions')}</a>
 ## RESTORE LINKS IF REQUIRED        <a href="#file-associated-links" role="button" class="btn btn-default" data-toggle="modal" title="${_('View all links')}">${TIM.ICO(32, 'apps/internet-web-browser')}</a>
     </div>
     <p></p>
-    
+
     % if user.profile.id>=3 or h.user_role(user, workspace)>=4:
         ## if the user can see the toolbar, it means he is the workspace manager.
         ## So now, we need to know if he alsa has right to delete workspaces
         <div class="btn-group btn-group-vertical">
             ## SHOW_ARCHIVE_BUTTON__BUG_#81
             <a title="${_('Archive file')}" class="btn btn-default ${delete_or_archive_disabled}" href="${tg.url('/workspaces/{}/folders/{}/files/{}/put_archive'.format(file.workspace.id, file.parent.id, file.id))}">
-                ${ICON.FA_FW('fa fa-archive t-less-visible')} ${_('Archive')}test
+                ${ICON.FA_FW('fa fa-archive t-less-visible')} ${_('Archive')}
             </a>
             <a title="${_('Delete file')}" class="btn btn-default ${delete_or_archive_disabled}" href="${tg.url('/workspaces/{}/folders/{}/files/{}/put_delete'.format(file.workspace.id, file.parent.id, file.id))}">
                 ${ICON.FA_FW('fa fa-trash t-less-visible')} ${_('Delete')}

tracim/tracim/templates/master_authenticated.mak

                     <ul class="nav navbar-nav navbar-left">
                         <li class="active"><a href="${tg.url('/home')}">${TIM.FA('fa-home fa-lg')} ${_('My Home')}</a></li>
                         <li class=""><a href="${tg.url('/calendar')}">${TIM.FA('fa-calendar')} ${_('Calendar')}</a></li>
-                        % if fake_api.current_user.profile.id>2:
-                            ${NAVBAR_MENU.ADMIN_ITEMS()}
-                        % endif
+                        ${NAVBAR_MENU.ADMIN_ITEMS()}
                     </ul>
                 % endif
 

tracim/tracim/templates/pod.mak

 
 <%def name="TINYMCE_INIT_SCRIPT(selector)">
     <script>
+        function base64EncodeAndTinyMceInsert (files) {
+          for (var i = 0; i < files.length; i++) {
+            if (files[i].size > 1000000)
+              files[i].allowed = confirm(files[i].name + " fait plus de 1mo et peut prendre du temps à insérer, voulez-vous continuer ?")
+          }
+
+          for (var i = 0; i < files.length; i++) {
+            if (files[i].allowed !== false && files[i].type.match('image.*')) {
+              var img = document.createElement('img')
+
+              var fr = new FileReader()
+
+              fr.readAsDataURL(files[i])
+
+              fr.onloadend = function (e) {
+                img.src = e.target.result
+                tinymce.activeEditor.execCommand('mceInsertContent', false, img.outerHTML)
+              }
+            }
+          }
+        }
+
         tinymce.init({
             menubar:false,
             statusbar:true,
             skin : 'tracim',
             selector:'${selector}',
             toolbar: [
-              "undo redo | bold italic underline strikethrough | bullist numlist outdent indent | table | charmap | styleselect | alignleft aligncenter alignright | fullscreen",
+              "undo redo | bold italic underline strikethrough | bullist numlist outdent indent | table | charmap | styleselect | alignleft aligncenter alignright | fullscreen | customInsertImage",
             ],
             paste_data_images: true,
             table_default_attributes: {
                 {title: 'Normal', value: 'user_content'},
                 {title: 'First row is header', value: 'user_content first_row_headers'},
                 {title: 'First column is header', value: 'user_content first_column_headers'}
-            ]
+            ],
+            setup: function ($editor) {
+              //////////////////////////////////////////////
+              // add custom btn to handle image by selecting them with system explorer
+              $editor.addButton('customInsertImage', {
+                text: 'Image',
+                icon: false,
+                onclick: function () {
+                  if ($('#hidden_tinymce_fileinput').length > 0) $('#hidden_tinymce_fileinput').remove()
+
+                  fileTag = document.createElement('input')
+                  fileTag.id = 'hidden_tinymce_fileinput'
+                  fileTag.type = 'file'
+                  $('body').append(fileTag)
+
+                  $('#hidden_tinymce_fileinput').on('change', function () {
+                    base64EncodeAndTinyMceInsert($(this)[0].files)
+                  })
+
+                  $('#hidden_tinymce_fileinput').click()
+                }
+              })
 
+              //////////////////////////////////////////////
+              // Handle drag & drop image into TinyMce by encoding them in base64 (to avoid uploading them somewhere and keep saving comment in string format)
+              $editor
+              .on('drag dragstart dragend dragover dragenter dragleave drop', function (e) {
+                e.preventDefault()
+                e.stopPropagation()
+              })
+              .on('drop', function(e) {
+                base64EncodeAndTinyMceInsert(e.dataTransfer.files)
+              })
+            }
         });
     </script>
 </%def>

tracim/tracim/templates/thread/getone.mak

 
 <div class="row">
     <div class="col-sm-7 col-sm-offset-3">
+        <div class="threads-history-reverse">
+        % if inverted:
+            <a href="${tg.url('/workspaces/{}/folders/{}/threads/{}'.format(result.thread.workspace.id, result.thread.parent.id, result.thread.id))}">
+                <i class="fa fa-chevron-down" aria-hidden="true"></i>
+        % else:
+            <a href="${tg.url('/workspaces/{}/folders/{}/threads/{}?inverted=1'.format(result.thread.workspace.id, result.thread.parent.id, result.thread.id))}">
+                <i class="fa fa-chevron-up" aria-hidden="true"></i>
+        % endif
+                ${_('Invert order')}
+            </a>
+        </div>
         % if h.user_role(fake_api.current_user, result.thread.workspace)<=1:
             ## READONLY USER
             <% a = 'b' %>
     </div>
 </div>
 
+<!-- % for event in reversed(result.thread.history): -->
 % for event in result.thread.history:
     ## TODO - D.A. - 2015-08-20
     ## Allow to show full history (with status change and archive/unarchive)

tracim/tracim/templates/widgets/navbar_menu.mak

 <%namespace name="ICON" file="tracim.templates.widgets.icon"/>
 
 <%def name="ADMIN_ITEMS()">
+    % if fake_api.current_user.profile.id>=2:
     <li class="">
         <a href="${tg.url('/admin/workspaces')}">
             ${ICON.FA('fa-bank fa-fw')} ${_('Workspaces')}
         </a>
     </li>
-    <li class="">
-        <a href="${tg.url('/admin/users')}">
-            ${ICON.FA('fa-user fa-fw')} ${_('Users')}
-        </a>
-    </li>
+    % endif
+    % if fake_api.current_user.profile.id>2:
+        <li class="">
+            <a href="${tg.url('/admin/users')}">
+                ${ICON.FA('fa-user fa-fw')} ${_('Users')}
+            </a>
+        </li>
+    % endif
 </%def>

tracim/tracim/tests/library/test_content_api.py

         eq_(u2id, updated.owner_id,
             'the owner id should be {} (found {})'.format(u2id,
                                                           updated.owner_id))
-        eq_('index.html', updated.file_name)
+        eq_('this_is_a_page.html', updated.file_name)
         eq_('text/html', updated.file_mimetype)
         eq_(b'<html>hello world</html>', updated.file_content)
         eq_(ActionDescription.REVISION, updated.revision_type)

tracim/tracim/tests/library/test_integrity.py

+# -*- coding: utf-8 -*-
+from nose.tools import ok_
+
+from tracim.fixtures.content import Content as ContentFixtures
+from tracim.lib.integrity import PathValidationManager
+from tracim.model import DBSession
+from tracim.model.data import Workspace
+from tracim.model.data import Content
+from tracim.model.data import ContentRevisionRO
+from tracim.tests import TestStandard
+
+
+class TestWebDav(TestStandard):
+    fixtures = [ContentFixtures]
+
+    def _get_content_by_label(self, label: str) -> Content:
+        revision = DBSession.query(ContentRevisionRO) \
+            .filter(ContentRevisionRO.label == label) \
+            .one()
+
+        return DBSession.query(Content) \
+            .filter(Content.id == revision.content_id) \
+            .one()
+
+    def test_unit__workspace_label_available__ok(self):
+        integrity_manager = PathValidationManager()
+        ok_(
+            integrity_manager.workspace_label_is_free('w42'),
+            msg='label w42 should not be used',
+        )
+
+    def test_unit__workspace_label_reserved__ok(self):
+        integrity_manager = PathValidationManager()
+        ok_(
+            not integrity_manager.workspace_label_is_free('w1'),
+            msg='label w1 should be reserved',
+        )
+
+    def test_unit__workspace_label_reserved_with_case__ok(self):
+        integrity_manager = PathValidationManager()
+        ok_(
+            not integrity_manager.workspace_label_is_free('W1'),
+            msg='label W1 should be reserved',
+        )
+
+    def test_unit__folder_label_available__ok__folder_at_root(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+
+        ok_(
+            integrity_manager.content_label_is_free(
+                content_label_as_file='f42',
+                workspace=w1,
+                parent=None,
+            ),
+            msg='label f42 should not be used',
+        )
+
+    def test_unit__folder_label_reserved__ok__folder_at_root(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1',
+                workspace=w1,
+                parent=None,
+            ),
+            msg='label w1f1 should be reserved',
+        )
+
+    def test_unit__folder_label_reserved_with_case__ok__folder_at_root(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='W1F1',
+                workspace=w1,
+                parent=None,
+            ),
+            msg='label W1F1 should be reserved',
+        )
+
+    def test_unit__folder_label_reserved__ok__folder_in_folder(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1f1',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1f1 should be reserved',
+        )
+
+    def test_unit__content_label_reserved__ok__because_page_name(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1p1.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1p1.html should be reserved '
+                'because page w1f1p1.html',
+        )
+
+    def test_unit__content_label_available__ok(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1p42.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1p42.html should be available',
+        )
+
+    def test_unit__content_label_available__ok__without_extension(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1p42',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1p42 should be available',
+        )
+
+    def test_unit__content_label_reserved__ok(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1p1.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1p1.html should be reserved',
+        )
+
+    def test_unit__content_label_reserved__ok__because_thread_extension(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1t1.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1t1 should be reserved because '
+                'w1f1t1 rendered with .html',
+        )
+
+    def test_unit__content_label_reserved__ok__because_html_file(self):
+        integrity_manager = PathValidationManager()
+        w1 = DBSession.query(Workspace).filter(Workspace.label == 'w1').one()
+        w1f1 = self._get_content_by_label('w1f1')
+
+        ok_(
+            not integrity_manager.content_label_is_free(
+                content_label_as_file='w1f1d2.html',
+                workspace=w1,
+                parent=w1f1,
+            ),
+            msg='label w1f1d2.html should be reserved because '
+                'w1f1d2 rendered with .html and file w1f1d2.html exist',
+        )

tracim/tracim/tests/library/test_webdav.py

+# -*- coding: utf-8 -*-
+import io
+from nose.tools import eq_
+from nose.tools import ok_
+from tracim.lib.webdav.sql_dav_provider import Provider
+from tracim.lib.webdav.sql_resources import Root
+from tracim.model import Content
+from tracim.model import ContentRevisionRO
+from tracim.model import DBSession
+from tracim.tests import TestStandard
+from tracim.fixtures.content import Content as ContentFixtures
+from wsgidav import util
+
+
+class TestWebDav(TestStandard):
+    fixtures = [ContentFixtures]
+
+    def _get_provider(self):
+        return Provider(
+            show_archived=False,
+            show_deleted=False,
+            show_history=False,
+        )
+
+    def _get_environ(
+            self,
+            provider: Provider,
+            username: str,
+    ) -> dict:
+        return {
+            'http_authenticator.username': username,
+            'http_authenticator.realm': '/',
+            'wsgidav.provider': provider,
+        }
+
+    def _put_new_text_file(
+            self,
+            provider,
+            environ,
+            file_path,
+            file_content,
+    ):
+        # This part id a reproduction of
+        # wsgidav.request_server.RequestServer#doPUT
+
+        # Grab parent folder where create file
+        parentRes = provider.getResourceInst(
+            util.getUriParent(file_path),
+            environ,
+        )
+        ok_(parentRes, msg='we should found folder for {0}'.format(file_path))
+
+        new_resource = parentRes.createEmptyResource(
+            util.getUriName(file_path),
+        )
+        write_object = new_resource.beginWrite(
+            contentType='application/octet-stream',
+        )
+        write_object.write(b'hello\n')
+        write_object.close()
+        new_resource.endWrite(withErrors=False)
+
+        # Now file should exist
+        return provider.getResourceInst(
+            file_path,
+            environ,
+        )
+
+    def test_unit__get_root__ok(self):
+        provider = self._get_provider()
+        root = provider.getResourceInst(
+            '/',
+            self._get_environ(
+                provider,
+                'bob@fsf.local',
+            )
+        )
+        ok_(root, msg='Path / should return a Root instance')
+        ok_(isinstance(root, Root))
+
+    def test_unit__list_workspaces_with_admin__ok(self):
+        provider = self._get_provider()
+        root = provider.getResourceInst(
+            '/',
+            self._get_environ(
+                provider,
+                'bob@fsf.local',
+            )
+        )
+        ok_(root, msg='Path / should return a Root instance')
+        ok_(isinstance(root, Root), msg='Path / should return a Root instance')
+
+        children = root.getMemberList()
+        eq_(
+            2,
+            len(children),
+            msg='Root should return 2 workspaces instead {0}'.format(
+                len(children),
+            )
+        )
+
+        workspaces_names = [w.name for w in children]
+        ok_('w1' in workspaces_names, msg='w1 should be in names ({0})'.format(
+            workspaces_names,
+        ))
+        ok_('w2' in workspaces_names, msg='w2 should be in names ({0})'.format(
+            workspaces_names,
+        ))
+
+    def test_unit__list_workspace_folders__ok(self):
+        provider = self._get_provider()
+        w1 = provider.getResourceInst(
+            '/w1/',
+            self._get_environ(
+                provider,
+                'bob@fsf.local',
+            )
+        )
+        ok_(w1, msg='Path /w1 should return a Wrkspace instance')
+
+        children = w1.getMemberList()
+        eq_(
+            2,
+            len(children),
+            msg='w1 should list 2 folders instead {0}'.format(
+                len(children),
+            ),
+        )
+
+        folders_names = [f.name for f in children]
+        ok_(
+            'w1f1' in folders_names,
+            msg='w1f1 should be in names ({0})'.format(
+                folders_names,
+            )
+        )
+        ok_(
+            'w1f2' in folders_names,
+            msg='w1f2 should be in names ({0})'.format(
+                folders_names,
+            )
+        )
+
+    def test_unit__list_content__ok(self):
+        provider = self._get_provider()
+        w1f1 = provider.getResourceInst(
+            '/w1/w1f1',
+            self._get_environ(
+                provider,
+                'bob@fsf.local',
+            )
+        )
+        ok_(w1f1, msg='Path /w1f1 should return a Wrkspace instance')
+
+        children = w1f1.getMemberList()
+        eq_(
+            5,
+            len(children),
+            msg='w1f1 should list 5 folders instead {0}'.format(
+                len(children),
+            ),
+        )
+
+        content_names = [c.name for c in children]
+        ok_(
+            'w1f1p1.html' in content_names,
+            msg='w1f1.html should be in names ({0})'.format(
+                content_names,
+            )
+        )
+        ok_(
+            'w1f1t1.html' in content_names,
+            msg='w1f1t1.html should be in names ({0})'.format(
+                content_names,
+            )
+        )
+        ok_(
+            'w1f1d1.txt' in content_names,
+            msg='w1f1d1.txt should be in names ({0})'.format(
+                content_names,
+            )
+        )
+        ok_(
+            'w1f1f1' in content_names,
+            msg='w1f1f1 should be in names ({0})'.format(
+                content_names,
+            )
+        )
+        ok_(
+            'w1f1d2.html' in content_names,
+            msg='w1f1d2.html should be in names ({0})'.format(
+                content_names,
+            )
+        )
+
+    def test_unit__get_content__ok(self):
+        provider = self._get_provider()
+        w1f1d1 = provider.getResourceInst(
+            '/w1/w1f1/w1f1d1.txt',
+            self._get_environ(
+                provider,
+                'bob@fsf.local',
+            )
+        )
+
+        ok_(w1f1d1, msg='w1f1d1 should be found')
+        eq_('w1f1d1.txt', w1f1d1.name)
+
+    def test_unit__delete_content__ok(self):
+        provider = self._get_provider()
+        w1f1d1 = provider.getResourceInst(
+            '/w1/w1f1/w1f1d1.txt',
+            self._get_environ(
+                provider,
+                'bob@fsf.local',
+            )
+        )
+
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(Content.label == 'w1f1d1') \
+            .one()  # It must exist only one revision, cf fixtures
+        eq_(
+            False,
+            content_w1f1d1.is_deleted,
+            msg='Content should not be deleted !'
+        )
+        content_w1f1d1_id = content_w1f1d1.content_id
+
+        w1f1d1.delete()
+
+        DBSession.flush()
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(Content.content_id == content_w1f1d1_id) \
+            .order_by(Content.revision_id.desc()) \
+            .first()
+        eq_(
+            True,
+            content_w1f1d1.is_deleted,
+            msg='Content should be deleted !'
+        )
+
+        result = provider.getResourceInst(
+            '/w1/w1f1/w1f1d1.txt',
+            self._get_environ(
+                provider,
+                'bob@fsf.local',
+            )
+        )
+        eq_(None, result, msg='Result should be None instead {0}'.format(
+            result
+        ))
+
+    def test_unit__create_content__ok(self):
+        provider = self._get_provider()
+        environ = self._get_environ(
+            provider,
+            'bob@fsf.local',
+        )
+        result = provider.getResourceInst(
+            '/w1/w1f1/new_file.txt',
+            environ,
+        )
+
+        eq_(None, result, msg='Result should be None instead {0}'.format(
+            result
+        ))
+
+        result = self._put_new_text_file(
+            provider,
+            environ,
+            '/w1/w1f1/new_file.txt',
+            b'hello\n',
+        )
+
+        ok_(result, msg='Result should not be None instead {0}'.format(
+            result
+        ))
+        eq_(
+            b'hello\n',
+            result.content.file_content,
+            msg='fiel content should be "hello\n" but it is {0}'.format(
+                result.content.file_content
+            )
+        )
+
+    def test_unit__create_delete_and_create_file__ok(self):
+        provider = self._get_provider()
+        environ = self._get_environ(
+            provider,
+            'bob@fsf.local',
+        )
+        new_file = provider.getResourceInst(
+            '/w1/w1f1/new_file.txt',
+            environ,
+        )
+
+        eq_(None, new_file, msg='Result should be None instead {0}'.format(
+            new_file
+        ))
+
+        # create it
+        new_file = self._put_new_text_file(
+            provider,
+            environ,
+            '/w1/w1f1/new_file.txt',
+            b'hello\n',
+        )
+        ok_(new_file, msg='Result should not be None instead {0}'.format(
+            new_file
+        ))
+
+        content_new_file = DBSession.query(ContentRevisionRO) \
+            .filter(Content.label == 'new_file') \
+            .one()  # It must exist only one revision
+        eq_(
+            False,
+            content_new_file.is_deleted,
+            msg='Content should not be deleted !'
+        )
+        content_new_file_id = content_new_file.content_id
+
+        # Delete if
+        new_file.delete()
+
+        DBSession.flush()
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(Content.content_id == content_new_file_id) \
+            .order_by(Content.revision_id.desc()) \
+            .first()
+        eq_(
+            True,
+            content_w1f1d1.is_deleted,
+            msg='Content should be deleted !'
+        )
+
+        result = provider.getResourceInst(
+            '/w1/w1f1/new_file.txt',
+            self._get_environ(
+                provider,
+                'bob@fsf.local',
+            )
+        )
+        eq_(None, result, msg='Result should be None instead {0}'.format(
+            result
+        ))
+
+        # Then create it again
+        new_file = self._put_new_text_file(
+            provider,
+            environ,
+            '/w1/w1f1/new_file.txt',
+            b'hello\n',
+        )
+        ok_(new_file, msg='Result should not be None instead {0}'.format(
+            new_file
+        ))
+
+        # Previous file is still dleeted
+        DBSession.flush()
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(Content.content_id == content_new_file_id) \
+            .order_by(Content.revision_id.desc()) \
+            .first()
+        eq_(
+            True,
+            content_w1f1d1.is_deleted,
+            msg='Content should be deleted !'
+        )
+
+        # And an other file exist for this name
+        content_new_new_file = DBSession.query(ContentRevisionRO) \
+            .filter(Content.label == 'new_file') \
+            .order_by(Content.revision_id.desc()) \
+            .first()
+        ok_(
+            content_new_new_file.content_id != content_new_file_id,
+            msg='Contents ids should not be same !'
+        )
+        eq_(
+            False,
+            content_new_new_file.is_deleted,
+            msg='Content should not be deleted !'
+        )
+
+    def test_unit__rename_content__ok(self):
+        provider = self._get_provider()
+        environ = self._get_environ(
+            provider,
+            'bob@fsf.local',
+        )
+        w1f1d1 = provider.getResourceInst(
+            '/w1/w1f1/w1f1d1.txt',
+            environ,
+        )
+
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(Content.label == 'w1f1d1') \
+            .one()  # It must exist only one revision, cf fixtures
+        ok_(content_w1f1d1, msg='w1f1d1 should be exist')
+        content_w1f1d1_id = content_w1f1d1.content_id
+
+        w1f1d1.moveRecursive('/w1/w1f1/w1f1d1_RENAMED.txt')
+
+        # Database content is renamed
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(ContentRevisionRO.content_id == content_w1f1d1_id) \
+            .order_by(ContentRevisionRO.revision_id.desc()) \
+            .first()
+        eq_(
+            'w1f1d1_RENAMED',
+            content_w1f1d1.label,
+            msg='File should be labeled w1f1d1_RENAMED, not {0}'.format(
+                content_w1f1d1.label
+            )
+        )
+
+    def test_unit__move_content__ok(self):
+        provider = self._get_provider()
+        environ = self._get_environ(
+            provider,
+            'bob@fsf.local',
+        )
+        w1f1d1 = provider.getResourceInst(
+            '/w1/w1f1/w1f1d1.txt',
+            environ,
+        )
+
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(Content.label == 'w1f1d1') \
+            .one()  # It must exist only one revision, cf fixtures
+        ok_(content_w1f1d1, msg='w1f1d1 should be exist')
+        content_w1f1d1_id = content_w1f1d1.content_id
+        content_w1f1d1_parent = content_w1f1d1.parent
+        eq_(
+            content_w1f1d1_parent.label,
+            'w1f1',
+            msg='field parent should be w1f1',
+        )
+
+        w1f1d1.moveRecursive('/w1/w1f2/w1f1d1.txt')  # move in f2
+
+        # Database content is moved
+        content_w1f1d1 = DBSession.query(ContentRevisionRO) \
+            .filter(ContentRevisionRO.content_id == content_w1f1d1_id) \
+            .order_by(ContentRevisionRO.revision_id.desc()) \
+            .first()
+        ok_(
+            content_w1f1d1.parent.label != content_w1f1d1_parent.label,
+            msg='file should be moved in w1f2 but is in {0}'.format(
+                content_w1f1d1.parent.label
+            )
+        )