some code refactoring

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_resources.py

 from os.path import normpath, dirname, basename
 from tracim.lib.content import ContentApi
 from tracim.lib.webdav import HistoryType
-from tracim.lib.webdav import MyFileStream, MyFileStream2
+from tracim.lib.webdav import FileStream
 from tracim.lib.user import UserApi
 from tracim.lib.workspace import WorkspaceApi
 from wsgidav import compat
     ContentType.Thread: OtherFile
 }
 
-def create_readable_date(some_date):
-    aff = ''
-
-    delta = datetime.now() - some_date
-
-    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
-
 class Encapsuler(object):
     def __init__(self, type: str, api: ContentApi, content: Content):
         self._api = api
 
         transaction.commit()
 
-class DummyResource(object):
-    def __init__(self, file_name: str, content: Content, content_api: ContentApi):
-        self._file_name = file_name
-        self._content = content
-        self._api = content_api
-
-    def beginWrite(self, contentType) -> MyFileStream2:
-        return MyFileStream2(file_name=self._file_name, content=self._content, content_api=self._api)
-
-    def endWrite(self, withErrors):
-        pass
-
-
-class DummyResource2(object):
-    def __init__(self, content: Content, content_api: ContentApi, file_name: str=''):
-        self._content = content
-        self._api = content_api
-        self._file_name = file_name
-
-    def beginWrite(self, contentType) -> MyFileStream:
-        return MyFileStream(content=self._content, content_api=self._api, file_name=self._file_name)
-
-    def endWrite(self, withErrors: bool):
-        pass
-
 
 class Root(DAVCollection):
     def __init__(self, path: str, environ: dict):
             environ=self.environ
             )
 
-    def createEmptyResource(self, file_name: str) -> DummyResource:
-        return DummyResource(file_name=file_name, content=self._content, content_api=self._api)
+    def createEmptyResource(self, file_name: str) -> FileStream:
+        return FileStream(
+            file_name=file_name,
+            content=self._content,
+            content_api=self._api,
+            new_file=True
+            )
 
     def createCollection(self, label: str) -> Folder:
 
     def createCollection(self, name):
         raise DAVError(HTTP_FORBIDDEN)
 
-    def createEmptyResource(self, name) -> DummyResource2:
-        return DummyResource2(content=self._content, content_api=self._api, file_name=name)
+    def createEmptyResource(self, name) -> FileStream:
+        return FileStream(
+            content=self._content,
+            content_api=self._api,
+            file_name=name,
+            new_file=False
+            )
 
     def getMemberNames(self) -> [str]:
-        return [content.revision_id for content in self._content.revisions]
+        return [content.revision_id for content in self._content.revisions \
+                if content.revision_type in [ActionDescription.CREATION, ActionDescription.EDITION, ActionDescription.REVISION]]
 
     def getMember(self, item_id) -> DAVCollection:
 
         histHTML = '<table class="table table-striped table-hover">'
         for event in hist:
             if isinstance(event, VirtualEvent):
-                date = create_readable_date(event.created)
+                date = event.create_readable_date()
                 _LABELS = {
                     'archiving': 'Item archived',
                     'content-comment': 'Item commented',
                             %s
                         </div>
                     </div>
-                    ''' % (t.owner.display_name, create_readable_date(t.created), t.description)
+                    ''' % (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]
                     </div>
                     ''' % (t.type.icon,
                            t.owner.display_name,
-                           create_readable_date(t.created),
+                           t.create_readable_date(),
                            label,
                            '''<span><a href="#">(View revision)</a></span>''' if t.type.id == 'revision' else '')
 
-        descP = ''
-        for name, infos in participants.items():
-            descP = '''
-            <div><b>%s</b> - %d message%s - last %s</div>
-            ''' % (name,
-                 infos[0],
-                 's' if infos[0]>1 else '',
-                   create_readable_date(infos[1]))
-
         page = '''
 <html>
 <head>
 	<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 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>
             %s
         </div>
     </div>
-    <div id="right" class="col-lg-4 col-md-12 col-sm-12 col-xs-12">
-        <h4>Participants</h4>
-        %s
-    </div>
 </body>
 </html>
         ''' % (content.label,
                self._content.created.strftime("%B %d, %Y at %H:%m"),
                self._content.owner.display_name,
                content.description,
-               disc,
-               descP)
+               disc)
 
         return page
 

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