A lot of optimization in database calls, new way to get content from path to limit calls, a lot of comments and integrated css

install/requirements.txt

 vobject==0.9.2
 waitress==0.8.9
 who-ldap==3.1.0
--e git+git@github.com:Nonolost/wsgidav.git@73f832e6bd94ac21ae608af43a9516ff31abc9a2#egg=wsgidav
+-e git+git@github.com:Nonolost/wsgidav.git@a5df223d5c66c252baa89ec5de8073f9f1494a8f#egg=wsgidav
 zope.interface==4.1.3
 zope.sqlalchemy==0.7.6
 

tracim/tracim/lib/content.py

 
         resultset = resultset.filter(Content.parent_id == parent_id)
 
-        try:
-            return resultset.filter(Content.label == content_label).one()
-        except:
-            try:
-                return resultset.filter(Content.file_name == content_label).one()
-            except:
-                import re
-                return resultset.filter(Content.label == re.sub(r'\.[^.]+$', '', content_label)).one()
+        return resultset.filter(or_(
+            Content.label == content_label,
+            Content.file_name == content_label,
+            Content.label == re.sub(r'\.[^.]+$', '', content_label)
+        )).one()
+
+    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)
+
+        res =  resultset.filter(or_(
+            Content.label == content_label,
+            Content.file_name == content_label,
+            Content.label == re.sub(r'\.[^.]+$', '', content_label)
+        )).all()
+
+        if content_parent_label:
+            tmp = dict()
+            for content in res:
+                tmp[content] = content.parent
+
+            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}
+
+                if len(tmp) == 1:
+                    content, last_parent = tmp.popitem()
+                    return content
+                elif len(tmp) == 0:
+                    return None
+
+            for content, parent_content in tmp.items():
+                if not parent_content:
+                    return content
+
+            return None
+        return res[0]
 
     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

 from wsgidav._version import __version__
 
 from tracim.lib.webdav.sql_dav_provider import Provider
-from tracim.lib.webdav.sql_domain_controller import SQLDomainController
+from tracim.lib.webdav.sql_domain_controller import TracimDomainController
 
 from inspect import isfunction
 import traceback
 DEFAULT_CONFIG_FILE = "wsgidav.conf"
 PYTHON_VERSION = "%s.%s.%s" % (sys.version_info[0], sys.version_info[1], sys.version_info[2])
 
-def _get_checked_path(path, mustExist=True, allowNone=True):
-    """Convert path to absolute if not None."""
-    if path in (None, ""):
-        if allowNone:
-            return None
-        else:
-            raise ValueError("Invalid path %r" % path)
-    path = os.path.abspath(path)
-    if mustExist and not os.path.exists(path):
-        raise ValueError("Invalid path %r" % path)
-    return path
 
 class WsgiDavDaemon(Daemon):
 
 
         config['middleware_stack'] = [ WsgiDavDirBrowser, TracimHTTPAuthenticator, ErrorPrinter, WsgiDavDebugFilter ]
 
-        config['provider_mapping'] = \
-            {
-                config['root_path']: Provider(
-                    show_archived=config['show_archived'],
-                    show_deleted=config['show_deleted'],
-                    show_history=config['show_history'],
-                    manage_locks=config['manager_locks']
-                )
-            }
-
-        config['domaincontroller'] = SQLDomainController(presetdomain=None, presetserver=None)
-        config['defaultdigest'] = True
-        config['acceptdigest'] = True
+        config['provider_mapping'] = {
+            config['root_path']: Provider(
+                show_archived=config['show_archived'],
+                show_deleted=config['show_deleted'],
+                show_history=config['show_history'],
+                manage_locks=config['manager_locks']
+            )
+        }
+
+        config['domaincontroller'] = TracimDomainController(presetdomain=None, presetserver=None)
 
         return config
 

tracim/tracim/lib/webdav/__init__.py

-from wsgidav.compat import to_bytes
+# coding: utf8
+
+import transaction
+from wsgidav import util
+from wsgidav import compat
 
 from tracim.lib.content import ContentApi
 from tracim.model import new_revision
-from tracim.model.data import ActionDescription, ContentType, Content, Workspace
-from wsgidav import util
+from tracim.model.data import ActionDescription
+from tracim.model.data import ContentType
+from tracim.model.data import Content
+from tracim.model.data import Workspace
 
-import transaction
-from wsgidav import compat
 
 class HistoryType(object):
     Deleted = 'deleted'
     All = 'all'
 
 
+class SpecialFolderExtension(object):
+    Deleted = '/.deleted'
+    Archived = '/.archived'
+    History = '/.history'
+
+
 class FakeFileStream(object):
-    """Fake a FileStream object that is needed by wsgidav to create or update existing files
-    with new content"""
+    """
+    Fake a FileStream that we're giving to wsgidav to receive data and create files / new revisions
 
-    def __init__(self, content_api: ContentApi, workspace: Workspace,
+    There's two scenarios :
+    - when a new file is created, wsgidav will call the method createEmptyResource and except to get a _DAVResource
+    which should have both 'beginWrite' and 'endWrite' method implemented
+    - when a file which already exists is updated, he's going to call the 'beginWrite' function of the _DAVResource
+    to get a filestream and write content in it
+
+    In the first case scenario, the transfer takes two part : it first create the resource (createEmptyResource)
+    then add its content (beginWrite, write, close..). If we went without this class, we would create two revision
+    of the file upon creating a new file, which is not what we want.
+    """
+
+    def __init__(self, content_api: ContentApi, workspace: Workspace, path: str,
                  file_name: str='', content: Content=None, parent: Content=None):
         """
 
-        :param file_name: the filename if the file is new
         :param content_api:
-        :param workspace: content's workspace, necessary if the file is new as we've got no other way to get it
-        :param content: either the content to be updated or None if it's a new file
+        :param workspace:
+        :param path:
+        :param file_name:
+        :param content:
+        :param parent:
         """
-        self._buff = compat.BytesIO()
+        self._file_stream = compat.BytesIO()
 
         self._file_name = file_name if file_name != '' else self._content.file_name
         self._content = content
         self._api = content_api
         self._workspace = workspace
         self._parent = parent
+        self._path = path
+
+    def getRefUrl(self) -> str:
+        """
+        As wsgidav expect to receive a _DAVResource upon creating a new resource, this method's result is used
+        by Windows client to establish both file's path and file's name
+        """
+        return self._path
 
     def beginWrite(self, contentType) -> 'FakeFileStream':
-        """Called by request_server to user as a file stream to write bits by bits content into a filestream"""
+        """
+        Called by wsgidav, it expect a filestream which possess both 'write' and 'close' operation to write
+        the file content.
+        """
         return self
 
     def endWrite(self, withErrors: bool):
-        """Called by request_server when finished writing everythin, wdc"""
+        """
+        Called by request_server when finished writing everything.
+        As we call operation to create new content or revision in the close operation, called before endWrite, there
+        is nothing to do here.
+        """
         pass
 
     def write(self, s: str):
-        """Called by request_server when writing content to files, we stock it in our file"""
-        self._buff.write(s)
+        """
+        Called by request_server when writing content to files, we put it inside a filestream
+        """
+        self._file_stream.write(s)
 
     def close(self):
