Adding webdav library previously developed, using the py3 version of the wsgidav project

tracim/tracim/lib/webdav/__init__.py

@@ -0,0 +1,82 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+Base = declarative_base()
+
+some_engine = create_engine('postgresql://arnaud:wxc@localhost/template1')
+Session = sessionmaker(bind=some_engine)
+
+from wsgidav.compat import to_bytes
+
+from tracim.lib.content import ContentApi
+from tracim.model import new_revision
+from tracim.model.data import ActionDescription, ContentType, Content
+from wsgidav import util
+
+import transaction
+Base.metadata.create_all(some_engine)
+
+role = {
+    'NOT_APPLICABLE': 0,
+    'READER': 1,
+    'CONTRIBUTOR': 2,
+    'CONTENT_MANAGER': 4,
+    'WORKSPACE_MANAGER': 8
+}
+
+class HistoryType(object):
+    Deleted = 'deleted'
+    Archived = 'archived'
+    Standard = 'standard'
+    All = 'all'
+
+# not_applicable : nothing
+# reader : can only read everything in designed workspace
+# contributor : + create / modify files
+# content_manager : + delete files / create directory / delete directory
+# workspace_manager : + create workspace / delete workspace
+
+class MyFileStream(object):
+    def __init__(self, content: Content, content_api: ContentApi, file_name: str=''):
+        self.buflist = []
+        self._content = content
+        self._api = content_api
+
+        self._file_name = file_name if file_name != '' else self._content.file_name
+
+    def write(self, s):
+        self.buflist.append(s)
+
+    def close(self):
+        tot = to_bytes('')
+        for buf in self.buflist:
+            tot += buf
+
+        with new_revision(self._content):
+            self._api.update_file_data(self._content, self._file_name, util.guessMimeType(self._content.file_name), tot)
+            self._api.save(self._content, ActionDescription.EDITION)
+
+        transaction.commit()
+
+
+class MyFileStream2(object):
+    def __init__(self, file_name: str, content: Content, content_api: ContentApi):
+        self.buflist = []
+        self._file_name = file_name
+        self._content = content
+        self._api = content_api
+
+    def write(self, s):
+        self.buflist.append(s)
+
+    def close(self):
+        tot = to_bytes('')
+        for buf in self.buflist:
+            tot += buf
+
+        file = self._api.create(ContentType.File, self._content.workspace, self._content)
+        self._api.update_file_data(file, self._file_name, util.guessMimeType(self._file_name), tot)
+        self._api.save(file, ActionDescription.CREATION)
+
+        transaction.commit()

tracim/tracim/lib/webdav/lock_storage.py

