New migration for temporary files, updating content's model and webdav to fit them, reducing number of calls to database with request

tracim/migration/versions/b4b8d57b54e5_add_hash_column_for_digest_.py

 down_revision = '534c4594ed29'
 
 from alembic import op
-from sqlalchemy import Column, Unicode
+from sqlalchemy import Column, Unicode, Boolean
 
 
 def upgrade():
     op.add_column('users', Column('webdav_left_digest_response_hash', Unicode(128)))
-
+    op.add_column('content_revisions', Column('is_temporary', Boolean(), unique=False, nullable=True))
+    op.execute('''
+        UPDATE content_revisions
+        SET is_temporary = FALSE
+        ''')
+    op.alter_column('content_revisions', 'is_temporary', nullable=False)
 
 def downgrade():
     op.drop_column('users', 'webdav_left_digest_response_hash')
+    op.drop_column('content_revisions', 'is_temporary')

tracim/tracim/lib/content.py

             current_user: User,
             show_archived=False,
             show_deleted=False,
+            show_temporary=False,
             all_content_in_treeview=True,
             force_show_all_types=False,
             disable_user_workspaces_filter=False,
         self._user_id = current_user.user_id if current_user else None
         self._show_archived = show_archived
         self._show_deleted = show_deleted
+        self._show_temporary = show_temporary
         self._show_all_type_of_contents_in_treeview = all_content_in_treeview
         self._force_show_all_types = force_show_all_types
         self._disable_user_workspaces_filter = disable_user_workspaces_filter
         if not self._show_archived:
             result = result.filter(Content.is_archived==False)
 
+        if not self._show_temporary:
+            result = result.filter(Content.is_temporary==False)
+
         return result
 
     def __revisions_real_base_query(self, workspace: Workspace=None):
         if not self._show_archived:
             result = result.filter(ContentRevisionRO.is_archived==False)
 
+        if not self._show_temporary:
+            result = result.filter(Content.is_temporary==False)
+
         return result
 
     def _hard_filtered_base_query(self, workspace: Workspace=None):
                 filter(Content.is_archived==False).\
                 filter(parent.is_archived==False)
 
+        if not self._show_temporary:
+            parent = aliased(Content)
+            result = result.join(parent, Content.parent). \
+                filter(Content.is_temporary == False). \
+                filter(parent.is_temporary == False)
+
         return result
 
     def get_child_folders(self, parent: Content=None, workspace: Workspace=None, filter_by_allowed_content_types: list=[], removed_item_ids: list=[], allowed_node_types=None) -> [Content]:
 
         return result
 
-    def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', do_save=False) -> Content:
+    def create(self, content_type: str, workspace: Workspace, parent: Content=None, label:str ='', is_temporary:bool =False, do_save=False) -> Content:
         assert content_type in ContentType.allowed_types()
         content = Content()
         content.owner = self._user
         content.workspace = workspace
         content.type = content_type
         content.label = label
+        content.is_temporary = is_temporary
         content.revision_type = ActionDescription.CREATION
 
         if do_save:
 
         return resultset.all()
 
+    # TODO find an other name to filter on is_deleted / is_archived
+    def get_all_with_filter(self, parent_id: int=None, content_type: str=ContentType.Any, workspace: Workspace=None) -> [Content]:
+        assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
+        assert content_type is not None# DYN_REMOVE
+        assert isinstance(content_type, str) # DYN_REMOVE
+
+        resultset = self._base_query(workspace)
+
+        if content_type != ContentType.Any:
+            resultset = resultset.filter(Content.type==content_type)
+
+        resultset = resultset.filter(Content.is_deleted == self._show_deleted)
+        resultset = resultset.filter(Content.is_archived == self._show_archived)
+        resultset = resultset.filter(Content.is_temporary == self._show_temporary)
+
+        resultset = resultset.filter(Content.parent_id==parent_id)
+
+        return resultset.all()
+
     def get_all_without_exception(self, content_type: str, workspace: Workspace=None) -> [Content]:
         assert content_type is not None# DYN_REMOVE
 

