annotation, few comments, some code refactoring and improvment

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()
-
-        return res if res is not None else query.filter(Content.file_name==content_label).one_or_none()
+        resultset = resultset.filter(Content.parent_id == parent_id)
 
-    # TODO : end of the webdav's code
+        try:
+            return resultset.filter(Content.label == content_label).one()
+        except:
+            return resultset.filter(Content.file_name == content_label).one()
 
-    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)
 
-        if parent_id:
-            resultset = resultset.filter(Content.parent_id==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()
 

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):