-        """Called by request_server when everything has been written and we either update the file or
-        create a new file"""
+        """
+        Called by request_server when the file content has been written. We either add a new content or create
+        a new revision
+        """
 
-        self._buff.seek(0)
+        self._file_stream.seek(0)
 
         if self._content is None:
-            self.create_file(self._buff)
+            self.create_file()
         else:
-            self.update_file(self._buff)
+            self.update_file()
+
+        transaction.commit()
+
+    def create_file(self):
+        """
+        Called when this is a new file; will create a new Content initialized with the correct content
+        """
 
-    def create_file(self, item_content):
         is_temporary = self._file_name.startswith('.~') or self._file_name.startswith('~')
 
         file = self._api.create(
             file,
             self._file_name,
             util.guessMimeType(self._file_name),
-            item_content.read()
+            self._file_stream.read()
         )
 
         self._api.save(file, ActionDescription.CREATION)
 
-        transaction.commit()
+    def update_file(self):
+        """
+        Called when we're updating an existing content; we create a new revision and update the file content
+        """
 
-    def update_file(self, item_content):
         with new_revision(self._content):
             self._api.update_file_data(
                 self._content,
                 self._file_name,
                 util.guessMimeType(self._content.file_name),
-                item_content.read()
+                self._file_stream.read()
             )
-            self._api.save(self._content, ActionDescription.EDITION)
 
-        transaction.commit()
+            self._api.save(self._content, ActionDescription.EDITION)

tracim/tracim/lib/webdav/design.py

+#coding: utf8
+from datetime import datetime
+
 from tracim.model.data import VirtualEvent
-from tracim.model import data
 from tracim.model.data import ContentType
-from datetime import datetime
+from tracim.model import data
 
 def create_readable_date(created, delta_from_datetime: datetime = None):
-    aff = ''
-
     if not delta_from_datetime:
         delta_from_datetime = datetime.now()
 
     return aff
 
 def designPage(content: data.Content, content_revision: data.ContentRevisionRO) -> str:
-    # f = open('wsgidav/addons/webdav/style.css', 'r')
-    style = ''  # f.read()
-    # f.close()
+    f = open('tracim/lib/webdav/style.css', 'r')
+    style = f.read()
+    f.close()
 
     hist = content.get_history()
     histHTML = '<table class="table table-striped table-hover">'
                        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">(View revision)</a></span>''' % (
-                       content.label, event.id, event.ref_object.label) if event.type.id in ['revision', 'creation', 'edition'] else '')
+                       '<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>'
 
 	<title>%s</title>
 	<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">
 	<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css">
-	<link rel="stylesheet" href="/home/arnaud/Documents/css/style.css">
+	<style>%s</style>
 	<script type="text/javascript" src="/home/arnaud/Documents/css/script.js"></script>
 	<script
 			  src="https://code.jquery.com/jquery-3.1.0.min.js"
 </body>
 </html>
         ''' % (content_revision.label,
+               style,
                content_revision.label,
                content.created.strftime("%B %d, %Y at %H:%m"),
                content.owner.display_name,
     return file
 
 def designThread(content: data.Content, content_revision: data.ContentRevisionRO, comments) -> str:
+        f = open('tracim/lib/webdav/style.css', 'r')
+        style = f.read()
+        f.close()
 
         hist = content.get_history()
 
 	<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.1.0/jquery.min.js"></script>
 	<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">
 	<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css">
-	<link rel="stylesheet" href="/home/arnaud/Documents/css/style.css">
+	<style>%s</style>
 	<script type="text/javascript" src="/home/arnaud/Documents/css/script.js"></script>
 </head>
 <body>
 </body>
 </html>
         ''' % (content_revision.label,
+               style,
                content_revision.label,
                content.created.strftime("%B %d, %Y at %H:%m"),
                content.owner.display_name,
                content_revision.description,
                disc)
 
-        return page
+        return page

tracim/tracim/lib/webdav/sql_dav_provider.py

 # coding: utf8
 
-from tracim.lib.webdav import HistoryType
-from tracim.lib.webdav.lock_storage import LockStorage
-
 import re
 from os.path import basename, dirname, normpath
-from tracim.lib.content import ContentApi
-from tracim.lib.webdav import sql_resources
-from tracim.lib.user import UserApi
-from tracim.lib.workspace import WorkspaceApi
-from wsgidav import util
+
 from wsgidav.dav_provider import DAVProvider
 from wsgidav.lock_manager import LockManager
-from tracim.model.data import ContentType
-
-from tracim.lib.content import ContentRevisionRO
-######################################
-
-__docformat__ = "reStructuredText"
-_logger = util.getModuleLogger(__name__)
-
-
-def wsgi_decode(s):
-    return s.encode('latin1').decode()
-
-def wsgi_encode(s):
-    if isinstance(s, bytes):
-        return s.decode('latin1')
-    return s.encode().decode('latin1')
 
+from tracim.lib.webdav import HistoryType, SpecialFolderExtension
+from tracim.lib.webdav import sql_resources
+from tracim.lib.webdav.lock_storage import LockStorage
 
+from tracim.lib.content import ContentApi
+from tracim.lib.content import ContentRevisionRO
+from tracim.lib.user import UserApi
+from tracim.lib.workspace import WorkspaceApi
+from tracim.model.data import Content, Workspace
+from tracim.model.data import ContentType
 
 
-# ============================================================
-# PostgreSQLProvider
-# ============================================================
 class Provider(DAVProvider):
+    """
+    This class' role is to provide to wsgidav _DAVResource. Wsgidav will then use them to execute action and send
+    informations to the client
+    """
+
     def __init__(self, show_history=True, show_deleted=True, show_archived=True, manage_locks=True):
         super(Provider, self).__init__()
 
     def show_archive(self):
         return self._show_archive
 
-    def __repr__(self):
-        return 'Provider'
-
     #########################################################
     # Everything override from DAVProvider
-    def getResourceInst(self, path, environ):
-        #if not self.exists(path, environ):
-        #    return None
-        if not self.exists(path, environ):
-            return None
-
-        norm_path = normpath(path)
-
+    def getResourceInst(self, path: str, environ: dict):
+        """
+        Called by wsgidav whenever a request is called to get the _DAVResource corresponding to the path
+        """
+        path = normpath(path)
         root_path = environ['http_authenticator.realm']
-        parent_path = dirname(norm_path)
 
-        user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
+        # If the requested path is the root, then we return a Root resource
+        if path == root_path:
+            return sql_resources.Root(path, environ)
 
+        user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
         workspace_api = WorkspaceApi(user)
+        workspace = self.get_workspace_from_path(path, workspace_api)
+
+        # If the request path is in the form root/name, then we return a Workspace resource
+        parent_path = dirname(path)
+        if parent_path == root_path:
+            return sql_resources.Workspace(path, environ, workspace)
+
+        # And now we'll work on the path to establish which type or resource is requested
+
         content_api = ContentApi(
             user,
             show_archived=self._show_archive,
             show_deleted=self._show_delete
         )
 