tracim/tracim/lib/webdav/__init__.py

             self.update_file(self._buff)
 
     def create_file(self, item_content):
+        is_temporary = self._file_name.startswith('.~') or self._file_name.startswith('~')
+
         file = self._api.create(
             content_type=ContentType.File,
             workspace=self._workspace,
-            parent=self._parent
-            )
+            parent=self._parent,
+            is_temporary=is_temporary
+        )
 
         self._api.update_file_data(
             file,

tracim/tracim/lib/webdav/design.py

                        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 '')
+                       content.label, event.id, event.ref_object.label) if event.type.id in ['revision', 'creation', 'edition'] else '')
 
     histHTML += '</table>'
 
 	<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>
+	<script
+			  src="https://code.jquery.com/jquery-3.1.0.min.js"
+			  integrity="sha256-cCueBR6CsyA4/9szpPfrX3s49M9vUU5BgtiJj06wt/s="
+			  crossorigin="anonymous"></script>
 </head>
 <body>
     <div id="left" class="col-lg-8 col-md-12 col-sm-12 col-xs-12">
     </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
-            }
+            file_location = window.location.href
+            file_location = file_location.replace(/\/[^/]*$/, '')
+            file_location = file_location.replace(/\/.history\/[^/]*$/, '')
+
+            $('.revision-link').each(function() {
+                $(this).attr('href', file_location + $(this).attr('href'))
+            });
         }
     </script>
 </body>
                     label = _LABELS[t.type.id]
 
                     disc += '''
-                    <div class="row comment comment-row to-hide">
+                    <div class="%s row comment comment-row to-hide">
                         <i class="fa %s comment-icon"></i>
                             <div class="comment-content">
                             <h5>
                             %s %s
                         </div>
                     </div>
-                    ''' % (t.type.icon,
+                    ''' % ('warning' if t.id == content_revision.revision_id else '',
+                           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,
+                            '<i class="fa fa-caret-left"></i> shown' if t.id == content_revision.revision_id else '''<span><a class="revision-link" href="/.history/%s/%s-%s">(View revision)</a></span>''' % (
+                               content.label,
                                t.id,
                                t.ref_object.label) if t.type.id in ['revision', 'creation', 'edition'] else '')
 
     </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
-            }
+            file_location = window.location.href
+            file_location = file_location.replace(/\/[^/]*$/, '')
+            file_location = file_location.replace(/\/.history\/[^/]*$/, '')
+
+            $('.revision-link').each(function() {
+                $(this).attr('href', file_location + $(this).attr('href'))
+            });
         }
 
         function hide_elements() {
                     $(elems[i]).hide();
                 }
                 while (elems.length>0) {
+                    $(elems[0]).removeClass('comment-row');
                     $(elems[0]).removeClass('to-hide');
                 }
                 $('#hideshow').addClass('fa-eye').removeClass('fa-eye-slash');
             else {
                 elems = document.getElementsByClassName('to-show');
                 for(var i = 0; i<elems.length; i++) {
+                    $(elems[0]).addClass('comment-row');
                     $(elems[i]).addClass('to-hide');
                     $(elems[i]).show();
                 }

tracim/tracim/lib/webdav/sql_dav_provider.py

     #########################################################
     # Everything override from DAVProvider
     def getResourceInst(self, path, environ):
-        print("ok : ", path)
         #if not self.exists(path, environ):
         #    return None
         if not self.exists(path, environ):
             return None
 
-        uapi = UserApi(None)
-        environ['user'] = uapi.get_one_by_email(environ['http_authenticator.username'])
-
         norm_path = normpath(path)
-        norm_path = self.transform_to_display(norm_path)
 
         root_path = environ['http_authenticator.realm']
         parent_path = dirname(norm_path)
 
-        workspace_api = WorkspaceApi(environ['user'])
+        user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
+
+        workspace_api = WorkspaceApi(user)
         content_api = ContentApi(
-            environ['user'],
+            user,
             show_archived=self._show_archive,
             show_deleted=self._show_delete
         )
             )
 
         # is history
-        is_history_file = re.search(r'/\.history/[^/]+/(\d+)-.+', norm_path) is not None
+        is_history_file = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) .+', norm_path) is not None
 
         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_revision = content_api.get_one_revision(re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) .+', 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)
+                return sql_resources.HistoryFile(norm_path, environ, content, content_revision)
             else:
-                return sql_resources.HistoryOtherFile(path, environ, content, content_revision)
+                return sql_resources.HistoryOtherFile(norm_path, environ, content, content_revision)
 
         # other
         if content is None:
             return None
         if content.type == ContentType.Folder:
-            return sql_resources.Folder(path, environ, content, content.workspace)
+            return sql_resources.Folder(norm_path, environ, content, content.workspace)
         elif content.type == ContentType.File:
-            return sql_resources.File(path, environ, content)
+            return sql_resources.File(norm_path, environ, content)
         elif content.type in [ContentType.Page, ContentType.Thread]:
-            return sql_resources.OtherFile(path, environ, content)
+            return sql_resources.OtherFile(norm_path, environ, content)
         else:
             return None
 
     def exists(self, path, environ):
-        print("ok (exist) : ", path)
-        uapi = UserApi(None)
-        environ['user'] = uapi.get_one_by_email(environ['http_authenticator.username'])
-
         norm_path = normpath(path)
         parent_path = dirname(norm_path)
         root_path = environ['http_authenticator.realm']
 
-        workspace_api = WorkspaceApi(environ['user'])
+        user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
+        workspace_api = WorkspaceApi(user)
         content_api = ContentApi(
-            current_user=environ['user'],
+            current_user=user,
             show_archived=True,
             show_deleted=True
         )
 
         if path == root_path:
-            print("ok (pass ici) : ", path)
             return True
         elif parent_path == root_path:
             return self.get_workspace_from_path(
 
         is_deleted = re.search(r'/\.deleted/(\.history/)?(?!\.history)[^/]*(/\.)?(history|deleted|archived)?$', norm_path) is not None
 
-        revision_id = re.search(r'/\.history/[^/]+/(\d+)-([^/].+)$', norm_path)
+        revision_id = re.search(r'/\.history/[^/]+/\((\d+) - [a-zA-Z]+\) ([^/].+)$', norm_path)
 
         blbl = self.reduce_path(norm_path)
         if dirname(blbl) == '/':
         workspace = self.get_workspace_from_path(path, workspace_api)
 
         try:
-            if basename(dirname(path)) == workspace.label:
+            if dirname(dirname(path)) == '/':
                 return content_api.get_one_by_label_and_parent(
                     self.transform_to_bdd(basename(path)),
                     workspace=workspace
 
     def transform_to_display(self, string):
         _TO_DISPLAY = {
-            # '/':'⁄',
+            '/':'⧸',
             '\\': '⧹',
             ':': '∶',
             '*': '∗',
 
     def transform_to_bdd(self, string):
         _TO_BDD = {
-            # '⁄': '/',
+            '⧸': '/',
             '⧹': '\\',
             '∶': ':',
             '∗': '*',

tracim/tracim/lib/webdav/sql_domain_controller.py

     def get_left_digest_response_hash(self, realmname, username, environ):
         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'''
+
         return self.isRealmUser(realmname, username, environ) and \
             self._api.get_one_by_email(username).validate_password(password)

tracim/tracim/lib/webdav/sql_resources.py

 import mimetypes
 
 from tracim.lib.content import ContentApi
+from tracim.lib.user import UserApi
 from tracim.lib.webdav import HistoryType
 from tracim.lib.webdav import FakeFileStream
 from tracim.lib.workspace import WorkspaceApi
 from tracim.model.data import Content, ActionDescription
 from tracim.model.data import ContentType
 from tracim.lib.webdav.design import designThread, designPage
-from tracim.lib.user import UserApi
 
 from wsgidav import compat
 from wsgidav.dav_error import DAVError, HTTP_FORBIDDEN
 from wsgidav.dav_provider import DAVCollection, DAVNonCollection
 from wsgidav.dav_provider import _DAVResource
 
+from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
 
 class Manage(object):
     """Objet qui sert à encapsuler l'exécution des actions de l'api archive/delete..."""
         self._new_name = self.make_name()
 
     def action(self):
-        """Exécute l'action"""
-        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.content_api.save(self.content, self._type)
+        try:
+            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)
+                self.content_api.save(self.content, self._type)
 