@@ -0,0 +1,276 @@
+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
+
+_logger = util.getModuleLogger(__name__)
+
+
+def from_dict_to_base(lock):
+    return Lock(
+        token=lock["token"],
+        depth=lock["depth"],
+        root=lock["root"],
+        type=lock["type"],
+        scopre=lock["scope"],
+        owner=lock["owner"],
+        timeout=lock["timeout"],
+        principal=lock["principal"],
+        expire=lock["expire"]
+    )
+
+
+def from_base_to_dict(lock):
+    return {
+        'token': lock.token,
+        'depth': lock.depth,
+        'root': lock.root,
+        'type': lock.type,
+        'scope': lock.scope,
+        'owner': lock.owner,
+        'timeout': lock.timeout,
+        'principal': lock.principal,
+        'expire': lock.expire
+    }
+
+
+class LockStorage(object):
+    LOCK_TIME_OUT_DEFAULT = 604800  # 1 week, in seconds
+    LOCK_TIME_OUT_MAX = 4 * 604800  # 1 month, in seconds
+
+    def __init__(self):
+        self._session = Session()
+        self._lock = ReadWriteLock()
+
+    def __repr__(self):
+        return "C'est bien mon verrou..."
+
+    def __del__(self):
+        pass
+
+    def get_lock_db_from_token(self, token):
+        return self._session.query(Lock).filter(Lock.token == token).one_or_none()
+
+    def _flush(self):
+        """Overloaded by Shelve implementation."""
+        pass
+
+    def open(self):
+        """Called before first use.
+
+        May be implemented to initialize a storage.
+        """
+        pass
+
+    def close(self):
+        """Called on shutdown."""
+        pass
+
+    def cleanup(self):
+        """Purge expired locks (optional)."""
+        pass
+
+    def clear(self):
+        """Delete all entries."""
+        self._session.query(Lock).all().delete(synchronize_session=False)
+        self._session.commit()
+
+    def get(self, token):
+        """Return a lock dictionary for a token.
+
+        If the lock does not exist or is expired, None is returned.
+
+        token:
+            lock token
+        Returns:
+            Lock dictionary or <None>
+
+        Side effect: if lock is expired, it will be purged and None is returned.
+        """
+        self._lock.acquireRead()
+        try:
+            lock_base = self._session.query(Lock).filter(Lock.token == token).one_or_none()
+            if lock_base is None:
+                # Lock not found: purge dangling URL2TOKEN entries
+                _logger.debug("Lock purged dangling: %s" % token)
+                self.delete(token)
+                return None
+            expire = float(lock_base.expire)
+            if 0 <= expire < time.time():
+                _logger.debug("Lock timed-out(%s): %s" % (expire, lockString(from_base_to_dict(lock_base))))
+                self.delete(token)
+                return None
+            return from_base_to_dict(lock_base)
+        finally:
+            self._lock.release()
+
+    def create(self, path, lock):
+        """Create a direct lock for a resource path.
+
+        path:
+            Normalized path (utf8 encoded string, no trailing '/')
+        lock:
+            lock dictionary, without a token entry
+        Returns:
+            New unique lock token.: <lock
+
+        **Note:** the lock dictionary may be modified on return:
+
+        - lock['root'] is ignored and set to the normalized <path>
+        - lock['timeout'] may be normalized and shorter than requested
+        - lock['token'] is added
+        """
+        self._lock.acquireWrite()
+        try:
+            # We expect only a lock definition, not an existing lock
+            assert lock.get("token") is None
+            assert lock.get("expire") is None, "Use timeout instead of expire"
+            assert path and "/" in path
+
+            # Normalize root: /foo/bar
+            org_path = path
+            path = normalizeLockRoot(path)
+            lock["root"] = path
+
+            # Normalize timeout from ttl to expire-date
+            timeout = float(lock.get("timeout"))
+            if timeout is None:
+                timeout = LockStorage.LOCK_TIME_OUT_DEFAULT
+            elif timeout < 0 or timeout > LockStorage.LOCK_TIME_OUT_MAX:
+                timeout = LockStorage.LOCK_TIME_OUT_MAX
+
+            lock["timeout"] = timeout
+            lock["expire"] = time.time() + timeout
+
+            validateLock(lock)
+
+            token = generateLockToken()
+            lock["token"] = token
+
+            # Store lock
+            lock_db = from_dict_to_base(lock)
+
+            self._session.add(lock_db)
+
+            # Store locked path reference
+            url2token = Url2Token(
+                path=path,
+                token=token
+            )
+
+            self._session.add(url2token)
+            self._session.commit()
+
+            self._flush()
+            _logger.debug("LockStorageDict.set(%r): %s" % (org_path, lockString(lock)))
+            #            print("LockStorageDict.set(%r): %s" % (org_path, lockString(lock)))
+            return lock
+        finally:
+            self._lock.release()
+
+    def refresh(self, token, timeout):
+        """Modify an existing lock's timeout.
+
+        token:
+            Valid lock token.
+        timeout:
+            Suggested lifetime in seconds (-1 for infinite).
+            The real expiration time may be shorter than requested!
+        Returns:
+            Lock dictionary.
+            Raises ValueError, if token is invalid.
+        """
+        lock_db = self._session.query(Lock).filter(Lock.token == token).one_or_none()
+        assert lock_db is not None, "Lock must exist"
+        assert timeout == -1 or timeout > 0
+        if timeout < 0 or timeout > LockStorage.LOCK_TIME_OUT_MAX:
+            timeout = LockStorage.LOCK_TIME_OUT_MAX
+
+        self._lock.acquireWrite()
+        try:
+            # Note: shelve dictionary returns copies, so we must reassign values:
+            lock_db.timeout = timeout
+            lock_db.expire = time.time() + timeout
+            self._session.commit()
+            self._flush()
+        finally:
+            self._lock.release()
+        return from_base_to_dict(lock_db)
+
+    def delete(self, token):
+        """Delete lock.
+
+        Returns True on success. False, if token does not exist, or is expired.
+        """
+        self._lock.acquireWrite()
+        try:
+            lock_db = self._session.query(Lock).filter(Lock.token == token).one_or_none()
+            _logger.debug("delete %s" % lockString(from_base_to_dict(lock_db)))
+            if lock_db is None:
+                return False
+            # Remove url to lock mapping
+            url2token = self._session.query(Url2Token).filter(
+                Url2Token.path == lock_db.root,
+                Url2Token.token == token).one_or_none()
+            if url2token is not None:
+                self._session.delete(url2token)
+            # Remove the lock
+            self._session.delete(lock_db)
+            self._session.commit()
+
+            self._flush()
+        finally:
+            self._lock.release()
+        return True
+
+    def getLockList(self, path, includeRoot, includeChildren, tokenOnly):
+        """Return a list of direct locks for <path>.
+
+        Expired locks are *not* returned (but may be purged).
+
+        path:
+            Normalized path (utf8 encoded string, no trailing '/')
+        includeRoot:
+            False: don't add <path> lock (only makes sense, when includeChildren
+            is True).
+        includeChildren:
+            True: Also check all sub-paths for existing locks.
+        tokenOnly:
+            True: only a list of token is returned. This may be implemented
+            more efficiently by some providers.
+        Returns:
+            List of valid lock dictionaries (may be empty).
+        """
+        assert path and path.startswith("/")
+        assert includeRoot or includeChildren
+
+        def __appendLocks(toklist):
+            # Since we can do this quickly, we use self.get() even if
+            # tokenOnly is set, so expired locks are purged.
+            for token in toklist:
+                lock_db = self.get_lock_db_from_token(token)
+                if lock_db:
+                    if tokenOnly:
+                        lockList.append(lock_db.token)
+                    else:
+                        lockList.append(from_base_to_dict(lock_db))
+
+        path = normalizeLockRoot(path)
+        self._lock.acquireRead()
+        try:
+            tokList = self._session.query(Url2Token.token).filter(Url2Token.path == path).all()
+            lockList = []
+            if includeRoot:
+                __appendLocks(tokList)
+
+            if includeChildren:
+                for url, in self._session.query(Url2Token.path).group_by(Url2Token.path):
+                    if util.isChildUri(path, url):
+                        __appendLocks(self._session.query(Url2Token.token).filter(Url2Token.path == url))
+
+            return lockList
+        finally:
+            self._lock.release()