-        # case we're requesting the root racine of webdav
-        if path == root_path:
-            return sql_resources.Root(path, environ)
-        # case we're at the root racine of a workspace
-        elif parent_path == root_path:
-            return sql_resources.Workspace(
-                path=norm_path,
-                environ=environ,
-                workspace=self.get_workspace_from_path(
-                    norm_path,
-                    workspace_api
-                )
-            )
-
         content = self.get_content_from_path(
-            path=norm_path,
+            path=path,
             content_api=content_api,
-            workspace_api=workspace_api
+            workspace=workspace
         )
 
-        # is archive
-        is_archived_folder = re.search(r'/\.archived$', norm_path) is not None
 
-        if self._show_archive and is_archived_folder:
-            return sql_resources.ArchivedFolder(
-                path=norm_path,
-                environ=environ,
-                content=content,
-                workspace=self.get_workspace_from_path(norm_path, workspace_api)
-            )
-
-        # is delete
-        is_deleted_folder = re.search(r'/\.deleted$', norm_path) is not None
-
-        if self._show_delete and is_deleted_folder:
-            return sql_resources.DeletedFolder(
-                path=norm_path,
-                environ=environ,
-                content=content,
-                workspace=self.get_workspace_from_path(norm_path, workspace_api)
-            )
+        # Easy cases : path either end with /.deleted, /.archived or /.history, then we return corresponding resources
+        if path.endswith(SpecialFolderExtension.Archived) and self._show_archive:
+            return sql_resources.ArchivedFolder(path, environ, workspace, content)
 
-        # is history
-        is_history_folder = re.search(r'/\.history$', norm_path) is not None
+        if path.endswith(SpecialFolderExtension.Deleted) and self._show_delete:
+            return sql_resources.DeletedFolder(path, environ, workspace, content)
 
-        if self._show_history and is_history_folder:
-            is_deleted_folder = re.search(r'/\.deleted/\.history$', norm_path) is not None
-            is_archived_folder = re.search(r'/\.archived/\.history$', norm_path) is not None
+        if path.endswith(SpecialFolderExtension.History) and self._show_history:
+            is_deleted_folder = re.search(r'/\.deleted/\.history$', path) is not None
+            is_archived_folder = re.search(r'/\.archived/\.history$', path) is not None
 
             type = HistoryType.Deleted if is_deleted_folder \
                 else HistoryType.Archived if is_archived_folder \
                 else HistoryType.Standard
 
-            return sql_resources.HistoryFolder(
-                path=norm_path,
-                environ=environ,
-                content=content,
-                type=type,
-                workspace=self.get_workspace_from_path(norm_path, workspace_api)
-            )
+            return sql_resources.HistoryFolder(path, environ, workspace, content, type)
 
-        # is history
-        is_history_file_folder = re.search(r'/\.history/([^/]+)$', norm_path) is not None
+        # Now that's more complicated, we're trying to find out if the path end with /.history/file_name
+        is_history_file_folder = re.search(r'/\.history/([^/]+)$', path) is not None
 
-        if self._show_history and is_history_file_folder:
+        if is_history_file_folder and self._show_history:
             return sql_resources.HistoryFileFolder(
-                path=norm_path,
+                path=path,
                 environ=environ,
                 content=content
             )
 
-        # is history
-        is_history_file = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) .+', norm_path) is not None
+        # And here next step :
+        is_history_file = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) .+', path) is not None
 
         if self._show_history and is_history_file:
-            content_revision = content_api.get_one_revision(re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) .+', norm_path).group(1))
+
+            revision_id = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) ([^/].+)$', path).group(1)
+
+            content_revision = content_api.get_one_revision(revision_id)
             content = self.get_content_from_revision(content_revision, content_api)
 
             if content.type == ContentType.File:
-                return sql_resources.HistoryFile(norm_path, environ, content, content_revision)
+                return sql_resources.HistoryFile(path, environ, content, content_revision)
             else:
-                return sql_resources.HistoryOtherFile(norm_path, environ, content, content_revision)
+                return sql_resources.HistoryOtherFile(path, environ, content, content_revision)
+
+        # And if we're still going, the client is asking for a standard Folder/File/Page/Thread so we check the type7
+        # and return the corresponding resource
 
-        # other
         if content is None:
             return None
         if content.type == ContentType.Folder:
-            return sql_resources.Folder(norm_path, environ, content, content.workspace)
+            return sql_resources.Folder(path, environ, content.workspace, content)
         elif content.type == ContentType.File:
-            return sql_resources.File(norm_path, environ, content)
-        elif content.type in [ContentType.Page, ContentType.Thread]:
-            return sql_resources.OtherFile(norm_path, environ, content)
+            return sql_resources.File(path, environ, content)
         else:
-            return None
+            return sql_resources.OtherFile(path, environ, content)
 
-    def exists(self, path, environ):
-        norm_path = normpath(path)
-        parent_path = dirname(norm_path)
-        root_path = environ['http_authenticator.realm']
+    def exists(self, path, environ) -> bool:
+        """
+        Called by wsgidav to check if a certain path is linked to a _DAVResource
+        """
 
-        user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
-        workspace_api = WorkspaceApi(user)
-        content_api = ContentApi(
-            current_user=user,
-            show_archived=True,
-            show_deleted=True
-        )
+        path = normpath(path)
+        working_path = self.reduce_path(path)
+        root_path = environ['http_authenticator.realm']
+        parent_path = dirname(working_path)
 
         if path == root_path:
             return True
-        elif parent_path == root_path:
-            return self.get_workspace_from_path(
-                    norm_path,
-                    workspace_api
-                ) is not None
 
-        is_archived = re.search(r'/\.archived/(\.history/)?(?!\.history)[^/]*(/\.)?(history|deleted|archived)?$', norm_path) is not None
+        user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
 
-        is_deleted = re.search(r'/\.deleted/(\.history/)?(?!\.history)[^/]*(/\.)?(history|deleted|archived)?$', norm_path) is not None
+        workspace = self.get_workspace_from_path(path, WorkspaceApi(user))
 
-        revision_id = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) ([^/].+)$', norm_path)
+        if parent_path == root_path:
+            return workspace is not None
 
-        blbl = self.reduce_path(norm_path)
-        if dirname(blbl) == '/':
-            return self.get_workspace_from_path(norm_path, workspace_api) is not None
+        content_api = ContentApi(user, show_archived=True, show_deleted=True)
+
+        revision_id = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) ([^/].+)$', path)
+
+        is_archived = self.is_path_archive(path)
+
+        is_deleted = self.is_path_delete(path)
 
         if revision_id:
             revision_id = revision_id.group(1)
             content = content_api.get_one_revision(revision_id)
         else:
-            content = self.get_content_from_path(norm_path, content_api, workspace_api)
+            content = self.get_content_from_path(working_path, content_api, workspace)
 
         return content is not None \
             and content.is_deleted == is_deleted \
             and content.is_archived == is_archived
 