-        transaction.commit()
+            transaction.commit()
 
     def make_name(self):
         """Créer le nouveau nom : rajoute de - archive date / retrait de - archive date suivant l'action"""
         extension = ''
         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)
+            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())
+            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)
 
     def __init__(self, path: str, environ: dict):
         super(Root, self).__init__(path, environ)
 
-        self.workspace_api = WorkspaceApi(environ['user'])
+        self.user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
+        self.workspace_api = WorkspaceApi(self.user)
 
     def __repr__(self) -> str:
         return '<DAVCollection: Root>'
         """
         try:
             workspace = self.workspace_api.get_one_by_label(label)
-            workspace_path = '%s%s%s' % (self.path, '' if self.path == '/' else '/', workspace.label)
+            workspace_path = '%s%s%s' % (self.path, '' if self.path == '/' else '/', self.provider.transform_to_display(workspace.label))
 
             return Workspace(workspace_path, self.environ, workspace)
         except AttributeError:
         [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."""
-        # TODO : remove comment here] raise DAVError(HTTP_FORBIDDEN)
+        # TODO : remove comment here
+        # raise DAVError(HTTP_FORBIDDEN)
 
         new_workspace = self.workspace_api.create_workspace(name)
         self.workspace_api.save(new_workspace)
+
+        workspace_path = '%s%s%s' % (
+        self.path, '' if self.path == '/' else '/', self.provider.transform_to_display(new_workspace.label))
+
         transaction.commit()
