resolve merge conflict

tracim/tracim/lib/content.py

 
         return self._base_query(workspace).filter(Content.content_id==content_id).filter(Content.type==content_type).one()
 
-    # TODO : temporary code for webdav support; make it clean !
     def get_one_revision(self, revision_id: int = None) -> Content:
+        """
+        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
+        :return: An item Content linked with the correct revision
+        """
+        assert revision_id is not None# DYN_REMOVE
 
-        return DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.revision_id == revision_id).one_or_none()
-
-    def get_one_revision2(self, revision_id: int = None):
-        ro = self.get_one_revision(revision_id)
+        revision = DBSession.query(ContentRevisionRO).filter(ContentRevisionRO.revision_id == revision_id)
+        
+        result = self._base_query(None)
 
-        return DBSession.query(Content).filter(Content.id == ro.content_id).one()
+        return result.filter(Content.revision_id == revision_id).one()
 
     def get_one_by_label_and_parent(self, content_label: str, content_parent: Content = None,
                                     workspace: Workspace = None) -> Content:
+        """
+        This method let us request the database to obtain a Content with its name and parent
+        :param content_label: Either the content's label or the content's filename if the label is None
+        :param content_parent: The parent's content
+        :param workspace: The workspace's content
+        :return The corresponding Content
+        """
+        assert content_label is not None# DYN_REMOVE
 
-        if not content_label:
-            return None
-
-        query = self._base_query(workspace)
+        resultset = self._base_query(workspace)
 
         parent_id = content_parent.content_id if content_parent else None
 
-        query = query.filter(Content.parent_id == parent_id)
-
-        res = query.filter(Content.label == content_label).one_or_none()
+        resultset = resultset.filter(Content.parent_id == parent_id)
 
-        return res if res is not None else query.filter(Content.file_name==content_label).one_or_none()
+        try:
+            return resultset.filter(Content.label == content_label).one()
+        except:
+            return resultset.filter(Content.file_name == content_label).one()
 
-    # TODO : end of the webdav's code
-
-    def get_all(self, parent_id: int, content_type: str, workspace: Workspace=None) -> Content:
+    def get_all(self, parent_id: int, content_type: str, 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
         if content_type!=ContentType.Any:
             resultset = resultset.filter(Content.type==content_type)
 
-        # todo : check utilité if parent_id:
         resultset = resultset.filter(Content.parent_id==parent_id)
 
         return resultset.all()
 
+    def get_all_without_exception(self, content_type: str) -> [Content]:
+        assert content_type is not None# DYN_REMOVE
+
+        resultset = self._base_query(None)
+
+        if content_type != ContentType.Any:
+            resultset = resultset.filter(Content.type==content_type)
+
+        return resultset.all()
+
     def get_last_active(self, parent_id: int, content_type: str, workspace: Workspace=None, limit=10) -> [Content]:
         assert parent_id is None or isinstance(parent_id, int) # DYN_REMOVE
         assert content_type is not None# DYN_REMOVE

tracim/tracim/lib/webdav/__init__.py

-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 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'
     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 = []
+class FileStream(object):
+    def __init__(self, file_name: str, content: Content, content_api: ContentApi, new_file: bool):
+        self._buffer = []
+        self._file_name = file_name if file_name != '' else self._content.file_name
         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 beginWrite(self, contentType) -> FileStream:
+        return self
 
-    def close(self):
-        tot = to_bytes('')
-        for buf in self.buflist:
-            tot += buf
+    def endWrite(self, withErrors: bool):
+        pass
 
-        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 write(self, s: str):
+        self._buffer.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)
+        item_content = b''
+
+        for part in self._buffer:
+            item_content += part
+
+        if new_file:
+            file = self._api.create(
+                content_type=ContentType.File,
+                workspace=self._content.workspace,
+                parent=self._content
+                )
+
+            self._api.update_file_data(
+                file,
+                self._file_name,
+                util.guessMimeType(self._file_name),
+                item_content
+                )
+
+            self._api.save(file, ActionDescription.CREATION)
+
+        else:
+            with new_revision(self._content):
+                self._api.update_file_data(
+                    self._content,
+                    self._file_name,
+                    util.guessMimeType(self._content.file_name),
+                    item_content)
+                self._api.save(self._content, ActionDescription.EDITION)
 
         transaction.commit()

tracim/tracim/lib/webdav/sql_dav_provider.py

 
         norm_path = normpath(working_path)
 
-        user = UserApi(None).get_one_by_email(environ['http_authenticator.username'])
-        workspace_api = WorkspaceApi(user)
+        workspace_api = WorkspaceApi(environ['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)
+        api = ContentApi(environ['user'], show_archived=True, show_deleted=True)
 
         working_path = self.reduce_path(path)
 
         elif dirname(path) == "/":
             return self.get_workspace_from_path(
                 path,
-                WorkspaceApi(UserApi(None).get_one_by_email(environ['http_authenticator.username']))
+                WorkspaceApi(environ['user'])
             ) is not None
 
         api = ContentApi(
-            current_user=UserApi(None).get_one_by_email(environ['http_authenticator.username']),
+            current_user=environ['user'],
             show_archived=True,
             show_deleted=True
         )
-        wapi = WorkspaceApi(UserApi(None).get_one_by_email(environ['http_authenticator.username']))
+        wapi = WorkspaceApi(environ['user'])
 
         norm_path = normpath(path)
 

tracim/tracim/lib/webdav/sql_domain_controller.py

         travailler dans la bdd pour vérifier si utilisateur existe
         """
         try:
-            self._api.get_one_by_email(username)
+            environ['user'] = self._api.get_one_by_email(username)
             return True
         except:
             return False

tracim/tracim/lib/workspace.py

     def get_one(self, id):
         return self._base_query().filter(Workspace.workspace_id==id).one()
 
-    def get_one_by_label(self, label: str):
-        return self._base_query().filter(Workspace.label==label).one()
+    def get_one_by_label(self, label: str) -> Workspace:
+        return self._base_query().filter(Workspace.label == label).one()
 
     """
     def get_one_for_current_user(self, id):

tracim/tracim/model/data.py

         if not delta_from_datetime:
             delta_from_datetime = datetime.now()
         return format_timedelta(delta_from_datetime - self.created,
-                                locale=tg.i18n.get_lang()[0])
+                                locale=tg.i18n.get_lang()[0])
+
+    def create_readable_date(self, delta_from_datetime:datetime=None):
+        aff = ''
+
+        if not delta_from_datetime:
+            delta_from_datetime = datetime.now()
+
+        delta = delta_from_datetime - self.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