correction of some behavior and working on new deletion/archiving behavior

tracim/tracim/lib/content.py

 
         return self._base_query(workspace).filter(Content.content_id==content_id).filter(Content.type==content_type).one()
 
-    def get_one_revision(self, revision_id: int = None) -> Content:
+    def get_one_revision(self, revision_id: int = None) -> ContentRevisionRO:
         """
         This method allow us to get directly any revision with its id
         :param revision_id: The content's revision's id that we want to return
         """
         assert revision_id is not None# DYN_REMOVE
 
-        revision = DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.revision_id == revision_id)
-        
-        result = self._base_query(None)
+        revision = DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.revision_id == revision_id).one()
 
-        return result.filter(Content.revision_id == revision_id).one()
+        return revision
 
     def get_one_by_label_and_parent(self, content_label: str, content_parent: Content = None,
                                     workspace: Workspace = None) -> Content:

tracim/tracim/lib/webdav/__init__.py

         self._file_name = file_name if file_name != '' else self._content.file_name
         self._content = content
         self._api = content_api
+        self._is_new_file = new_file
 
-    def beginWrite(self, contentType) -> FileStream:
+    def beginWrite(self, contentType) -> 'FileStream':
         return self
 
     def endWrite(self, withErrors: bool):
         for part in self._buffer:
             item_content += part
 