+        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à !
+
+        members = []
+        for workspace in self.workspace_api.get_all():
+            workspace_path = '%s%s%s' % (self.path, '' if self.path == '/' else '/', workspace.label)
+            members.append(Workspace(workspace_path, self.environ, workspace))
+
+        return members
 
 
 class Workspace(DAVCollection):
 
         self.workspace = workspace
         self.content = None
+        self.user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
 
-        self.content_api = ContentApi(UserApi(None).get_one_by_email(environ['http_authenticator.username']))
+        self.content_api = ContentApi(self.user, show_temporary=True)
 
         self._file_count = 0
 
         return "<DAVCollection: Workspace (%d)>" % self.workspace.workspace_id
 
     def getPreferredPath(self):
-        return self.provider.transform_to_display(self.path)
+        return self.path
 
     def getCreationDate(self) -> float:
         return mktime(self.workspace.created.timetuple())
     def getMember(self, content_label: str) -> _DAVResource:
 
         return self.provider.getResourceInst(
-            '%s/%s' % (self.path, content_label),
+            '%s/%s' % (self.path, self.provider.transform_to_display(content_label)),
             self.environ
         )
 
 
         transaction.commit()
 
-        return Folder('%s/%s' % (self.path, label), self.environ, folder, self.workspace)
+        return Folder('%s/%s' % (self.path, self.provider.transform_to_display(label)),
+                      self.environ, folder,
+                      self.workspace)
 
     def delete(self):
         """For now, it is not possible to delete a workspace through the webdav client."""
         raise DAVError(HTTP_FORBIDDEN)
 
-    def copyMoveSingle(self, destpath, ismove):
-        raise DAVError(HTTP_FORBIDDEN)
-
     def supportRecursiveMove(self, destpath):
-        # return False
         return True
 
     def moveRecursive(self, destpath):
-        if dirname(normpath(destpath)) == '/':
+        if dirname(normpath(destpath)) == self.provider.root:
             self.workspace.label = basename(normpath(destpath))
             transaction.commit()
         else:
             raise DAVError(HTTP_FORBIDDEN)
 
     def getMemberList(self) -> [_DAVResource]:
-        memberlist = []
+        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)
 