-    def reduce_path(self, path):
+    def is_path_archive(self, path):
+        """
+        This function will check if a given path is linked to a file that's archived or not. We're checking if the
+        given path end with one of these string :
+
+        ex:
+            - /a/b/.archived/my_file
+            - /a/b/.archived/.history/my_file
+            - /a/b/.archived/.history/my_file/(3615 - edition) my_file
+        """
+
+        return re.search(
+            r'/\.archived/(\.history/)?(?!\.history)[^/]*(/\.)?(history|deleted|archived)?$',
+            path
+        ) is not None
+
+    def is_path_delete(self, path):
+        """
+        This function will check if a given path is linked to a file that's deleted or not. We're checking if the
+        given path end with one of these string :
+
+        ex:
+            - /a/b/.deleted/my_file
+            - /a/b/.deleted/.history/my_file
+            - /a/b/.deleted/.history/my_file/(3615 - edition) my_file
+        """
+
+        return re.search(
+            r'/\.deleted/(\.history/)?(?!\.history)[^/]*(/\.)?(history|deleted|archived)?$',
+            path
+        ) is not None
+
+    def reduce_path(self, path: str) -> str:
+        """
+        As we use the given path to request the database
+
+        ex: if the path is /a/b/.deleted/c/.archived, we're trying to get the archived content of the 'c' resource,
+        we need to keep the path /a/b/c
+
+        ex: if the path is /a/b/.history/my_file, we're trying to get the history of the file my_file, thus we need
+        the path /a/b/my_file
+
+        ex: if the path is /a/b/.history/my_file/(1985 - edition) my_old_name, we're looking for,
+        thus we remove all useless information
+        """
         path = re.sub(r'/\.archived', r'', path)
         path = re.sub(r'/\.deleted', r'', path)
         path = re.sub(r'/\.history/[^/]+/(\d+)-.+', r'/\1', path)
 
         return path
 
-    def get_content_from_path(self, path, content_api: ContentApi, workspace_api: WorkspaceApi):
+    def get_content_from_path(self, path, content_api: ContentApi, workspace: Workspace) -> Content:
+        """
+        Called whenever we want to get the Content item from the database for a given path
+        """
         path = self.reduce_path(path)
+        parent_path = dirname(path)
 
-        workspace = self.get_workspace_from_path(path, workspace_api)
+        blbl = parent_path.replace('/'+workspace.label, '')
+
+        parents = blbl.split('/')
+
+        parents.remove('')
+        parents = [self.transform_to_bdd(x) for x in parents]
 
         try:
-            if dirname(dirname(path)) == '/':
-                return content_api.get_one_by_label_and_parent(
-                    self.transform_to_bdd(basename(path)),
-                    workspace=workspace
-                )
-            else:
-                parent = self.get_parent_from_path(path, content_api, workspace_api)
-                if parent is not None:
-                    return content_api.get_one_by_label_and_parent(self.transform_to_bdd(basename(path)), content_parent=parent)
-                return None
+            return content_api.get_one_by_label_and_parent_label(
+                self.transform_to_bdd(basename(path)),
+                parents,
+                workspace
+            )
         except:
             return None
 
-    def get_content_from_revision(self, revision: ContentRevisionRO, api:ContentApi):
+    def get_content_from_revision(self, revision: ContentRevisionRO, api: ContentApi) -> Content:
         try:
             return api.get_one(revision.content_id, ContentType.Any)
         except:
             return None
 
-    def get_parent_from_path(self, path, api: ContentApi, workspace_api: WorkspaceApi):
-
-        return self.get_content_from_path(dirname(path), api, workspace_api)
-
-    def get_workspace_from_path(self, path: str, api: WorkspaceApi):
-        assert path.startswith('/')
+    def get_parent_from_path(self, path, api: ContentApi, workspace) -> Content:
+        return self.get_content_from_path(dirname(path), api, workspace)
 
+    def get_workspace_from_path(self, path: str, api: WorkspaceApi) -> Workspace:
         try:
             return api.get_one_by_label(self.transform_to_bdd(path.split('/')[1]))
         except:
             return None
 
     def transform_to_display(self, string):