-        if new_file:
+        if self._is_new_file:
             file = self._api.create(
                 content_type=ContentType.File,
                 workspace=self._content.workspace,

tracim/tracim/lib/webdav/design.py

+from tracim.model.data import VirtualEvent
+from tracim.model import data
+from tracim.model.data import ContentType
+from datetime import datetime
+
+def create_readable_date(created, delta_from_datetime: datetime = None):
+    aff = ''
+
+    if not delta_from_datetime:
+        delta_from_datetime = datetime.now()
+
+    delta = delta_from_datetime - created
+
+    if delta.days > 0:
+        if delta.days >= 365:
+            aff = '%d year%s ago' % (delta.days / 365, 's' if delta.days / 365 >= 2 else '')
+        elif delta.days >= 30:
+            aff = '%d month%s ago' % (delta.days / 30, 's' if delta.days / 30 >= 2 else '')
+        else:
+            aff = '%d day%s ago' % (delta.days, 's' if delta.days >= 2 else '')
+    else:
+        if delta.seconds < 60:
+            aff = '%d second%s ago' % (delta.seconds, 's' if delta.seconds > 1 else '')
+        elif delta.seconds / 60 < 60:
+            aff = '%d minute%s ago' % (delta.seconds / 60, 's' if delta.seconds / 60 >= 2 else '')
+        else:
+            aff = '%d hour%s ago' % (delta.seconds / 3600, 's' if delta.seconds / 3600 >= 2 else '')
+
+    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()
+
+    hist = content.get_history()
+    histHTML = '<table class="table table-striped table-hover">'
+    for event in hist:
+        if isinstance(event, VirtualEvent):
+            date = event.create_readable_date()
+            _LABELS = {
+                'archiving': 'Item archived',
+                'content-comment': 'Item commented',
+                'creation': 'Item created',
+                'deletion': 'Item deleted',
+                'edition': 'item modified',
+                'revision': 'New revision',
+                'status-update': 'New status',
+                'unarchiving': 'Item unarchived',
+                'undeletion': 'Item undeleted',
+                'move': 'Item moved'
+            }
+
+            label = _LABELS[event.type.id]
+
+            histHTML += '''
+                <tr class="%s">
+                    <td class="my-align"><span class="label label-default"><i class="fa %s"></i> %s</span></td>
+                    <td>%s</td>
+                    <td>%s</td>
+                    <td>%s</td>
+                </tr>
+                ''' % ('warning' if event.id == content_revision.revision_id else '',
+                       event.type.icon,
+                       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_revision.label, event.id, event.ref_object.label) if event.type.id in ['revision', 'creation', 'edition'] else '')
+
+    histHTML += '</table>'
+
+    file = '''
+<html>
+<head>
+	<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">
+	<script type="text/javascript" src="/home/arnaud/Documents/css/script.js"></script>
+</head>
+<body>
+    <div id="left" class="col-lg-8 col-md-12 col-sm-12 col-xs-12">
+        <div class="title page">
+            <div class="title-text">
+                <i class="fa fa-file-text-o title-icon page"></i>
+                <h1>%s</h1>
+                <h6>page created on <b>%s</b> by <b>%s</b></h6>
+            </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>
+                </div>
+            </div>
+        </div>
+        <div class="content col-xs-12 col-sm-12 col-md-12 col-lg-12">
+            %s
+        </div>
+    </div>
+    <div id="right" class="col-lg-4 col-md-12 col-sm-12 col-xs-12">
+        <h4>History</h4>
+        %s
+    </div>
+    <script type="text/javascript">
+        window.onload = function() {
+            elems = document.getElementsByClassName('revision-link');
+            for(var i = 0; i<elems.length; i++) {
+                test = window.location.href
+                test += "/.." + elems[i].href.replace(/file:\/\//, "")
+                elems[i].href = test
+            }
+        }
+    </script>
+</body>
+</html>
+        ''' % (content_revision.label,
+               content_revision.label,
+               content.created.strftime("%B %d, %Y at %H:%m"),
+               content.owner.display_name,
+               content_revision.description,
+               histHTML)
+
+    return file
+
+def designThread(content: data.Content, content_revision: data.ContentRevisionRO, comments) -> str:
+
+        hist = content.get_history()
+
+        allT = []
+        allT += comments
+        allT += hist
+        allT.sort(key=lambda x: x.created, reverse=True)
+
+        disc = ''
+        participants = {}
+        for t in allT:
+            if t.type == ContentType.Comment:
+                disc += '''
+                    <div class="row comment comment-row">
+                        <i class="fa fa-comment-o comment-icon"></i>
+                            <div class="comment-content">
+                            <h5>
+                                <span class="comment-author"><b>%s</b> wrote :</span>
+                                <div class="pull-right text-right">%s</div>
+                            </h5>
+                            %s
+                        </div>
+                    </div>
+                    ''' % (t.owner.display_name, create_readable_date(t.created), t.description)
+
+                if t.owner.display_name not in participants:
+                    participants[t.owner.display_name] = [1, t.created]
+                else:
+                    participants[t.owner.display_name][0] += 1
+            else:
+                if isinstance(t, VirtualEvent) and t.type.id != 'comment':
+                    _LABELS = {
+                        'archiving': 'Item archived',
+                        'content-comment': 'Item commented',
+                        'creation': 'Item created',
+                        'deletion': 'Item deleted',
+                        'edition': 'item modified',
+                        'revision': 'New revision',
+                        'status-update': 'New status',
+                        'unarchiving': 'Item unarchived',
+                        'undeletion': 'Item undeleted',
+                        'move': 'Item moved',
+                        'comment' : 'hmmm'
+                    }
+
+                    label = _LABELS[t.type.id]
+
+                    disc += '''
+                    <div class="row comment comment-row to-hide">
+                        <i class="fa %s comment-icon"></i>
+                            <div class="comment-content">
+                            <h5>
+                                <span class="comment-author"><b>%s</b></span>
+                                <div class="pull-right text-right">%s</div>
+                            </h5>
+                            %s %s
+                        </div>
+                    </div>
+                    ''' % (t.type.icon,
+                           t.owner.display_name,
+                           t.create_readable_date(),
+                           label,
+                           '''<span><a class="revision-link" href="/.history/%s/%s-%s">(View revision)</a></span>''' % (
+                               content_revision.label,
+                               t.id,
+                               t.ref_object.label) if t.type.id in ['revision', 'creation', 'edition'] else '')
+
+        page = '''
+<html>
+<head>
+	<title>%s</title>
+	<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">
+	<script type="text/javascript" src="/home/arnaud/Documents/css/script.js"></script>
+</head>
+<body>
+    <div id="left" class="col-lg-12 col-md-12 col-sm-12 col-xs-12">
+        <div class="title thread">
+            <div class="title-text">
+                <i class="fa fa-comments-o title-icon thread"></i>
+                <h1>%s</h1>
+                <h6>thread created on <b>%s</b> by <b>%s</b></h6>
+            </div>
+            <div class="pull-right">
+                <div class="btn-group btn-group-vertical">
+                    <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>
+                    <a class="btn btn-default">
+                        <i class="fa fa-external-link"></i> View in tracim</a>
+                    </a>
+                </div>
+            </div>
+        </div>
+        <div class="content col-xs-12 col-sm-12 col-md-12 col-lg-12">
+            <div class="description">
+                <span class="description-text">%s</span>
+            </div>
+            %s
+        </div>
+    </div>
+    <script type="text/javascript">
+        window.onload = function() {
+            elems = document.getElementsByClassName('revision-link');
+            for(var i = 0; i<elems.length; i++) {
+                test = window.location.href
+                test += "/.." + elems[i].href.replace(/file:\/\//, "")
+                elems[i].href = test
+            }
+        }
+
+        function hide_elements() {
+            elems = document.getElementsByClassName('to-hide');
+            if (elems.length > 0) {
+                for(var i = 0; i < elems.length; i++) {
+                    $(elems[i]).addClass('to-show')
+                    $(elems[i]).hide();
+                }
+                while (elems.length>0) {
+                    $(elems[0]).removeClass('to-hide');
+                }
+                $('#hideshow').addClass('fa-eye').removeClass('fa-eye-slash');
+                $('#hideshowtxt').html('Show history');
+            }
+            else {
+                elems = document.getElementsByClassName('to-show');
+                for(var i = 0; i<elems.length; i++) {
+                    $(elems[i]).addClass('to-hide');
+                    $(elems[i]).show();
+                }
+                while (elems.length>0) {
+                    $(elems[0]).removeClass('to-show');
+                }
+                $('#hideshow').removeClass('fa-eye').addClass('fa-eye-slash');
+                $('#hideshowtxt').html('Hide history');
+            }
+        }
+    </script>
+</body>
+</html>
+        ''' % (content_revision.label,
+               content_revision.label,
+               content.created.strftime("%B %d, %Y at %H:%m"),
+               content.owner.display_name,
+               content_revision.description,
+               disc)
+
+        return page