-        for name in self.getMemberNames():
-            member = self.getMember(name)
-            if member is not None:
-                memberlist.append(member)
+        for content in childs:
+            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))
+            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():
-            memberlist.append(
+            members.append(
                 HistoryFolder(
                     path=self.path + '/' + ".history",
                     environ=self.environ,
             )
 
         if self.provider.show_delete():
-            memberlist.append(
+            members.append(
                 DeletedFolder(
                     path=self.path + '/' + ".deleted",
                     environ=self.environ,
             )
 
         if self.provider.show_archive():
-            memberlist.append(
+            members.append(
                 ArchivedFolder(
                     path=self.path + '/' + ".archived",
                     environ=self.environ,
                     workspace=self.workspace
                 )
             )
-
-        return memberlist
+        return members
 
 
 class Folder(Workspace):
         super(Folder, self).__init__(path, environ, workspace)
 
         self.content = content
-        self.path = self.provider.transform_to_display(self.path)
-
-        self.current_path = 'DELETED' if basename(dirname(path)) == '.deleted' \
-            else 'ARCHIVED' if basename(dirname(path)) == '.archived' \
-            else ''
 
     def __repr__(self) -> str:
         return "<DAVCollection: Folder (%s)>" % self.content.label
     def getLastModified(self) -> float:
         return mktime(self.content.updated.timetuple())
 
-    def handleDelete(self):
+    def delete(self):
         Manage(ActionDescription.DELETION, self.content_api, self.content).action()
-        return True
 
-    def delete(self):
-        raise DAVError(HTTP_FORBIDDEN)
-        
     def supportRecursiveMove(self, destpath: str):
         return True
 
         parent = self.provider.get_parent_from_path(
             normpath(destpath),
             self.content_api,
-            WorkspaceApi(self.environ['user']))
+            WorkspaceApi(self.user)
+        )
 
         workspace = self.provider.get_workspace_from_path(
             normpath(destpath),
-            WorkspaceApi(self.environ['user'])
+            WorkspaceApi(self.user)
         )
 
         with new_revision(self.content):
-            if basename(destpath) != self.content.label:
-                self.content_api.update_content(self.content, basename(destpath), self.content.description)
+            if basename(destpath) != self.getDisplayName():
+                self.content_api.update_content(self.content, self.provider.transform_to_bdd(basename(destpath)))
                 self.content_api.save(self.content)
-
-            try:
-                workspace_id = parent.workspace.workspace_id
-            except AttributeError:
-                workspace_id = self.provider.get_workspace_from_path(
-                    destpath, WorkspaceApi(self.environ['user'])
-                ).workspace_id
-
-            if 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)
+                    workspace_id = parent.workspace.workspace_id
                 except AttributeError:
-                    self.content_api.move_recursively(self.content, parent, workspace)
+                    workspace_id = self.provider.get_workspace_from_path(
+                        destpath, WorkspaceApi(self.user)
+                    ).workspace_id
+
+                if 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)
 
         transaction.commit()
 
         self._is_deleted = type == HistoryType.Deleted
 
         self.content_api = ContentApi(
-            current_user=UserApi(None).get_one_by_email(environ['http_authenticator.username']),
+            current_user=self.user,
             show_archived=self._is_archived,
             show_deleted=self._is_deleted
         )
     def getMemberNames(self) -> [str]:
         ret = []
 
-        for content in self.content_api.get_all(self.content.id, ContentType.Any):
+        content_id = None if self.content is None else self.content.id
+        for content in self.content_api.get_all(content_id, ContentType.Any, self.workspace):
             if (self._is_archived and content.is_archived or
                 self._is_deleted and content.is_deleted or
                 not (content.is_archived or self._is_archived or content.is_deleted or self._is_deleted))\
         return True
 
     def getMemberList(self) -> [_DAVResource]:
-        memberlist = []
-        for name in self.getMemberNames():
-            member = self.getMember(name)
-            if member is not None:
-                memberlist.append(member)
-        return memberlist
+        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):
+            members.append(HistoryFileFolder(
+                path='%s/%s' % (self.path, content.get_label()),
+                environ=self.environ,
+                content=content))
+
+        return members
 
 
 class DeletedFolder(HistoryFolder):
     def __init__(self, path: str, environ: dict, workspace: data.Workspace, content: data.Content=None):
         super(DeletedFolder, self).__init__(path, environ, workspace, HistoryType.Deleted, content)
 
-        self.content_api = ContentApi(
-            current_user=environ['user'],
-            show_deleted=True
-        )
-
         self._file_count = 0
 
     def __repr__(self):
         )
 
         return self.provider.getResourceInst(
-            path='%s/%s' % (self.path, content.get_label()),
+            path='%s/%s' % (self.path, self.provider.transform_to_display(content.get_label())),
             environ=self.environ
             )
 
         raise DAVError(HTTP_FORBIDDEN)
 
     def getMemberList(self) -> [_DAVResource]:
-        memberlist = []
+        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):
+            content_path = '%s/%s' % (self.path, self.provider.transform_to_display(content.get_label()))
 
-        for name in self.getMemberNames():
-            member = self.getMember(name)
-            if member is not None:
-                memberlist.append(member)
+            if content.type == ContentType.Folder:
+                members.append(Folder(content_path, self.environ, content, self.workspace))
+            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():
-            memberlist.append(
+            members.append(
                 HistoryFolder(
                     path=self.path + '/' + ".history",
                     environ=self.environ,
                     content=self.content,
-                    type=HistoryType.Deleted,
-                    workspace=self.workspace
+                    workspace=self.workspace,
+                    type=HistoryType.Standard
                 )
             )
 
-        return memberlist
+        return members
 
 
 class ArchivedFolder(HistoryFolder):
     def __init__(self, path: str, environ: dict, workspace: data.Workspace, content: data.Content=None):
         super(ArchivedFolder, self).__init__(path, environ, workspace, HistoryType.Archived, content)
 
-        self.content_api = ContentApi(
-            current_user=environ['user'],
-            show_archived=True
-        )
-
         self._file_count = 0
 
     def __repr__(self) -> str:
         )
 
         return self.provider.getResourceInst(
-            path=self.path + '/' + content.get_label(),
+            path=self.path + '/' + self.provider.transform_to_display(content.get_label()),
             environ=self.environ
-            )
+        )
 
     def getMemberNames(self) -> [str]:
         retlist = []
 