+        """
+        As characters that Windows does not support may have been inserted through Tracim in names, before displaying
+        information we update path so that all these forbidden characters are replaced with similar shape character
+        that are allowed so that the user isn't trouble and isn't limited in his naming choice
+        """
         _TO_DISPLAY = {
             '/':'⧸',
             '\\': '⧹',
         return string
 
     def transform_to_bdd(self, string):
+        """
+        Called before sending request to the database to recover the right names
+        """
         _TO_BDD = {
             '⧸': '/',
             '⧹': '\\',
             string = string.replace(key, value)
 
         return string
-
-
-"""
-
-{'wsgidav.dump_request_body': False,
- 'wsgi.run_once': False,
- 'wsgi.multiprocess': False,
- 'wsgi.multithread': True,
- 'QUERY_STRING': '',
- 'REQUEST_URI': b'/nouveau/',
- 'wsgidav.dump_response_body': False,
- 'SERVER_PROTOCOL': 'HTTP/1.1',
- 'REMOTE_ADDR': '127.0.0.1',
- 'wsgidav.verbose': 1,
- 'wsgi.version': (1, 0),
- 'wsgidav.config': {
-     'middleware_stack':[],
-                       'propsmanager': None,
-                       'add_header_MS_Author_Via': True,
-                       'acceptbasic': True,
-                       'user_mapping': {},
-                       'enable_loggers': [],
-                       'locksmanager': True,
-                       'mount_path': None,
-                       'catchall': False,
-                       'unquote_path_info': False,
-                       'provider_mapping': {'': Provider},
-                       'port': 3030,
-                       'Provider': [],
-                       'verbose': 1,
-                       'SQLDomainController': [],
-                       'domaincontroller': [],
-     'acceptdigest': True,
-     'dir_browser': {
-         'ms_sharepoint_urls': False,
-         'ms_mount': False,
-         'davmount': False,
-         'enable': True,
-         'ms_sharepoint_plugin': True,
-         'response_trailer': ''
-     },
-     'defaultdigest': True,
-     'host': '0.0.0.0',
-     'ext_servers': ['cherrypy-bundled', 'wsgidav']
- },
- 'http_authenticator.realm': '/',
- 'HTTP_AUTHORIZATION': 'Digest username="admin@admin.admin",
- realm="/", nonce="=",
- uri="/nouveau/",
- algorithm=MD5,
- response="9c78c484263409b3385ead95ea7bf65b", '
- 'cnonce="MHgyMzNkZjkwOjQ4OTU6MTQ2OTc3OTI1NQ==", nc=00000471, qop=auth',
- 'HTTP_ACCEPT_ENCODING': 'gzip, deflate',
- 'HTTP_USER_AGENT': 'gvfs/1.22.2', 'wsgidav.debug_break': False,
- 'HTTP_CONNECTION': 'Keep-Alive', 'SERVER_PORT': '3030', 'CONTENT_LENGTH': '235', 'HTTP_HOST': '127.0.0.1:3030', 'REQUEST_METHOD': 'PROPFIND', 'HTTP_APPLY_TO_REDIRECT_REF': 'T', 'SERVER_NAME': 'WsgiDAV/3.0.0pre1 CherryPy/3.2.4 Python/3.4.2', 'wsgi.errors': <_io.TextIOWrapper name='<stderr>' mode='w' encoding='UTF-8'>, 'wsgi.url_scheme': 'http', 'user': <User: email='admin@admin.admin', display='Global manager'>, 'HTTP_ACCEPT_LANGUAGE': 'en-us, en;q=0.9', 'ACTUAL_SERVER_PROTOCOL': 'HTTP/1.1', 'REMOTE_PORT': '48375', 'CONTENT_TYPE': 'application/xml', 'SCRIPT_NAME': '', 'wsgi.input': <wsgidav.server.cherrypy.wsgiserver.wsgiserver3.KnownLengthRFile object at 0x7fbc8410ce48>, 'wsgidav.username': 'admin@admin.admin', 'http_authenticator.username': 'admin@admin.admin', 'wsgidav.provider': Provider, 'PATH_INFO': '/nouveau/', 'HTTP_DEPTH': '1', 'SERVER_SOFTWARE': 'WsgiDAV/3.0.0pre1 CherryPy/3.2.4 Python/3.4.2 Server'}
-"""

tracim/tracim/lib/webdav/sql_domain_controller.py

 
 from tracim.lib.user import UserApi
 
-class SQLDomainController(object):
-
+class TracimDomainController(object):
+    """
+    The domain controller is used by http_authenticator to authenticate the user every time a request is
+    sent
+    """
     def __init__(self, presetdomain = None, presetserver = None):
         self._api = UserApi(None)
 
     def getDomainRealm(self, inputURL, environ):
-
-        '''On va récupérer le workspace de travail pour travailler sur les droits'''
-
         return '/'
 
     def requireAuthentication(self, realmname, environ):
         return True
 
     def isRealmUser(self, realmname, username, environ):
-
-        '''travailler dans la bdd pour vérifier si utilisateur existe'''
-
+        """
+        Called to check if for a given root, the username exists (though here we don't make difference between
+        root as we're always starting at tracim's root
+        """
         try:
             self._api.get_one_by_email(username)
             return True
         except:
             return False
 
-    def getRealmUserPassword(self, realmname, username, environ):
-        '''Retourne le mdp pour l'utilisateur pour ce real'''
-        try:
-            user = self._api.get_one_by_email(username)
-            return user.password
-        except:
-            return None
-
     def get_left_digest_response_hash(self, realmname, username, environ):
+        """
+        Called by our http_authenticator to get the hashed md5 digest for the current user that is also sent by
+        the webdav client
+        """
         try:
             user = self._api.get_one_by_email(username)
-            environ['user_api'] = UserApi(user)
-            print("hey ! ", realmname)
             return user.webdav_left_digest_response_hash
         except:
             return None
 
     def authDomainUser(self, realmname, username, password, environ):
-        '''Vérifier que l'utilisateur est valide pour ce domaine'''
+        """
+        If you ever feel the need to send a request al-mano with a curl, this is the function that'll be called by
+        http_authenticator to validate the password sent
+        """
 
         return self.isRealmUser(realmname, username, environ) and \
             self._api.get_one_by_email(username).validate_password(password)

tracim/tracim/lib/webdav/sql_model.py

-from datetime import datetime
+#coding: utf8
 
 from sqlalchemy import Column
 from sqlalchemy import ForeignKey
-from sqlalchemy import Sequence
-from sqlalchemy.orm import deferred
-from sqlalchemy.types import DateTime, Integer, LargeBinary, Unicode, UnicodeText, Float
-
-from wsgidav.compat import to_unicode, to_bytes
-
-# ==================================================
-# Content
-# ==================================================
-class Workspace(object):
-    __tablename__ = 'my_workspaces'
-
-    workspace_id = Column(Integer, Sequence('my_seq__workspace__id'), autoincrement=True, primary_key=True)
-    label = Column(Unicode(255), unique=False, nullable=False, default=to_unicode(''))
-
-    created = Column(DateTime, unique=False, nullable=False, default=datetime.now)
-    updated = Column(DateTime, unique=False, nullable=False, default=datetime.now)
-
-    def __repr__(self):
-        return "<Workspace %s : %s>" % (self.workspace_id, self.label)
-
-
-class User(object):
-    __tablename__ = 'my_users'
-
-    user_id = Column(Integer, Sequence('my_seq__users__id'), autoincrement=True, primary_key=True)
-    display_name = Column(Unicode(255), unique=True, nullable=False, default=to_unicode(''))
-    password = Column(Unicode(255), unique=False, nullable=False, default=to_unicode(''))
-
-    def __repr__(self):
-        return "<User %s : %s>" % (self.user_id, self.display_name)
-
-
-class UserWorkspace(object):
-    __tablename__ = 'my_user_workspace'
-
-    workspace_id = Column(Integer, ForeignKey('my_workspaces.workspace_id', ondelete="CASCADE"), nullable=False, primary_key=True)
-    user_id = Column(Integer, ForeignKey('my_users.user_id', ondelete="CASCADE"), nullable=False, primary_key=True)
-    role = Column(Unicode(255), unique=False, nullable=False, default=u'NOT_APPLICABLE')
-
-    def __repr__(self):
-        return "<Role (W:%s, U:%s) : %s" % (self.workspace_id, self.user_id, self.role)
-
-
-class ItemRevision(object):
-    __tablename__ = 'my_items_revisions'
-
-    id = Column(Integer, Sequence('my_seq__items__id'), autoincrement=True, primary_key=True)
-    workspace_id = Column(Integer, ForeignKey('my_workspaces.workspace_id', ondelete="CASCADE"), nullable=False)
-    parent_id = Column(Integer, ForeignKey('my_items_revisions.id', ondelete="CASCADE"), nullable=True, default=None)
-
-    item_type = Column(Unicode(32), unique=False, nullable=False)
-    item_name = Column(Unicode(255), unique=False, nullable=False, default=to_unicode(''))
-    item_content = deferred(Column(LargeBinary(), unique=False, nullable=True, default=to_bytes('')))
-
-    created = Column(DateTime, unique=False, nullable=False, default=datetime.now)
-    updated = Column(DateTime, unique=False, nullable=False, default=datetime.now)
-
-    parent_revision_id = Column(Integer, ForeignKey('my_items_revisions.id', ondelete="CASCADE"), nullable=True, default=None)
-    child_revision_id = Column(Integer, ForeignKey('my_items_revisions.id', ondelete="CASCADE"), nullable=True, default=None)
-
-    def __repr__(self):
-        return "<Content %s : %s in %s>" % (self.id, self.item_name, self.parent_id)
+from sqlalchemy.types import Unicode, UnicodeText, Float
 
+from wsgidav.compat import to_unicode
 
 class Lock(object):
     __tablename__ = 'my_locks'

tracim/tracim/lib/webdav/sql_resources.py

 
 from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
 
-class Manage(object):
-    """Objet qui sert à encapsuler l'exécution des actions de l'api archive/delete..."""
+class ManageActions(object):
+    """
+    This object is used to encapsulate all Deletion/Archiving related method as to not duplicate too much code
+    """
     def __init__(self, action_type: str, api: ContentApi, content: Content):
         self.content_api = api
         self.content = content
 
     def action(self):
         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)
             raise DAVError(HTTP_FORBIDDEN)
         except NoResultFound:
-            """Exécute l'action"""
             with new_revision(self.content):
                 self.content_api.update_content(self.content, self._new_name)
                 self._actions[self._type](self.content)
 
             transaction.commit()
 
-    def make_name(self):
-        """Créer le nouveau nom : rajoute de - archive date / retrait de - archive date suivant l'action"""
+    def make_name(self) -> str:
+        """
+        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()
         extension = ''
-        is_file_name = self.content.label == ''
-
 
+        # if the content has no label, the last .ext is important
+        # thus we want to rename a file from 'file.txt' to 'file - deleted... .txt' and not 'file.txt - deleted...'
+        is_file_name = self.content.label == ''
         if is_file_name:
             extension = re.search(r'(\.[^.]+)$', new_name).group(0)
             new_name = re.sub(r'(\.[^.]+)$', '', new_name)
         if self._type in [ActionDescription.ARCHIVING, ActionDescription.DELETION]:
             new_name += ' - %s the %s' % (self._to_name[self._type], datetime.now().strftime('%d-%m-%Y at %H:%M'))
         else:
-            new_name = re.sub(r'( - (%s|%s) the .*)$' % (self._to_name[ActionDescription.DELETION], self._to_name[ActionDescription.ARCHIVING]), '', new_name)
+            new_name = re.sub(
+                r'( - (%s|%s) the .*)$' % (self._to_name[ActionDescription.DELETION], self._to_name[ActionDescription.ARCHIVING]),
+                '',
+                new_name
+            )
 
         new_name += extension
 
 
 
 class Root(DAVCollection):
-    """Root ressource that represents tracim's home, which contains all workspaces"""
+    """
+    Root ressource that represents tracim's home, which contains all workspaces
+    """
 
     def __init__(self, path: str, environ: dict):
         super(Root, self).__init__(path, environ)
     def getMemberNames(self) -> [str]:
         """
         This method returns the names (here workspace's labels) of all its children
+
+        Though for perfomance issue, we're not using this function anymore
         """
         return [workspace.label for workspace in self.workspace_api.get_all()]
 
     def getMember(self, label: str) -> DAVCollection:
         """
         This method returns the child Workspace that corresponds to a given name
+
+        Though for perfomance issue, we're not using this function anymore
         """
         try:
             workspace = self.workspace_api.get_one_by_label(label)
         This method is called whenever the user wants to create a DAVNonCollection resource (files in our case).
 
         There we don't allow to create files at the root;
-        only workspaces (thus collection) can be created."""
+        only workspaces (thus collection) can be created.
+        """
         raise DAVError(HTTP_FORBIDDEN)
 
     def createCollection(self, name: str):
 
         [For now] we don't allow to create new workspaces through
         webdav client. Though if we come to allow it, deleting the error's raise will
-        make it possible."""
+        make it possible.
+        """
         # TODO : remove comment here
         # raise DAVError(HTTP_FORBIDDEN)
 
         return Workspace(workspace_path, self.environ, new_workspace)
 
     def getMemberList(self):
-        # De base on appellerait getMemberNames puis getMember, mais ça fait trop de requête alors on optimise :
-        # on fait une seule requête en BDD; get_all et voilà !
+        """
+        This method is called by wsgidav when requesting with a depth > 0, it will return a list of _DAVResource
+        of all its direct children
+        """
 
         members = []
         for workspace in self.workspace_api.get_all():
 
 
 class Workspace(DAVCollection):
-    """Workspace resource corresponding to tracim's workspaces.
-    Direct children can only be folders, though files might come later on"""
+    """
+    Workspace resource corresponding to tracim's workspaces.
+    Direct children can only be folders, though files might come later on and are supported
+    """
 
     def __init__(self, path: str, environ: dict, workspace: data.Workspace):
         super(Workspace, self).__init__(path, environ)
         )
 
     def createEmptyResource(self, file_name: str):