tracim/tracim/lib/webdav/lock_storage.py

 import time
 
 from tracim.lib.webdav.sql_model import Lock, Url2Token
-from tracim.lib.webdav import Session
 from wsgidav import util
 from wsgidav.lock_manager import normalizeLockRoot, lockString, generateLockToken, validateLock
 from wsgidav.rw_lock import ReadWriteLock
     LOCK_TIME_OUT_MAX = 4 * 604800  # 1 month, in seconds
 
     def __init__(self):
-        self._session = Session()
+        self._session = None# todo Session()
         self._lock = ReadWriteLock()
 
     def __repr__(self):

tracim/tracim/lib/webdav/sql_dav_provider.py

 from wsgidav.lock_manager import LockManager
 from tracim.model.data import ContentType
 
+from tracim.lib.content import ContentRevisionRO
 ######################################
 
 __docformat__ = "reStructuredText"
         if manage_lock:
             self.lockManager = LockManager(LockStorage())
 
+        self._show_archive = True
+        self._show_delete = True
+        self._show_history = True
+
+    def show_history(self):
+        return self._show_history
+
+    def show_delete(self):
+        return self._show_delete
+
+    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
 
-        working_path = path
-
-        if not self.exists(path, environ):
-            return None
-
-        if path == "/":
-            return sql_resources.Root(path, environ)
-
-        norm_path = normpath(working_path)
+        norm_path = normpath(path)
+        root_path = environ['http_authenticator.realm']
+        parent_path = dirname(norm_path)
 
         workspace_api = WorkspaceApi(environ['user'])
+        content_api = ContentApi(
+            environ['user'],
+            show_archived=self._show_archive,
+            show_deleted=self._show_delete
+        )
 
-        if dirname(norm_path) == "/":
-            workspace = self.get_workspace_from_path(norm_path, workspace_api)
-            return sql_resources.Workspace(path, environ, workspace)
-
-
-        api = ContentApi(environ['user'], show_archived=True, show_deleted=True)
-
-        working_path = self.reduce_path(path)
+        # 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(working_path, api, workspace_api)
+        content = self.get_content_from_path(
+            path=norm_path,
+            content_api=content_api,
+            workspace_api=workspace_api
+        )
 
         # is archive
         is_archived_folder = re.search(r'/\.archived$', norm_path) is not None
 
-        if is_archived_folder:
-            return sql_resources.ArchivedFolder(path, environ, content)
+        if self._show_archive and is_archived_folder:
+            return sql_resources.ArchivedFolder(
+                path=norm_path,
+                environ=environ,
+                content=content,
+            )
 
         # is delete
         is_deleted_folder = re.search(r'/\.deleted$', norm_path) is not None
 
-        if is_deleted_folder:
-            return sql_resources.DeletedFolder(path, environ, content)
+        if self._show_delete and is_deleted_folder:
+            return sql_resources.DeletedFolder(
+                path=norm_path,
+                environ=environ,
+                content=content
+            )
 
         # is history
         is_history_folder = re.search(r'/\.history$', norm_path) is not None
 
-        if is_history_folder:
+        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
 
                 else HistoryType.Archived if is_archived_folder \
                 else HistoryType.Standard
 
-            return sql_resources.HistoryFolder(path, environ, content, type)
+            return sql_resources.HistoryFolder(
+                path=norm_path,
+                environ=environ,
+                content=content,
+                type=type
+            )
 
         # is history
         is_history_file_folder = re.search(r'/\.history/([^/]+)$', norm_path) is not None
 
-        if is_history_file_folder:
-            return sql_resources.HistoryFileFolder(path, environ, content)
+        if self._show_history and is_history_file_folder:
+            return sql_resources.HistoryFileFolder(
+                path=norm_path,
+                environ=environ,
+                content=content
+            )
 
         # is history
         is_history_file = re.search(r'/\.history/[^/]+/(\d+)-.+', norm_path) is not None
 
-        if is_history_file:
-            content = api.get_one_revision2(re.search(r'/\.history/[^/]+/(\d+)-.+', norm_path).group(1))
-            content_revision = self.get_content_from_revision(re.search(r'/\.history/[^/]+/(\d+)-.+', norm_path).group(1), api)
+        if self._show_history and is_history_file:
+            content_revision = content_api.get_one_revision(re.search(r'/\.history/[^/]+/(\d+)-.+', norm_path).group(1))
+            content = self.get_content_from_revision(content_revision, content_api)
 
             if content.type == ContentType.File:
                 return sql_resources.HistoryFile(path, environ, content, content_revision)
         # other
         if content.type == ContentType.Folder:
             return sql_resources.Folder(path, environ, content)
-
-        if content.type == ContentType.File:
+        elif content.type == ContentType.File:
             return sql_resources.File(path, environ, content, False)
-        else:
+        elif content.type in [ContentType.Page, ContentType.Thread]:
             return sql_resources.OtherFile(path, environ, content)
+        else:
+            return None
 
     def exists(self, path, environ):