-        for content in self.content_api.get_all(
+        for content in self.content_api.get_all_with_filter(
                 self.content if self.content is None else self.content.id, ContentType.Any):
-            if content.is_archived:
-                retlist.append(content.get_label())
+            retlist.append(content.get_label())
 
-                if content.type != ContentType.Folder:
-                    self._file_count += 1
+            if content.type != ContentType.Folder:
+                self._file_count += 1
 
         return retlist
 
         raise DAVError(HTTP_FORBIDDEN)
 
     def getMemberList(self) -> [_DAVResource]:
-        memberlist = []
+        members = []
 
-        for name in self.getMemberNames():
-            member = self.getMember(name)
-            if member is not None:
-                memberlist.append(member)
+        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):
+            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))
+            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():
-            memberlist.append(
+            members.append(
                 HistoryFolder(
                     path=self.path + '/' + ".history",
                     environ=self.environ,
                     content=self.content,
-                    type=HistoryType.Archived,
-                    workspace=self.workspace
+                    workspace=self.workspace,
+                    type=HistoryType.Standard
                 )
             )
 
-        return memberlist
+        return members
 
 
 class HistoryFileFolder(HistoryFolder):
         )
 
     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"""
         ret = []
 
         for content in self.content.revisions:
-            if content.revision_type in \
-                    [ActionDescription.CREATION, ActionDescription.EDITION, ActionDescription.REVISION]:
-                ret.append(content.revision_id)
+            ret.append(content.revision_id)
 
         return ret
 
     def getMember(self, item_id) -> DAVCollection:
 
         revision = self.content_api.get_one_revision(item_id)
-        
+
+        left_side = '%s/(%d - %s) ' % (self.path, revision.revision_id, revision.revision_type)
+
         if self.content.type == ContentType.File:
             return HistoryFile(
-                path=self.path + '/' + str(revision.revision_id) + '-' + revision.file_name,
+                path='%s%s' % (left_side, self.provider.transform_to_display(revision.file_name)),
                 environ=self.environ,
-                content=self.content, 
+                content=self.content,
                 content_revision=revision)
         else:
             return HistoryOtherFile(
-                path=self.path + '/' + str(revision.revision_id) + '-' + revision.get_label(),
+                path='%s%s' % (left_side, self.provider.transform_to_display(revision.get_label())),
                 environ=self.environ,
                 content=self.content,
                 content_revision=revision)
         raise DAVError(HTTP_FORBIDDEN)
 
     def getMemberList(self) -> [_DAVResource]:
-        memberlist = []
+        members = []
+
+        for content in self.content.revisions:
+
+            left_side = '%s/(%d - %s) ' % (self.path, content.revision_id, content.revision_type)
 
-        for name in self.getMemberNames():
-            member = self.getMember(name)
-            if member is not None:
-                memberlist.append(member)
+            if self.content.type == ContentType.File:
+                members.append(HistoryFile(
+                    path='%s%s' % (left_side, self.provider.transform_to_display(content.file_name)),
+                    environ=self.environ,
+                    content=self.content,
+                    content_revision=content)
+                )
+            else:
+                members.append(HistoryOtherFile(
+                    path='%s%s' % (left_side, self.provider.transform_to_display(content.file_name)),
+                    environ=self.environ,
+                    content=self.content,
+                    content_revision=content)
+                )
 
-        return memberlist
+        return members
 
 
 class File(DAVNonCollection):
         super(File, self).__init__(path, environ)
 
         self.content = content
+        self.user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
+        self.content_api = ContentApi(self.user)
 
-        self.content_api = ContentApi(
-            current_user=environ['user'],
-            show_archived=True,
-            show_deleted=True
-        )
 
     def getPreferredPath(self):
-        if self.content.label == '' or self.path.endswith(mimetypes.guess_extension(self.getContentType())):
-            return self.provider.transform_to_display(self.path)
+        fix_txt = '.txt' if self.getContentType() == 'text/plain' else mimetypes.guess_extension(self.getContentType())
+
+        if self.content.label == '' or self.path.endswith(fix_txt):
+            return self.path
         else:
-            return self.provider.transform_to_display(self.path + mimetypes.guess_extension(self.getContentType()))
+            return self.path + fix_txt
 
     def __repr__(self) -> str:
         return "<DAVNonCollection: File (%d)>" % self.content.revision_id
         return mktime(self.content.created.timetuple())
 
     def getDisplayName(self) -> str:
-        return '%s%s' % (self.content.get_label(), '')
-        # ''.%s' % self.getContentType() if self.content.label != '' else '')
+        return self.content.get_label()
 
     def getLastModified(self) -> float:
         return mktime(self.content.updated.timetuple())
             workspace=self.content.workspace
         )
 
-    def copyMoveSingle(self, destpath: str, ismove: bool):
-        pass #if we use that to move items it'll first call delete function and we get exception about content not
-        # linked to a session, so for now we use moveRecursive
-
     def moveRecursive(self, destpath):
         """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..."""
         parent = self.provider.get_parent_from_path(
             normpath(destpath),
             self.content_api,
-            WorkspaceApi(self.environ['user'])
+            WorkspaceApi(self.user)
         )
 
         workspace = self.provider.get_workspace_from_path(
             normpath(destpath),
-            WorkspaceApi(self.environ['user'])
+            WorkspaceApi(self.user)
         )
 
         with new_revision(self.content):
-            if basename(destpath) != self.content.label:
-                self.content_api.update_content(self.content, basename(destpath), self.content.description)
+            if basename(destpath) != self.getDisplayName():
+                self.content_api.update_content(self.content, re.sub('\.[^\.]+$', '', self.provider.transform_to_bdd(basename(destpath))))
                 self.content_api.save(self.content)
-
-            self.content_api.move(
-                item=self.content,
-                new_parent=parent,
-                must_stay_in_same_workspace=False,
-                new_workspace=workspace
-            )
+            else:
+                self.content_api.move(
+                    item=self.content,
+                    new_parent=parent,
+                    must_stay_in_same_workspace=False,
+                    new_workspace=workspace
+                )
 
         transaction.commit()
 
         return "<DAVNonCollection: HistoryFile (%s-%s)" % (self.content.content_id, self.content.file_name)
 
     def getDisplayName(self) -> str:
-        return str(self.content_revision.revision_id) + '-' + self.content_revision.file_name
+        left_side = '(%d - %s) ' % (self.content_revision.revision_id, self.content_revision.revision_type)
+        return '%s%s' % (left_side, self.provider.transform_to_display(self.content_revision.file_name))
 
     def getContent(self):
         filestream = compat.BytesIO()
 
         self.content_designed = self.design()
 
+        # workaroung 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'):
+            self.path += '.html'
+
     def getDisplayName(self) -> str:
         return self.content.get_label()
 
     def getPreferredPath(self):
-        return self.path + '.html'
+        return self.path
 
     def __repr__(self) -> str:
         return "<DAVNonCollection: OtherFile (%s)" % self.content.file_name
 
     def design(self):
         if self.content.type == ContentType.Page:
-            return designPage(self.content, self.content.revision)
+            return designPage(self.content, self.content_revision)
         else:
             return designThread(
                 self.content,
     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
+        self.content_designed = self.design()
 
     def __repr__(self) -> str:
         return "<DAVNonCollection: HistoryOtherFile (%s-%s)" % (self.content.file_name, self.content.id)
 
     def getDisplayName(self) -> str:
-        return str(self.content_revision.revision_id) + '-' + self.content_revision.get_label()
+        left_side = '(%d - %s) ' % (self.content_revision.revision_id, self.content_revision.revision_type)
+        return '%s%s' % (left_side, self.provider.transform_to_display(self.content_revision.get_label()))
 
     def getContent(self):
         filestream = compat.BytesIO()
     def copyMoveSingle(self, destpath, ismove):
         raise DAVError(HTTP_FORBIDDEN)
 
-
-_CONTENTS = {
-    ContentType.Folder: Folder,
-    ContentType.File: File,
-    ContentType.Page: OtherFile,
-    ContentType.Thread: OtherFile
-}

tracim/tracim/lib/webdav/tracim_http_authenticator.py

 _logger = util.getModuleLogger(__name__, True)
 HOTFIX_WINXP_AcceptRootShareLogin = True
 
+
 class TracimHTTPAuthenticator(HTTPAuthenticator):
     def __init__(self, application, config):
         super(TracimHTTPAuthenticator, self).__init__(application, config)
             # TODO: Chun added this comments, but code was commented out
             # Do not do realm checking - a hotfix for WinXP using some other realm's
             # auth details for this realm - if user/password match
-        print(authheaderdict.get("realm"), realmname)
+
         if 'realm' in authheaderdict:
             if authheaderdict["realm"].upper() != realmname.upper():
                 if HOTFIX_WINXP_AcceptRootShareLogin:

tracim/tracim/model/data.py

     updated = Column(DateTime, unique=False, nullable=False, default=datetime.utcnow)
     is_deleted = Column(Boolean, unique=False, nullable=False, default=False)
     is_archived = Column(Boolean, unique=False, nullable=False, default=False)
+    is_temporary = Column(Boolean, unique=False, nullable=False, default=False)
     revision_type = Column(Unicode(32), unique=False, nullable=False, default='')
 
     workspace_id = Column(Integer, ForeignKey('workspaces.workspace_id'), unique=False, nullable=True)
         return ContentRevisionRO.is_archived
 
     @hybrid_property
+    def is_temporary(self) -> bool:
+        return self.revision.is_temporary
+
+    @is_temporary.setter
+    def is_temporary(self, value: bool) -> None:
+        self.revision.is_temporary = value
+
+    @is_temporary.expression
+    def is_temporary(cls) -> InstrumentedAttribute:
+        return ContentRevisionRO.is_temporary
+
+    @hybrid_property
     def revision_type(self) -> str:
         return self.revision.revision_type