tracim/tracim/lib/webdav/sql_dav_provider.py

@@ -0,0 +1,497 @@
+# coding: utf8
+
+from tracim.lib.webdav import HistoryType
+from tracim.lib.webdav.lock_storage import LockStorage
+
+import re
+from os.path import basename, dirname, normpath
+from tracim.lib.content import ContentApi
+from tracim.lib.webdav import sql_resources
+from tracim.lib.user import UserApi
+from tracim.lib.workspace import WorkspaceApi
+from wsgidav import util
+from wsgidav.dav_provider import DAVProvider
+from wsgidav.lock_manager import LockManager
+from tracim.model.data import ContentType
+
+######################################
+
+__docformat__ = "reStructuredText"
+_logger = util.getModuleLogger(__name__)
+
+
+def wsgi_decode(s):
+    return s.encode('latin1').decode()
+
+def wsgi_encode(s):
+    if isinstance(s, bytes):
+        return s.decode('latin1')
+    return s.encode().decode('latin1')
+
+
+# ============================================================
+# PostgreSQLProvider
+# ============================================================
+class Provider(DAVProvider):
+    def __init__(self, manage_lock=True):
+        super(Provider, self).__init__()
+
+        if manage_lock:
+            self.lockManager = LockManager(LockStorage())
+
+    def __repr__(self):
+        return 'Provider'
+
+    #########################################################
+    # Everything override from DAVProvider
+    def getResourceInst(self, path, environ):
+
+        working_path = path
+
+        if not self.exists(path, environ):
+            return None
+
+        if path == "/":
+            return sql_resources.Root(path, environ)
+
+        norm_path = normpath(working_path)
+
+        user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
+        workspace_api = WorkspaceApi(user)
+
+        if dirname(norm_path) == "/":
+            workspace = self.get_workspace_from_path(norm_path, workspace_api)
+            return sql_resources.Workspace(path, environ, workspace)
+
+
+        api = ContentApi(user, show_archived=True, show_deleted=True)
+
+        working_path = self.reduce_path(path)
+
+        content = self.get_content_from_path(working_path, 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)
+
+        # 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)
+
+        # is history
+        is_history_folder = re.search(r'/\.history$', norm_path) is not None
+
+        if 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
+
+            type = HistoryType.Deleted if is_deleted_folder \
+                else HistoryType.Archived if is_archived_folder \
+                else HistoryType.Standard
+
+            return sql_resources.HistoryFolder(path, environ, content, 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)
+
+        # 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 content.type == ContentType.File:
+                return sql_resources.HistoryFile(path, environ, content, content_revision)
+            else:
+                return sql_resources.HistoryOtherFile(path, environ, content, content_revision)
+
+        # other
+        if content.type == ContentType.Folder:
+            return sql_resources.Folder(path, environ, content)
+
+        if content.type == ContentType.File:
+            return sql_resources.File(path, environ, content, False)
+        else:
+            return sql_resources.OtherFile(path, environ, content)
+
+    def exists(self, path, environ):
+        path = normpath(path)
+        if path == "/":
+            return True
+        elif dirname(path) == "/":
+            return self.get_workspace_from_path(
+                path,
+                WorkspaceApi(UserApi(None).get_one_by_email(environ['http_authenticator.username']))
+            ) is not None
+
+        api = ContentApi(
+            current_user=UserApi(None).get_one_by_email(environ['http_authenticator.username']),
+            show_archived=True,
+            show_deleted=True
+        )
+        wapi = WorkspaceApi(UserApi(None).get_one_by_email(environ['http_authenticator.username']))
+
+        norm_path = normpath(path)
+
+        is_archived = re.search(r'/\.archived/(\.history/)?(?!\.history)[^/]*(/\.)?(history|deleted|archived)?$', norm_path) is not None
+
+        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)
+
+        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)
+
+        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)
+
+    def reduce_path(self, path):
+        path = re.sub(r'/\.archived', r'', path)
+        path = re.sub(r'/\.deleted', r'', path)
+        path = re.sub(r'/\.history/[^/]+/(\d+)-.+', r'/\1', path)
+        path = re.sub(r'/\.history/([^/]+)', r'/\1', path)
+        path = re.sub(r'/\.history', r'', path)
+
+        return path
+
+    def get_content_from_path(self, path, api: ContentApi, workspace_api: WorkspaceApi):
+        path = normpath(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)
+        else:
+            parent = self.get_parent_from_path(path, api, workspace_api)
+            if parent is not None:
+                return api.get_one_by_label_and_parent(basename(path), content_parent=parent)
+            return None
+
+    def get_content_from_revision(self, revision_id: int, api:ContentApi):
+        return api.get_one_revision(revision_id)
+
+    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])
+
+    #########################################################
+    # Everything that transform path
+    '''
+    def from_id_to_name(self, path):
+        path_ret = ''
+
+        for item_id in path.split('/'):
+            if item_id == '':
+                pass
+            elif path_ret == '':
+                path_ret += '/' + self.get_workspace({'workspace_id': item_id}).label
+            else:
+                path_ret += '/' + self.get_item({'id': item_id}).item_name
+
+        return path_ret
+
+    def from_name_to_id(self, path):
+        if path == '/':
+            return '/'
+        path_ret = ""
+        last_id = None
+        workspace_id = None
+
+        for item_name in path.split("/"):
+            if item_name == '':
+                pass
+            elif path_ret == '':
+                workspace = self.get_workspace({'label': item_name})
+                if workspace is None:
+                    return None
+
+                workspace_id = workspace.workspace_id
+                path_ret += '/' + str(workspace_id)
+            else:
+                item = self.get_item(
+                    {
+                        'parent_id': last_id,
+                        'item_name': item_name,
+                        'workspace_id': workspace_id,
+                        'child_revision_id': None
+                    }
+                )
+
+                if item is None:
+                    return None
+
+                last_id = item.id
+                path_ret += '/' + str(last_id)
+
+        return path_ret
+
+    #########################################################
+    # Everything that check things (lol) ...
+    def has_right(self, username, workspace_id, expected=0):
+        ret = self.session.query(UserRoleInWorkspace.role).filter(
+            UserRoleInWorkspace.workspace_id == workspace_id,
+            User.user_id == UserRoleInWorkspace.user_id,
+            User.display_name == username
+        ).one_or_none()
+
+        return ret is not None and role[ret.role] >= expected
+
+    def exist_revision(self, item_name, item_id):
+        return self.get_item({'id': item_id, 'item_name': item_name}) is not None
+
+    @staticmethod
+    def is_history(path):
+        return normpath(path).endswith('.history')
+
+    #########################################################
+    # Everything that goes with "delete"
+    def delete_item(self, element):
+        self.session.delete(element)
+        self.session.commit()
+
+    #########################################################
+    # Everything that goes with "add"
+    def add_item(self, item_name, item_type, workspace_id, parent_id=None, parent_revision_id=None,
+                 child_revision_id=None, item_content=None, created=None, updated=None):
+
+        item = ItemRevision(
+            item_name=to_unicode(item_name),
+            item_type=to_unicode(item_type),
+            item_content=item_content,
+            workspace_id=workspace_id,
+            parent_id=parent_id,
+            created=created,
+            updated=updated,
+            parent_revision_id=parent_revision_id,
+            child_revision_id=child_revision_id
+        )
+
+        self.session.add(item)
+        self.session.commit()
+
+        return item
+
+    def add_workspace(self, environ, label):
+        workspace = Workspace(label=label)
+
+        self.session.add(workspace)
+
+        user = self.get_user_with_name(environ['http_authenticator.username'])
+
+        user_workspace = UserRoleInWorkspace(
+            role='WORKSPACE_MANAGER',
+            workspace_id=workspace.workspace_id,
+            user_id=user.user_id
+        )
+
+        self.session.add(user_workspace)
+        self.session.commit()
+
+        return workspace
+
+    #########################################################
+    # Everything that goes with "set"
+    def set_workspace_label(self, workspace, label):
+        workspace.label = label
+        self.session.commit()
+
+    #########################################################
+    # Everything that goes with "get"
+    def get_all_revisions_from_item(self, item, only_id=False):
+        ret = []
+        current_item = item
+        while current_item is not None:
+            if only_id:
+                ret.insert(0,current_item.id)
+            else:
+                ret.insert(0,current_item)
+
+            current_item = self.get_item(
+                {
+                    'child_revision_id': current_item.id
+                }
+            )
+
+        return ret
+
+    def get_item(self, keys_dict):
+        query = self.session.query(ItemRevision)
+
+        for key, value in keys_dict.items():
+            query = query.filter(getattr(ItemRevision, key) == value)
+        return query.first()
+
+    def get_item_children(self, item_id):
+        items_result = self.session.query(ItemRevision.id).filter(
+            ItemRevision.parent_id == item_id,
+            ItemRevision.child_revision_id.is_(None)
+        )
+
+        ret_id = []
+        for item in items_result:
+            ret_id.append(item.id)
+
+        return ret_id
+
+    def get_workspace_id_from_path(self, path):
+        return int(self.get_id_from_path('/' + path.split('/')[1]))
+
+    def get_workspace_children_id(self, workspace):
+        items_result = self.session.query(ItemRevision.id).filter(
+            ItemRevision.parent_id.is_(None),
+            ItemRevision.workspace_id == workspace.workspace_id
+        )
+
+        ret = []
+        for item in items_result:
+            ret.append(item.id)
+
+        return ret
+
+    # on workspaces
+    def get_workspace(self, keys_dict):
+        query = self.session.query(Workspace)
+
+        for key, value in keys_dict.items():
+            query = query.filter(getattr(Workspace, key) == value)
+        return query.one_or_none()
+
+    def get_all_workspaces(self, only_name=False):
+        retlist = []
+        for workspace in self.session.query(Workspace).all():
+            if only_name:
+                retlist.append(workspace.label)
+            else:
+                retlist.append(workspace)
+
+        return retlist
+
+    # on users
+    def get_user_with_name(self, username):
+        return self.session.query(User).filter(
+            User.display_name == username
+        ).one_or_none()
+
+    # on path
+    def get_id_from_path(self, path):
+        path_id = self.from_name_to_id(path)
+
+        if path_id == '/':
+            return None
+        else:
+            return int(basename(path_id))
+
+    def get_parent_id_from_path(self, path):
+        return self.get_id_from_path(dirname(path))
+
+    #########################################################
+    # Everything that goes with "move"
+    def move_item(self, item, destpath):
+        path = normpath(destpath)
+
+        if dirname(dirname(path)) == '/':
+            new_parent = None
+        else:
+            new_parent = self.get_parent_id_from_path(path)
+
+        item.parent_id = new_parent
+        item.workspace_id = self.get_workspace_id_from_path(path)
+        item.item_name = basename(path)
+        self.session.commit()
+
+    def move_all_revisions(self, item, destpath):
+        path = normpath(destpath)
+        new_parent = self.get_parent_id_from_path(path)
+        new_workspace = self.get_workspace_id_from_path(destpath)
+
+        items = self.get_all_revisions_from_item(item)
+
+        for current_item in items:
+            current_item.parent_id = new_parent
+            current_item.workspace_id = new_workspace
+
+        new_name = basename(normpath(destpath))
+
+        new_item = self.add_item(
+            item_name=new_name,
+            item_type=item.item_type,
+            workspace_id=item.workspace_id,
+            parent_id=item.parent_id,
+            parent_revision_id=item.id,
+            child_revision_id=None,
+            item_content=item.item_content,
+            created=item.created,
+            updated=datetime.now()
+        )
+
+        item.child_revision_id = new_item.id
+
+        self.session.commit()
+
+    #########################################################
+    # Everything that goes with "copy"
+    def copy_item(self, item, destpath):
+        path = normpath(destpath)
+
+        new_parent = self.get_parent_id_from_path(path)
+        new_workspace = self.get_workspace_id_from_path(path)
+        items = self.get_all_revisions_from_item(item)
+
+        first = True
+        last_item = None
+
+        for current_item in items:
+            new_item = self.add_item(
+                item_name=current_item.item_name,
+                item_type=current_item.item_type,
+                workspace_id=new_workspace,
+                parent_id=new_parent,
+                parent_revision_id=None,
+                child_revision_id=None,
+                item_content=current_item.item_content,
+                created=current_item.created,
+                updated=current_item.updated
+            )
+
+            if not first:
+                last_item.child_revision_id = new_item.id
+                new_item.parent_revision_id = last_item.id
+
+            first = False
+            last_item = new_item
+
+        new_name = basename(destpath)
+        
+        new_item = self.add_item(
+            item_name=new_name,
+            item_type=item.item_type,
+            workspace_id=new_workspace,
+            parent_id=new_parent,
+            parent_revision_id=last_item.id,
+            child_revision_id=None,
+            item_content=item.item_content,
+            created=datetime.now(),
+            updated=datetime.now()
+        )
+
+        last_item.child_revision_id = new_item.id
+
+        self.session.commit()'''