-        path = normpath(path)
-        if path == "/":
-            return True
-        elif dirname(path) == "/":
-            return self.get_workspace_from_path(
-                path,
-                WorkspaceApi(environ['user'])
-            ) is not None
+        norm_path = normpath(path)
+        parent_path = dirname(norm_path)
+        root_path = environ['http_authenticator.realm']
 
-        api = ContentApi(
+        workspace_api = WorkspaceApi(environ['user'])
+        content_api = ContentApi(
             current_user=environ['user'],
             show_archived=True,
             show_deleted=True
         )
-        wapi = WorkspaceApi(environ['user'])
 
-        norm_path = normpath(path)
+        if path == root_path:
+            return sql_resources.Root(path, environ)
+        elif parent_path == root_path:
+            return sql_resources.Workspace(
+                path=norm_path,
+                environ=environ,
+                workspace=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
 
 
         if revision_id:
             revision_id = revision_id.group(1)
-            return self.get_content_from_revision(revision_id, api) is not None
-
-        working_path = self.reduce_path(path)
-
-        content = self.get_content_from_path(working_path, api, wapi)
+            content = content_api.get_one_revision(revision_id)
+        else:
+            content = self.get_content_from_path(norm_path, content_api, workspace_api)
 
         return content is not None \
             and content.is_deleted == is_deleted \
-            and content.is_archived == is_archived \
-            and (revision_id is None or content.revision_id == revision_id)
+            and content.is_archived == is_archived
 
     def reduce_path(self, path):
         path = re.sub(r'/\.archived', r'', path)
 
         return path
 
-    def get_content_from_path(self, path, api: ContentApi, workspace_api: WorkspaceApi):
-        path = normpath(path)
+    def get_content_from_path(self, path, content_api: ContentApi, workspace_api: WorkspaceApi):
+        path = self.reduce_path(path)
+
         workspace = self.get_workspace_from_path(path, workspace_api)
 
         if basename(dirname(path)) == workspace.label:
-            return api.get_one_by_label_and_parent(basename(path), workspace=workspace)
+            try:
+                return content_api.get_one_by_label_and_parent(basename(path), workspace=workspace)
+            except:
+                return None
         else:
-            parent = self.get_parent_from_path(path, api, workspace_api)
+            parent = self.get_parent_from_path(path, content_api, workspace_api)
             if parent is not None:
-                return api.get_one_by_label_and_parent(basename(path), content_parent=parent)
+                try:
+                    return content_api.get_one_by_label_and_parent(basename(path), content_parent=parent)
+                except:
+                    return None
             return None
 
-    def get_content_from_revision(self, revision_id: int, api:ContentApi):
-        return api.get_one_revision(revision_id)
+    def get_content_from_revision(self, revision: ContentRevisionRO, api:ContentApi):
+        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('/')
 
-        return api.get_one_by_label(path.split('/')[1])
+        print(path)
+        try:
+            return api.get_one_by_label(path.split('/')[1])
+        except:
+            return None
 
     #########################################################
     # Everything that transform path
         last_item.child_revision_id = new_item.id
 
         self.session.commit()'''
+
+"""
+
+{'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_model.py

 from sqlalchemy import Sequence
 from sqlalchemy.orm import deferred
 from sqlalchemy.types import DateTime, Integer, LargeBinary, Unicode, UnicodeText, Float
-from tracim.lib.webdav import Base
+
 from wsgidav.compat import to_unicode, to_bytes
 
 # ==================================================
 # Content
 # ==================================================
-class Workspace(Base):
+class Workspace(object):
     __tablename__ = 'my_workspaces'
 
     workspace_id = Column(Integer, Sequence('my_seq__workspace__id'), autoincrement=True, primary_key=True)
         return "<Workspace %s : %s>" % (self.workspace_id, self.label)
 
 
-class User(Base):
+class User(object):
     __tablename__ = 'my_users'
 
     user_id = Column(Integer, Sequence('my_seq__users__id'), autoincrement=True, primary_key=True)
         return "<User %s : %s>" % (self.user_id, self.display_name)
 
 
-class UserWorkspace(Base):
+class UserWorkspace(object):
     __tablename__ = 'my_user_workspace'
 
     workspace_id = Column(Integer, ForeignKey('my_workspaces.workspace_id', ondelete="CASCADE"), nullable=False, primary_key=True)
         return "<Role (W:%s, U:%s) : %s" % (self.workspace_id, self.user_id, self.role)
 
 
-class ItemRevision(Base):
+class ItemRevision(object):
     __tablename__ = 'my_items_revisions'
 
     id = Column(Integer, Sequence('my_seq__items__id'), autoincrement=True, primary_key=True)
         return "<Content %s : %s in %s>" % (self.id, self.item_name, self.parent_id)
 
 
-class Lock(Base):
+class Lock(object):
     __tablename__ = 'my_locks'
 
     token = Column(UnicodeText, primary_key=True, unique=True, nullable=False)
     timeout = Column(Float, unique=False, nullable=False)
 
 
-class Url2Token(Base):
+class Url2Token(object):
     __tablename__ = 'my_url2token'
 
     token = Column(UnicodeText, primary_key=True, unique=True, nullable=False)

tracim/tracim/lib/webdav/sql_resources.py

 from wsgidav.dav_error import DAVError, HTTP_FORBIDDEN
 from wsgidav.dav_provider import DAVCollection, DAVNonCollection
 from tracim.model import data, new_revision
-from tracim.model.data import Content, ActionDescription, VirtualEvent
+from tracim.model.data import Content, ActionDescription
 from tracim.model.data import ContentType
-from wsgidav.dav_provider import DAVResource
+from wsgidav.dav_provider import _DAVResource
 
-_CONTENTS = {
-    ContentType.Folder: Folder,
-    ContentType.File: File,
-    ContentType.Page: OtherFile,
-    ContentType.Thread: OtherFile
-}
+from tracim.lib.webdav.design import designThread, designPage
 
 class Encapsuler(object):
     def __init__(self, type: str, api: ContentApi, content: Content):
 
         self._type = type
 
+        self._new_name = self.make_name()
+
     def action(self):
         with new_revision(self._content):
             self._actions[self._type](self._content)
+
+            if self._content.label == '':
+                self._content.file_name = self._new_name
+            else:
+                self._content.label = self._new_name
+
             self._api.save(self._content, self._type)
 
         transaction.commit()
 
+    def make_name(self):
+        new_name = self._content.get_label()
+        is_file_name = self._content.label == ''
+        add = ''
+
+        if self._type in [ActionDescription.ARCHIVING, ActionDescription.DELETION]:
+            new_name += ' - %s the %s' % (self._type, datetime.now())
+        else:
+            pass
+
+        return new_name
 
 class Root(DAVCollection):
     def __init__(self, path: str, environ: dict):
     def getMemberNames(self) -> [str]:
         return [workspace.label for workspace in self._workspace_api.get_all()]
 
-    def getMember(self, label: str) -> Workspace:
+    def getMember(self, label: str) -> _DAVResource:
 
         workspace = self._workspace_api.get_one_by_label(label)
 
 
         return retlist
 
-    def getMember(self, content_label: str) -> DAVResource:
+    def getMember(self, content_label: str) -> _DAVResource:
 
         content = self._content_api.get_one_by_label_and_parent(
             content_label=content_label,
         )
 
         return _CONTENTS[content.type](
-            path=self.path + content.get_label(),
+            path=self.path + '/' + content.get_label(),
             environ=self.environ,
             content=content
             )
     def createEmptyResource(self, name: str):
         raise DAVError(HTTP_FORBIDDEN)
 
-    def createCollection(self, label: str) -> Folder:
+    def createCollection(self, label: str) -> 'Folder':
 
         folder = self._content_api.create(
             content_type=ContentType.Folder,
 
         transaction.commit()
 
-        return Folder(self.path + label, self.environ, folder)
+        return Folder(self.path + '/' + label, self.environ, folder)
 
     def delete(self):
         raise DAVError(HTTP_FORBIDDEN)
     def setLastModified(self, destpath, timestamp, dryrun):
         return False
 
-    def getMemberList(self) -> [DAVResource]:
+    def getMemberList(self) -> [_DAVResource]:
         memberlist = []
 
         if self.environ['REQUEST_METHOD'] not in ['MOVE', 'COPY', 'DELETE']:
             if memberlist != [] and self._file_count > 0:
                 memberlist.append(
                     HistoryFolder(
-                        path=self.path + ".history",
+                        path=self.path + '/' + ".history",
                         environ=self.environ,
-                        content=self._content,
+                        content=None,
                         type=HistoryType.Standard
                         )
                     )
 
             memberlist.append(
                 DeletedFolder(
-                    path=self.path + ".deleted",
+                    path=self.path + '/' + ".deleted",
                     environ=self.environ,
-                    content=self._content
+                    content=None
                     )
                 )
 
             memberlist.append(
                 ArchivedFolder(
-                    path=self.path + ".archived",
+                    path=self.path + '/' + ".archived",
                     environ=self.environ,
-                    content=self._content
+                    content=None
                     )
                 )
 
 
         return retlist
 
-    def getMember(self, content_label: str) -> DAVResource:
+    def getMember(self, content_label: str) -> _DAVResource:
 
         content = self._api.get_one_by_label_and_parent(
             content_label=content_label,
         )
 
         return self.provider.getResourceInst(
-            path=self.path + content.get_label(),
+            path=self.path + '/' + content.get_label(),
             environ=self.environ
             )
 
             new_file=True
             )
 
-    def createCollection(self, label: str) -> Folder:
+    def createCollection(self, label: str) -> _DAVResource:
 
         folder = self._api.create(ContentType.Folder, self._content.workspace, self._content, label)
 
 
         transaction.commit()
 
-        return Folder(self.path + label, self.environ, folder)
+        return Folder(self.path + '/' + label, self.environ, folder)
 
     def delete(self):
         Encapsuler(ActionDescription.DELETION, self._api, self._content).action()
         #self.item.updated = datetime.fromtimestamp(timestamp)
         #return True
 
-    def getMemberList(self) -> [DAVResource]:
+    def getMemberList(self) -> [_DAVResource]:
         memberlist = []
 
         for name in self.getMemberNames():
             if memberlist != [] and self._file_count > 0:
                 memberlist.append(
                     HistoryFolder(
-                        path=self.path + ".history",
+                        path=self.path + '/' + ".history",
                         environ=self.environ,
                         content=self._content,
                         type=HistoryType.Standard
 
             memberlist.append(
                 DeletedFolder(
-                    path=self.path + ".deleted",
+                    path=self.path + '/' + ".deleted",
                     environ=self.environ,
                     content=self._content
                     )
 
             memberlist.append(
                 ArchivedFolder(
-                    path=self.path + ".archived",
+                    path=self.path + '/' + ".archived",
                     environ=self.environ,
                     content=self._content
                     )
 
         return memberlist
 
-
 class HistoryFolder(Folder):
     def __init__(self, path, environ, content: data.Content, type):
         super(HistoryFolder, self).__init__(path, environ, content)
     def getLastModified(self) -> float:
         return mktime(datetime.now().timetuple())
 
-    def getMember(self, content_label: str) -> HistoryFileFolder:
+    def getMember(self, content_label: str) -> _DAVResource:
         content = self._api.get_one_by_label_and_parent(
             content_label=content_label,
             content_parent=self._content
         )
 
         return HistoryFileFolder(
-            path=self.path + content.get_label(),
+            path=self.path + '/' + content.get_label(),
             environ=self.environ,
             content=content)
 
     def setLastModified(self, destpath: str, timestamp: float, dryrun: bool):
         return False
 
-    def getMemberList(self) -> [HistoryFileFolder]:
+    def getMemberList(self) -> [_DAVResource]:
         memberlist = []
         for name in self.getMemberNames():
             member = self.getMember(name)
         super(DeletedFolder, self).__init__(path, environ, content, HistoryType.Deleted)
 
         self._api = ContentApi(
-            current_user=self._user,
+            current_user=environ['user'],
             show_deleted=True
         )
 
     def getLastModified(self) -> float:
         return mktime(datetime.now().timetuple())
 
-    def getMember(self, content_label) -> DAVResource:
+    def getMember(self, content_label) -> _DAVResource:
 
         content = self._api.get_one_by_label_and_parent(
             content_label=content_label,
         )
 
         return self.provider.getResourceInst(
-            path=self.path + content.get_label(),
+            path=self.path + '/' + content.get_label(),
             environ=self.environ
             )
 
     def setLastModified(self, destpath: str, timestamp: float, dryrun: bool):
         return False
 
-    def getMemberList(self) -> [DAVResource]:
+    def getMemberList(self) -> [_DAVResource]:
         memberlist = []
 
         if self.environ['REQUEST_METHOD'] not in ['MOVE', 'COPY', 'DELETE']:
             if self._file_count > 0:
                 memberlist.append(
                     HistoryFolder(
-                        path=self.path + ".history",
+                        path=self.path + '/' + ".history",
                         environ=self.environ,
                         content=self._content, 
                         type=HistoryType.Deleted
     def getLastModified(self) -> float:
         return mktime(datetime.now().timetuple())
 
-    def getMember(self, content_label) -> DAVResource:
+    def getMember(self, content_label) -> _DAVResource:
 
         content = self._api.get_one_by_label_and_parent(
             content_label=content_label,
         )
 
         return self.provider.getResourceInst(
-            path=self.path + content.get_label(),
+            path=self.path + '/' + content.get_label(),
             environ=self.environ
             )
 
     def setLastModified(self, destpath: str, timestamp: float, dryrun: bool):
         return False
 
-    def getMemberList(self) -> [DAVResource]:
+    def getMemberList(self) -> [_DAVResource]:
         memberlist = []
         
         if self.environ['REQUEST_METHOD'] not in ['MOVE', 'COPY', 'DELETE']:
             if self._file_count > 0:
                 memberlist.append(
                     HistoryFolder(
-                        path=self.path + ".history",
+                        path=self.path + '/' + ".history",
                         environ=self.environ,
                         content=self._content,
                         type=HistoryType.Archived
         
         if self._content.type == ContentType.File:
             return HistoryFile(
-                path=self.path + str(rev.revision_id) + '-' + rev.file_name,
+                path=self.path + '/' + str(revision.revision_id) + '-' + revision.file_name,
                 environ=self.environ,
                 content=self._content, 
                 content_revision=revision)
         else:
             return HistoryOtherFile(
-                path=self.path + str(rev.revision_id) + '-' + rev.get_label(),
+                path=self.path + '/' + str(revision.revision_id) + '-' + revision.get_label(),
                 environ=self.environ,
                 content=self._content,
                 content_revision=revision)
     def delete(self):
         raise DAVError(HTTP_FORBIDDEN)
 
+    def getMemberList(self) -> [_DAVResource]:
+        memberlist = []
+
+        if self.environ['REQUEST_METHOD'] not in ['MOVE', 'COPY', 'DELETE']:
+
+            for name in self.getMemberNames():
+                member = self.getMember(name)
+                if member is not None:
+                    memberlist.append(member)
+
+        return memberlist
+
 
 class File(DAVNonCollection):
-    def __init__(self, path: str, environ: environ, content: Content, is_new_file: bool):
+    def __init__(self, path: str, environ: dict, content: Content, is_new_file: bool):
         super(File, self).__init__(path, environ)
 
         self._content = content
             show_deleted=True
         )
 
-        self.filestream = MyFileStream(content=self._content, content_api=self._api)
+        self.filestream = FileStream(
+            content=self._content,
+            content_api=self._api,
+            file_name=self._content.get_label(),
+            new_file=False
+            )
 
     def __repr__(self) -> str:
-        return "<DAVNonCollectio: File (%s)>" % self._content.get_label()
+        return "<DAVNonCollection: File (%s)>" % self._content.get_label()
 
     def getContentLength(self) -> int:
         return len(self._content.file_content)
 
         return filestream
 
-    def beginWrite(self, contentType: str=None) -> MyFileStream:
+    def beginWrite(self, contentType: str=None) -> FileStream:
         return self.filestream
 
     def copyMoveSingle(self, destpath: str, ismove: bool):
         destpath = normpath(destpath)
 
         if ismove:
-            parent = self.provider.get_parent_from_path(normpath(destpath), self._api, WorkspaceApi(self._user))
+            parent = self.provider.get_parent_from_path(
+                normpath(destpath),
+                self._api,
+                WorkspaceApi(self.environ['user'])
+            )
 
             with new_revision(self._content):
                 if basename(destpath) != self._content.label:
         raise DAVError(HTTP_FORBIDDEN)
 
     def handleDelete(self):
-        return True
+        return False
 
     def handleCopy(self, destPath, depthInfinity):
         return True
 
     def getContentLength(self) -> int:
         if self._content.type == ContentType.Page:
-            return len(self.designPage(self._content))
+            return len(designPage(self._content, self._content.revision))
         else:
-            return len(self.designThread(self._content))
+            return len(designThread(self._content, self._content.revision, self._api.get_all(self._content.content_id, ContentType.Comment)))
 
     def getContentType(self) -> str:
         return 'text/html'
             filestream = compat.StringIO()
 
         if self._content.type == ContentType.Page:
-            self._content_page = self.designPage(self._content)
+            self._content_page = designPage(self._content, self._content.revision)
         else:
-            self._content_page = self.designThread(self._content)
+            self._content_page = designThread(self._content, self._content.revision, self._api.get_all(self._content.content_id, ContentType.Comment))
 
         filestream.write(bytes(self._content_page, 'utf-8'))
         filestream.seek(0)
         return filestream
 
-    def designPage(self, content: data.Content) -> str:
-        #f = open('wsgidav/addons/webdav/style.css', 'r')
-        style = ''#f.read()
-        #f.close()
-
-        hist = self._content.get_history()
-        histHTML = '<table class="table table-striped table-hover">'
-        for event in hist:
-            if isinstance(event, VirtualEvent):
-                date = event.create_readable_date()
-                _LABELS = {
-                    'archiving': 'Item archived',
-                    'content-comment': 'Item commented',
-                    'creation': 'Item created',
-                    'deletion': 'Item deleted',
-                    'edition': 'item modified',
-                    'revision': 'New revision',
-                    'status-update': 'New status',
-                    'unarchiving': 'Item unarchived',
-                    'undeletion': 'Item undeleted',
-                    'move': 'Item moved'
-                }
-
-                label = _LABELS[event.type.id]
-
-                histHTML += '''
-                <tr class="%s">
-                    <td class="my-align"><span class="label label-default"><i class="fa %s"></i> %s</span></td>
-                    <td>%s</td>
-                    <td>%s</td>
-                    <td>%s</td>
-                </tr>
-                ''' % ('warning' if event.id == content.revision_id else '',
-                       event.type.icon,
-                       label,
-                       date,
-                       event.owner.display_name,
-                       '<i class="fa fa-caret-left"></i> shown' if event.id == content.revision_id else '''<span><a class="revision-link" href="/.history/%s/%s-%s">(View revision)</a></span>''' % (self._content.label, event.id, event.ref_object.label) if event.type.id == 'revision' else '')
-
-        histHTML+='</table>'
-
-        file = '''
-<html>
-<head>
-	<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">
-	<script type="text/javascript" src="/home/arnaud/Documents/css/script.js"></script>
-</head>
-<body>
-    <div id="left" class="col-lg-8 col-md-12 col-sm-12 col-xs-12">
-        <div class="title page">
-            <div class="title-text">
-                <i class="fa fa-file-text-o title-icon page"></i>
-                <h1>%s</h1>
-                <h6>page created on <b>%s</b> by <b>%s</b></h6>
-            </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>
-                </div>
-            </div>
-        </div>
-        <div class="content col-xs-12 col-sm-12 col-md-12 col-lg-12">
-            %s
-        </div>
-    </div>
-    <div id="right" class="col-lg-4 col-md-12 col-sm-12 col-xs-12">
-        <h4>History</h4>
-        %s
-    </div>
-    <script type="text/javascript">
-        window.onload = function() {
-            elems = document.getElementsByClassName('revision-link');
-            for(var i = 0; i<elems.length; i++) {
-                test = window.location.href
-                test += "/.." + elems[i].href.replace(/file:\/\//, "")
-                elems[i].href = test
-            }
-        }
-    </script>
-</body>
-</html>
-        ''' % (content.label,
-               content.label,
-               self._content.created.strftime("%B %d, %Y at %H:%m"),
-               self._content.owner.display_name,
-               content.description,
-               histHTML)
-
-        return file
-
-    def designThread(self, content: data.Content) -> str:
-
-        comments = self._api.get_all(self._content.content_id, ContentType.Comment)
-        hist = self._content.get_history()
-
-        allT = []
-        allT += comments
-        allT += hist
-        allT.sort(key=lambda x: x.created, reverse=True)
-
-        disc = ''
-        participants = {}
-        for t in allT:
-            if t.type == ContentType.Comment:
-                disc += '''
-                    <div class="row comment comment-row">
-                        <i class="fa fa-comment-o comment-icon"></i>
-                            <div class="comment-content">
-                            <h5>
-                                <span class="comment-author"><b>%s</b> wrote :</span>
-                                <div class="pull-right text-right">%s</div>
-                            </h5>
-                            %s
-                        </div>
-                    </div>
-                    ''' % (t.owner.display_name, t.create_readable_date(), t.description)
-
-                if t.owner.display_name not in participants:
-                    participants[t.owner.display_name] = [1, t.created]
-                else:
-                    participants[t.owner.display_name][0] += 1
-            else:
-                if isinstance(t, VirtualEvent) and t.type.id != 'comment':
-                    _LABELS = {
-                        'archiving': 'Item archived',
-                        'content-comment': 'Item commented',
-                        'creation': 'Item created',
-                        'deletion': 'Item deleted',
-                        'edition': 'item modified',
-                        'revision': 'New revision',
-                        'status-update': 'New status',
-                        'unarchiving': 'Item unarchived',
-                        'undeletion': 'Item undeleted',
-                        'move': 'Item moved',
-                        'comment' : 'hmmm'
-                    }
-
-                    label = _LABELS[t.type.id]
-
-                    disc += '''
-                    <div class="row comment comment-row">
-                        <i class="fa %s comment-icon"></i>
-                            <div class="comment-content">
-                            <h5>
-                                <span class="comment-author"><b>%s</b></span>
-                                <div class="pull-right text-right">%s</div>
-                            </h5>
-                            %s %s
-                        </div>
-                    </div>
-                    ''' % (t.type.icon,
-                           t.owner.display_name,
-                           t.create_readable_date(),
-                           label,
-                           '''<span><a class="revision-link" href="/.history/%s/%s-%s">(View revision)</a></span>''' % (
-                               self._content.label,
-                               t.id,
-                               t.ref_object.label) if t.type.id == 'revision' else '')
-
-        page = '''
-<html>
-<head>
-	<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">
-	<script type="text/javascript" src="/home/arnaud/Documents/css/script.js"></script>
-</head>
-<body>
-    <div id="left" class="col-lg-12 col-md-12 col-sm-12 col-xs-12">
-        <div class="title thread">
-            <div class="title-text">
-                <i class="fa fa-comments-o title-icon thread"></i>
-                <h1>%s</h1>
-                <h6>thread created on <b>%s</b> by <b>%s</b></h6>
-            </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>
-                </div>
-            </div>
-        </div>
-        <div class="content col-xs-12 col-sm-12 col-md-12 col-lg-12">
-            <div class="description">
-                <span class="description-text">%s</span>
-            </div>
-            %s
-        </div>
-    </div>
-    <script type="text/javascript">
-        window.onload = function() {
-            elems = document.getElementsByClassName('revision-link');
-            for(var i = 0; i<elems.length; i++) {
-                test = window.location.href
-                test += "/.." + elems[i].href.replace(/file:\/\//, "")
-                elems[i].href = test
-            }
-        }
-    </script>
-</body>
-</html>
-        ''' % (content.label,
-               content.label,
-               self._content.created.strftime("%B %d, %Y at %H:%m"),
-               self._content.owner.display_name,
-               content.description,
-               disc)
-
-        return page
-
-
 class HistoryOtherFile(OtherFile):
     def __init__(self, path: str, environ: dict, content: data.Content, content_revision: data.ContentRevisionRO):
         super(HistoryOtherFile, self).__init__(path, environ, content)
             filestream = compat.StringIO()
 
         if self._content.type == ContentType.Page:
-            self._content_page = self.designPage(self._content_revision)
+            self._content_page = designPage(self._content, self._content_revision)
         else:
-            self._content_page = self.designThread(self._content_revision)
+            self._content_page = designThread(self._content, self._content_revision, self._api.get_all(self._content.content_id, ContentType.Comment))
 
         filestream.write(bytes(self._content_page, 'utf-8'))
         filestream.seek(0)
 
     def copyMoveSingle(self, destpath, ismove):
         raise DAVError(HTTP_FORBIDDEN)
+
+
+_CONTENTS = {
+    ContentType.Folder: Folder,
+    ContentType.File: File,
+    ContentType.Page: OtherFile,
+    ContentType.Thread: OtherFile
+}

tracim/tracim/model/data.py

         self.content = content
         self.ref_object = ref_object
 
-        print(type)
+        # todo moi ? print(type)
         assert hasattr(type, 'id')
         assert hasattr(type, 'css')
         assert hasattr(type, 'icon')