-        """[For now] we don't allow to create files right under workspaces.
-        Though if we come to allow it, deleting the error's raise will make it possible."""
+        """
+        [For now] we don't allow to create files right under workspaces.
+        Though if we come to allow it, deleting the error's raise will make it possible.
+        """
         # TODO : remove commentary here raise DAVError(HTTP_FORBIDDEN)
         if '/.deleted/' in self.path or '/.archived/' in self.path:
             raise DAVError(HTTP_FORBIDDEN)
             content_api=self.content_api,
             workspace=self.workspace,
             content=None,
-            parent=self.content
+            parent=self.content,
+            path=self.path + '/' + file_name
         )
 
     def createCollection(self, label: str) -> 'Folder':
-        """Create a new folder for the current workspace. As it's not possible for the user to choose
+        """
+        Create a new folder for the current workspace. As it's not possible for the user to choose
         which types of content are allowed in this folder, we allow allow all of them.
 
-        This method return the DAVCollection created."""
+        This method return the DAVCollection created.
+        """
 
         if '/.deleted/' in self.path or '/.archived/' in self.path:
             raise DAVError(HTTP_FORBIDDEN)
         return True
 
     def moveRecursive(self, destpath):
-        if dirname(normpath(destpath)) == self.provider.root:
+        if dirname(normpath(destpath)) == self.environ['http_authenticator.realm']:
             self.workspace.label = basename(normpath(destpath))
             transaction.commit()
         else:
 
     def getMemberList(self) -> [_DAVResource]:
         members = []
-        parent_id = None if self.content is None else self.content.id
 
-        childs = self.content_api.get_all(parent_id, ContentType.Any, self.workspace)
+        children = self.content_api.get_all(None, ContentType.Any, self.workspace)
 
-        for content in childs:
+        for content in children:
             content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
 
             if content.type == ContentType.Folder:
-                members.append(Folder(content_path, self.environ, content, self.workspace))
+                members.append(Folder(content_path, self.environ, self.workspace, content))
             elif content.type == ContentType.File:
                 self._file_count += 1
                 members.append(File(content_path, self.environ, content))
                     workspace=self.workspace
                 )
             )
+
         return members
 
 
 class Folder(Workspace):
-    """Folder resource corresponding to tracim's folders.
+    """
+    Folder resource corresponding to tracim's folders.
     Direct children can only be either folder, files, pages or threads
-    By default when creating new folders, we allow them to contain all types of content"""
+    By default when creating new folders, we allow them to contain all types of content
+    """
 
-    def __init__(self, path: str, environ: dict, content: data.Content, workspace: data.Workspace):
+    def __init__(self, path: str, environ: dict, workspace: data.Workspace, content: data.Content):
         super(Folder, self).__init__(path, environ, workspace)
 
         self.content = content
         return mktime(self.content.updated.timetuple())
 
     def delete(self):
-        Manage(ActionDescription.DELETION, self.content_api, self.content).action()
+        ManageActions(ActionDescription.DELETION, self.content_api, self.content).action()
 
     def supportRecursiveMove(self, destpath: str):
         return True
 
     def moveRecursive(self, destpath: str):
-        """As we support recursive move, copymovesingle won't be called, though with copy it'll be called
-        but i have to check if the client ever call that function..."""
+        """
+        As we support recursive move, copymovesingle won't be called, though with copy it'll be called
+        but i have to check if the client ever call that function...
+        """
         destpath = normpath(destpath)
 
         invalid_path = False
             current_path = re.sub(r'/\.(deleted|archived)', '', self.path)
 
             if current_path == destpath:
-                Manage(
+                ManageActions(
                     ActionDescription.UNDELETION if self.content.is_deleted else ActionDescription.UNARCHIVING,
                     self.content_api,
                     self.content
             dest_path = re.sub(r'/\.(deleted|archived)', '', destpath)
 
             if dest_path == self.path:
-                Manage(
+                ManageActions(
                     ActionDescription.DELETION if '.deleted' in destpath else ActionDescription.ARCHIVING,
                     self.content_api,
                     self.content
             raise DAVError(HTTP_FORBIDDEN)
 
     def move_folder(self, destpath):
-        parent = self.provider.get_parent_from_path(
-            normpath(destpath),
-            self.content_api,
-            WorkspaceApi(self.user)
-        )
 
+        workspace_api = WorkspaceApi(self.user)
         workspace = self.provider.get_workspace_from_path(
+            normpath(destpath), workspace_api
+        )
+
+        parent = self.provider.get_parent_from_path(
             normpath(destpath),
-            WorkspaceApi(self.user)
+            self.content_api,
+            workspace
         )
 
         with new_revision(self.content):
                 self.content_api.update_content(self.content, self.provider.transform_to_bdd(basename(destpath)))
                 self.content_api.save(self.content)
             else:
-                try:
-                    workspace_id = parent.workspace.workspace_id
-                except AttributeError:
-                    workspace_id = self.provider.get_workspace_from_path(
-                        destpath, WorkspaceApi(self.user)
-                    ).workspace_id
-
-                if workspace_id == self.content.workspace.workspace_id:
+                if workspace.workspace_id == self.content.workspace.workspace_id:
                     self.content_api.move(self.content, parent)
                 else:
-                    try:
-                        self.content_api.move_recursively(self.content, parent, parent.workspace)
-                    except AttributeError:
-                        self.content_api.move_recursively(self.content, parent, workspace)
+                    self.content_api.move_recursively(self.content, parent, workspace)
 
         transaction.commit()
 
+    def getMemberList(self) -> [_DAVResource]:
+        members = []
+
+        for content in self.content.children:
+            content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
 
-class HistoryFolder(Folder):
+            if content.type == ContentType.Folder:
+                members.append(Folder(content_path, self.environ, self.workspace, content))
+            elif content.type == ContentType.File:
+                self._file_count += 1
+                members.append(File(content_path, self.environ, content))
+            else:
+                self._file_count += 1
+                members.append(OtherFile(content_path, self.environ, content))
+
+        if self._file_count > 0 and self.provider.show_history():
+            members.append(
+                HistoryFolder(
+                    path=self.path + '/' + ".history",
+                    environ=self.environ,
+                    content=self.content,
+                    workspace=self.workspace,
+                    type=HistoryType.Standard
+                )
+            )
+
+        if self.provider.show_delete():
+            members.append(
+                DeletedFolder(
+                    path=self.path + '/' + ".deleted",
+                    environ=self.environ,
+                    content=self.content,
+                    workspace=self.workspace
+                )
+            )
+
+        if self.provider.show_archive():
+            members.append(
+                ArchivedFolder(
+                    path=self.path + '/' + ".archived",
+                    environ=self.environ,
+                    content=self.content,
+                    workspace=self.workspace
+                )
+            )
+
+        return members
 
-    def __init__(self, path, environ, workspace: data.Workspace, type: str, content: data.Content=None):
-        super(HistoryFolder, self).__init__(path, environ, content, workspace)
+
+class HistoryFolder(Folder):
+    """
+    A virtual resource which contains a sub-folder for every files (DAVNonCollection) contained in the parent
+    folder
+    """
+    
+    def __init__(self, path, environ, workspace: data.Workspace,
+                 content: data.Content=None, type: str=HistoryType.Standard):
+        super(HistoryFolder, self).__init__(path, environ, workspace, content)
 
         self._is_archived = type == HistoryType.Archived
         self._is_deleted = type == HistoryType.Deleted
 
     def getMemberList(self) -> [_DAVResource]:
         members = []
-
-        parent_id = None if self.content is None else self.content.id
-
-        for content in self.content_api.get_all_with_filter(parent_id, ContentType.Any, self.workspace):
+        
+        if self.content:
+            children = self.content.children
+        else:
+            children = self.content_api.get_all(None, ContentType.Any, self.workspace)
+        
+        for content in children:
             members.append(HistoryFileFolder(
                 path='%s/%s' % (self.path, content.get_label()),
                 environ=self.environ,
 
 
 class DeletedFolder(HistoryFolder):
+    """
+    A virtual resources which exists for every folder or workspaces which contains their deleted children
+    """
+
     def __init__(self, path: str, environ: dict, workspace: data.Workspace, content: data.Content=None):
-        super(DeletedFolder, self).__init__(path, environ, workspace, HistoryType.Deleted, content)
+        super(DeletedFolder, self).__init__(path, environ, workspace, content, HistoryType.Deleted)
 
         self._file_count = 0
 
     def getMemberNames(self) -> [str]:
         retlist = []
 
-        for content in self.content_api.get_all(
-                parent_id=self.content if self.content is None else self.content.id, content_type=ContentType.Any):
+        if self.content:
+            children = self.content.children
+        else:
+            children = self.content_api.get_all(None, ContentType.Any, self.workspace)
+
+        for content in children:
             if content.is_deleted:
                 retlist.append(content.get_label())
 
 
         return retlist
 
-    def createEmptyResource(self, name: str):
-        raise DAVError(HTTP_FORBIDDEN)
-
-    def createCollection(self, name: str):
-        raise DAVError(HTTP_FORBIDDEN)
-
-    def delete(self):
-        raise DAVError(HTTP_FORBIDDEN)
-
     def getMemberList(self) -> [_DAVResource]:
         members = []
 
-        parent_id = None if self.content is None else self.content.id
+        if self.content:
+            children = self.content.children
+        else:
+            children = self.content_api.get_all(None, ContentType.Any, self.workspace)
 
-        for content in self.content_api.get_all_with_filter(parent_id, ContentType.Any, self.workspace):
+        for content in children:
             content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
 
             if content.type == ContentType.Folder:
-                members.append(Folder(content_path, self.environ, content, self.workspace))
+                members.append(Folder(content_path, self.environ, self.workspace, content))
             elif content.type == ContentType.File:
                 self._file_count += 1
                 members.append(File(content_path, self.environ, content))
 
 
 class ArchivedFolder(HistoryFolder):
+    """
+    A virtual resources which exists for every folder or workspaces which contains their archived children
+    """
     def __init__(self, path: str, environ: dict, workspace: data.Workspace, content: data.Content=None):
-        super(ArchivedFolder, self).__init__(path, environ, workspace, HistoryType.Archived, content)
+        super(ArchivedFolder, self).__init__(path, environ, workspace, content, HistoryType.Archived)
 
         self._file_count = 0
 
 
         return retlist
 
-    def createEmptyResource(self, name):
-        raise DAVError(HTTP_FORBIDDEN)
-
-    def createCollection(self, name):
-        raise DAVError(HTTP_FORBIDDEN)
-
-    def delete(self):
-        raise DAVError(HTTP_FORBIDDEN)
-
     def getMemberList(self) -> [_DAVResource]:
         members = []
 
-        parent_id = None if self.content is None else self.content.id
+        if self.content:
+            children = self.content.children
+        else:
+            children = self.content_api.get_all(None, ContentType.Any, self.workspace)
 
-        for content in self.content_api.get_all_with_filter(parent_id, ContentType.Any, self.workspace):
+        for content in children:
             content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
 
             if content.type == ContentType.Folder:
-                members.append(Folder(content_path, self.environ, content, self.workspace))
+                members.append(Folder(content_path, self.environ, self.workspace, content))
             elif content.type == ContentType.File:
                 self._file_count += 1
                 members.append(File(content_path, self.environ, content))
 
 
 class HistoryFileFolder(HistoryFolder):
+    """
+    A virtual resource that contains for a given content (file/page/thread) all its revisions
+    """
+
     def __init__(self, path: str, environ: dict, content: data.Content):
-        super(HistoryFileFolder, self).__init__(path, environ, content.workspace, HistoryType.All, content)
+        super(HistoryFileFolder, self).__init__(path, environ, content.workspace, content, HistoryType.All)
 
     def __repr__(self) -> str:
         return "<DAVCollection: HistoryFileFolder (%s)" % self.content.file_name
     def createCollection(self, name):
         raise DAVError(HTTP_FORBIDDEN)
 
-    def createEmptyResource(self, name) ->FakeFileStream:
-        return FakeFileStream(
-            content=self.content,
-            content_api=self.content_api,
-            file_name=name,
-            workspace=self.content.workspace
-        )
-
     def getMemberNames(self) -> [int]:
-        """ Usually we would return a string, but here as it can be the same name because that's history, we get the id"""
+        """
+        Usually we would return a string, but here as we're working with different
+        revisions of the same content, we'll work with revision_id
+        """
         ret = []
 
         for content in self.content.revisions:
                 content=self.content,
                 content_revision=revision)
 
-    def delete(self):
-        raise DAVError(HTTP_FORBIDDEN)
-
     def getMemberList(self) -> [_DAVResource]:
         members = []
 
 
 
 class File(DAVNonCollection):
+    """
+    File resource corresponding to tracim's files
+    """
     def __init__(self, path: str, environ: dict, content: Content):
         super(File, self).__init__(path, environ)
 
         self.user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
         self.content_api = ContentApi(self.user)
 
+        # this is the property that windows client except to check if the file is read-write or read-only,
+        # 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())
             content=self.content,
             content_api=self.content_api,
             file_name=self.content.get_label(),
-            workspace=self.content.workspace
+            workspace=self.content.workspace,
+            path=self.path
         )
 
     def moveRecursive(self, destpath):
             current_path = re.sub(r'/\.(deleted|archived)', '', self.path)
 
             if current_path == destpath:
-                Manage(
+                ManageActions(
                     ActionDescription.UNDELETION if self.content.is_deleted else ActionDescription.UNARCHIVING,
                     self.content_api,
                     self.content
             dest_path = re.sub(r'/\.(deleted|archived)', '', destpath)
 
             if dest_path == self.path:
-                Manage(
+                ManageActions(
                     ActionDescription.DELETION if '.deleted' in destpath else ActionDescription.ARCHIVING,
                     self.content_api,
                     self.content
         return True
 
     def delete(self):
-        Manage(ActionDescription.DELETION, self.content_api, self.content).action()
+        ManageActions(ActionDescription.DELETION, self.content_api, self.content).action()
 
 
 class HistoryFile(File):
+    """
+    A virtual resource corresponding to a specific tracim's revision's file
+    """
     def __init__(self, path: str, environ: dict, content: data.Content, content_revision: data.ContentRevisionRO):
         super(HistoryFile, self).__init__(path, environ, content)
         self.content_revision = content_revision
     def delete(self):
         raise DAVError(HTTP_FORBIDDEN)
 
-    def handleDelete(self):
-        return False
-
-    def handleCopy(self, destpath, depth_infinity):
-        return True
-
-    def handleMove(self, destpath):
-        return True
-
     def copyMoveSingle(self, destpath, ismove):
         raise DAVError(HTTP_FORBIDDEN)
 
 
 class OtherFile(File):
+    """
+    File resource corresponding to tracim's page and thread
+    """
     def __init__(self, path: str, environ: dict, content: data.Content):
         super(OtherFile, self).__init__(path, environ, content)
 
 
         self.content_designed = self.design()
 
-        # workaroung for consistent request as we have to return a resource with a path ending with .html
+        # workaround for consistent request as we have to return a resource with a path ending with .html
         # when entering folder for windows, but only once because when we select it again it would have .html.html
         # which is no good
         if not self.path.endswith('.html'):
 
 
 class HistoryOtherFile(OtherFile):
+    """
+    A virtual resource corresponding to a specific tracim's revision's page and thread
+    """
     def __init__(self, path: str, environ: dict, content: data.Content, content_revision: data.ContentRevisionRO):
         super(HistoryOtherFile, self).__init__(path, environ, content)
         self.content_revision = content_revision
 
         return filestream
 
-    def beginWrite(self, contentType=None):
-        raise DAVError(HTTP_FORBIDDEN)
-
     def delete(self):
         raise DAVError(HTTP_FORBIDDEN)
 
-    def handleDelete(self):
-        return True
-
-    def handleCopy(self, destpath, depth_infinity):
-        return True
-
-    def handleMove(self, destpath):
-        return True
-
     def copyMoveSingle(self, destpath, ismove):
         raise DAVError(HTTP_FORBIDDEN)
-

tracim/tracim/lib/webdav/style.css

-body {
-    background: red
+.title {
+	background:#F5F5F5;
+	padding-right:15px;
+	padding-left:15px;
+	padding-top:10px;
+	border-bottom:1px solid #CCCCCC;
+	overflow:auto;
+} .title h1 { margin-top:0; }
+
+.content {
+	padding: 15px;
+}
+
+#left{ padding:0; }
+
+#right {
+	background:#F5F5F5;
+	border-left:1px solid #CCCCCC;
+	border-bottom: 1px solid #CCCCCC;
+	padding-top:15px;
+}
+@media (max-width: 1200px) {
+	#right {
+		border-top:1px solid #CCCCCC;
+		border-left: none;
+		border-bottom: none;
+	}
+}
+
+body { overflow:auto; }
+
+.btn {
+	text-align: left;
+}
+
+.table tbody tr .my-align {
+	vertical-align:middle;
+}
+
+.title-icon {
+	font-size:2.5em;
+	float:left;
+	margin-right:10px;
+}
+.title.page, .title-icon.page { color:#00CC00; }
+.title.thread, .title-icon.thread { color:#428BCA; }
+
+/* ****************************** */
+.description-icon {
+	color:#999;
+	font-size:3em;
+}
+
+.description {
+	border-left: 5px solid #999;
+	padding-left: 10px;
+	margin-left: 10px;
+	margin-bottom:10px;
+}
+
+.description-text {
+	display:block;
+	overflow:hidden;
+	color:#999;
+}
+
+.comment-row:nth-child(2n) {
+	background-color:#F5F5F5;
+}
+
+.comment-row:nth-child(2n+1) {
+	background-color:#FFF;
+}
+
+.comment-icon {
+	color:#CCC;
+	font-size:3em;
+	display:inline-block;
+	margin-right: 10px;
+	float:left;
+}
+
+.comment-content {
+	display:block;
+	overflow:hidden;
+}
+
+.comment, .comment-revision {
+	padding:10px;
+	border-top: 1px solid #999;
+}
+
+.comment-revision-icon {
+	color:#777;
+	margin-right: 10px;
+}
+
+.title-text {
+	display: inline-block;
 }