tracim/tracim/lib/webdav/sql_domain_controller.py

@@ -0,0 +1,41 @@
+# coding: utf8
+
+from tracim.lib.user import UserApi
+
+class SQLDomainController(object):
+
+    def __init__(self, presetdomain = None, presetserver = None):
+        self._api = UserApi(None)
+
+    def getDomainRealm(self, inputURL, environ):
+        """
+        On va récupérer le workspace de travail pour travailler sur les droits
+        """
+        return '/'
+
+    def requireAuthentication(self, realmname, environ):
+        return True
+
+    def isRealmUser(self, realmname, username, environ):
+        """
+        travailler dans la bdd pour vérifier si utilisateur existe
+        """
+        try:
+            self._api.get_one_by_email(username)
+            return True
+        except:
+            return False
+
+    def getRealmUserPassword(self, realmname, username, environ):
+        """Retourne le mdp pour l'utilisateur pour ce real"""
+        try:
+            user = self._api.get_one_by_email(username)
+            return 'test'
+            return user.password
+        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_model.py

@@ -0,0 +1,88 @@
+from datetime import datetime
+
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+from sqlalchemy import Sequence
+from sqlalchemy.orm import deferred
+from sqlalchemy.types import DateTime, Integer, LargeBinary, Unicode, UnicodeText, Float
+from tracim.lib.webdav import Base
+from wsgidav.compat import to_unicode, to_bytes
+
+# ==================================================
+# Content
+# ==================================================
+class Workspace(Base):
+    __tablename__ = 'my_workspaces'
+
+    workspace_id = Column(Integer, Sequence('my_seq__workspace__id'), autoincrement=True, primary_key=True)
+    label = Column(Unicode(255), unique=False, nullable=False, default=to_unicode(''))
+
+    created = Column(DateTime, unique=False, nullable=False, default=datetime.now)
+    updated = Column(DateTime, unique=False, nullable=False, default=datetime.now)
+
+    def __repr__(self):
+        return "<Workspace %s : %s>" % (self.workspace_id, self.label)
+
+
+class User(Base):
+    __tablename__ = 'my_users'
+
+    user_id = Column(Integer, Sequence('my_seq__users__id'), autoincrement=True, primary_key=True)
+    display_name = Column(Unicode(255), unique=True, nullable=False, default=to_unicode(''))
+    password = Column(Unicode(255), unique=False, nullable=False, default=to_unicode(''))
+
+    def __repr__(self):
+        return "<User %s : %s>" % (self.user_id, self.display_name)
+
+
+class UserWorkspace(Base):
+    __tablename__ = 'my_user_workspace'
+
+    workspace_id = Column(Integer, ForeignKey('my_workspaces.workspace_id', ondelete="CASCADE"), nullable=False, primary_key=True)
+    user_id = Column(Integer, ForeignKey('my_users.user_id', ondelete="CASCADE"), nullable=False, primary_key=True)
+    role = Column(Unicode(255), unique=False, nullable=False, default=u'NOT_APPLICABLE')
+
+    def __repr__(self):
+        return "<Role (W:%s, U:%s) : %s" % (self.workspace_id, self.user_id, self.role)
+
+
+class ItemRevision(Base):
+    __tablename__ = 'my_items_revisions'
+
+    id = Column(Integer, Sequence('my_seq__items__id'), autoincrement=True, primary_key=True)
+    workspace_id = Column(Integer, ForeignKey('my_workspaces.workspace_id', ondelete="CASCADE"), nullable=False)
+    parent_id = Column(Integer, ForeignKey('my_items_revisions.id', ondelete="CASCADE"), nullable=True, default=None)
+
+    item_type = Column(Unicode(32), unique=False, nullable=False)
+    item_name = Column(Unicode(255), unique=False, nullable=False, default=to_unicode(''))
+    item_content = deferred(Column(LargeBinary(), unique=False, nullable=True, default=to_bytes('')))
+
+    created = Column(DateTime, unique=False, nullable=False, default=datetime.now)
+    updated = Column(DateTime, unique=False, nullable=False, default=datetime.now)
+
+    parent_revision_id = Column(Integer, ForeignKey('my_items_revisions.id', ondelete="CASCADE"), nullable=True, default=None)
+    child_revision_id = Column(Integer, ForeignKey('my_items_revisions.id', ondelete="CASCADE"), nullable=True, default=None)
+
+    def __repr__(self):
+        return "<Content %s : %s in %s>" % (self.id, self.item_name, self.parent_id)
+
+
+class Lock(Base):
+    __tablename__ = 'my_locks'
+
+    token = Column(UnicodeText, primary_key=True, unique=True, nullable=False)
+    depth = Column(Unicode(32), unique=False, nullable=False, default=to_unicode('infinity'))
+    root = Column(UnicodeText, unique=False, nullable=False)
+    type = Column(Unicode(32), unique=False, nullable=False, default=to_unicode('write'))
+    scope = Column(Unicode(32), unique=False, nullable=False, default=to_unicode('exclusive'))
+    owner = Column(UnicodeText, unique=False, nullable=False)
+    expire = Column(Float, unique=False, nullable=False)
+    principal = Column(Unicode(255), ForeignKey('my_users.display_name', ondelete="CASCADE"))
+    timeout = Column(Float, unique=False, nullable=False)
+
+
+class Url2Token(Base):
+    __tablename__ = 'my_url2token'
+
+    token = Column(UnicodeText, primary_key=True, unique=True, nullable=False)
+    path = Column(UnicodeText, primary_key=True, unique=False, nullable=False)

tracim/tracim/lib/webdav/style.css

@@ -0,0 +1,3 @@
+body {
+    background: red
+}