allow to activate/desactive content view in left side treeview

tracim/development.ini.base

 website.home.subtitle = Default login: admin@admin.admin (password: admin@admin.admin)
 website.home.tag_line = <div class="text-center" style="font-weight: bold;">Collaboration, versionning and traceability</div>
 website.home.below_login_form = in case of problem, please contact the administrator.
+# Values may be 'all' or 'folders'
+website.treeview.content = all
 
 # The following base_url is used for links and icons
 # integrated in the email notifcations

tracim/tracim/config/app_cfg.py

 from sqlalchemy import and_
 #This tells to TurboGears how to retrieve the data for your user
 class ApplicationAuthMetadata(TGAuthMetadata):
+
     def __init__(self, sa_auth):
         self.sa_auth = sa_auth
+
     def authenticate(self, environ, identity):
-        user = self.sa_auth.dbsession.query(self.sa_auth.user_class).filter(and_(self.sa_auth.user_class.is_active==True, self.sa_auth.user_class.email==identity['login'])).first()
+        user = self.sa_auth.dbsession.query(self.sa_auth.user_class).filter(and_(
+            self.sa_auth.user_class.is_active==True,
+            self.sa_auth.user_class.email==identity['login']
+        )).first()
+
         if user and user.validate_password(identity['password']):
             return identity['login']
     def get_user(self, identity, userid):
         self.TRACKER_JS_PATH = tg.config.get('js_tracker_path')
         self.TRACKER_JS_CONTENT = self.get_tracker_js_content(self.TRACKER_JS_PATH)
 
+        self.WEBSITE_TREEVIEW_CONTENT = tg.config.get('website.treeview.content')
+
 
     def get_tracker_js_content(self, js_tracker_file_path = None):
         js_tracker_file_path = tg.config.get('js_tracker_path', None)
         ASYNC = 'ASYNC'
         SYNC = 'SYNC'
 
+        TREEVIEW_FOLDERS = 'folders'
+        TREEVIEW_ALL = 'all'
+
 #######
 #
 # INFO - D.A. - 2014-11-05

tracim/tracim/controllers/workspace.py

 from tg.i18n import ugettext as _
 from tg.predicates import not_anonymous
 
+from tracim.config.app_cfg import CFG
+
 from tracim.controllers import TIMRestController
 from tracim.controllers.content import UserWorkspaceFolderRestController
 
 from tracim.model.serializers import Context, CTX, DictLikeClass
 
 
-
-
 class UserWorkspaceRestController(TIMRestController):
 
     allow_only = not_anonymous()
         # including the selected node, all parents (and their siblings)
         workspace, content = convert_id_into_instances(current_id)
 
+        # The following step allow to select the parent folder when content itself is not visible in the treeview
+        if content.type!=ContentType.Folder and CFG.CST.TREEVIEW_ALL!=CFG.get_instance().WEBSITE_TREEVIEW_CONTENT:
+            content = content.parent if content.parent else None
+
         # This is the init of the recursive-like build of the tree
         content_parent = content
         tree_items = []
 
         return Context(CTX.MENU_API_BUILD_FROM_TREE_ITEM).toDict(full_tree, 'd')
 
-
     def _build_sibling_list_of_workspaces(self, workspace: Workspace, child_contents: [NodeTreeItem], select_active_workspace = False, all_workspaces = True) -> [NodeTreeItem]:
 
         root_items = []
 
         return root_items
 
+
     def _build_sibling_list_of_tree_items(self,
                                           workspace: Workspace,
                                           content: Content,
         tree_items = []
 
         parent = content.parent if content else None
-        for child in api.get_child_folders(parent, workspace, allowed_content_types, ignored_item_ids):
+
+        viewable_content_types = self._get_treeviewable_content_types_or_none()
+        child_contents = api.get_child_folders(parent, workspace, allowed_content_types, ignored_item_ids, viewable_content_types)
+        for child in child_contents:
             children_to_add = children if child==content else []
-            is_selected = True if select_active_node and child==content else False
+            if child==content and select_active_node:
+                # The item is the requested node, so we select it
+                is_selected = True
+            elif content not in child_contents and select_active_node and child==content:
+                # The item is not present in the list, so we select its parent node
+                is_selected = True
+            else:
+                is_selected = False
+
             new_item = NodeTreeItem(child, children_to_add, is_selected)
             tree_items.append(new_item)
 
+        # This allow to show contents and folders group by type
+        tree_items = ContentApi.sort_tree_items(tree_items)
 
         return parent, tree_items
 
 
         ignore_item_ids = [int(ignore_id)] if ignore_id else []
         workspace, content = convert_id_into_instances(id)
-        contents = ContentApi(tmpl_context.current_user).get_child_folders(content, workspace, [], ignore_item_ids)
 
-        dictified_contents = Context(CTX.MENU_API).toDict(contents, 'd')
+        viewable_content_types = self._get_treeviewable_content_types_or_none()
+        contents = ContentApi(tmpl_context.current_user).get_child_folders(content, workspace, [], ignore_item_ids, viewable_content_types)
+        # This allow to show contents and folders group by type
+        sorted_contents = ContentApi.sort_content(contents)
+
+        dictified_contents = Context(CTX.MENU_API).toDict(sorted_contents, 'd')
         return dictified_contents
 
+    def _get_treeviewable_content_types_or_none(self):
+        if CFG.get_instance().WEBSITE_TREEVIEW_CONTENT==CFG.CST.TREEVIEW_ALL:
+            return ContentType.Any
+        return None # None means "workspaces and folders"

tracim/tracim/lib/__init__.py

 # l_('November')
 # l_('December')
 
+
+def cmp_to_key(mycmp):
+    """
+    List sort related function
+
+    Convert a cmp= function into a key= function
+    """
+    class K(object):
+        def __init__(self, obj, *args):
+            self.obj = obj
+        def __lt__(self, other):
+            return mycmp(self.obj, other.obj) < 0
+        def __gt__(self, other):
+            return mycmp(self.obj, other.obj) > 0
+        def __eq__(self, other):
+            return mycmp(self.obj, other.obj) == 0
+        def __le__(self, other):
+            return mycmp(self.obj, other.obj) <= 0
+        def __ge__(self, other):
+            return mycmp(self.obj, other.obj) >= 0
+        def __ne__(self, other):
+            return mycmp(self.obj, other.obj) != 0
+    return K

tracim/tracim/lib/content.py

 import tg
 
 from sqlalchemy.orm.attributes import get_history
+from tracim.lib import cmp_to_key
 from tracim.lib.notifications import Notifier
 from tracim.model import DBSession
 from tracim.model.auth import User
 from tracim.model.data import ContentStatus, ContentRevisionRO, ActionDescription
 from tracim.model.data import Content
 from tracim.model.data import ContentType
+from tracim.model.data import NodeTreeItem
 from tracim.model.data import Workspace
 
+def compare_content_for_sorting_by_type_and_name(content1: Content, content2: Content):
+    """
+    :param content1:
+    :param content2:
+    :return:    1 if content1 > content2
+                -1 if content1 < content2
+                0 if content1 = content2
+    """
+
+    if content1.type==content2.type:
+        if content1.get_label().lower()>content2.get_label().lower():
+            return 1
+        elif content1.get_label().lower()<content2.get_label().lower():
+            return -1
+        return 0
+    else:
+        # TODO - D.A. - 2014-12-02 - Manage Content Types Dynamically
+        content_type_order = [ContentType.Folder, ContentType.Page, ContentType.Thread, ContentType.File]
+        result = content_type_order.index(content1.type)-content_type_order.index(content2.type)
+        if result<0:
+            return -1
+        elif result>0:
+            return 1
+        else:
+            return 0
+
+def compare_tree_items_for_sorting_by_type_and_name(item1: NodeTreeItem, item2: NodeTreeItem):
+    return compare_content_for_sorting_by_type_and_name(item1.node, item2.node)
+
+
 class ContentApi(object):
 
-    def __init__(self, current_user: User, show_archived=False, show_deleted=False):
+    def __init__(self, current_user: User, show_archived=False, show_deleted=False, all_content_in_treeview=True):
         self._user = current_user
         self._show_archived = show_archived
         self._show_deleted = show_deleted
+        self._show_all_type_of_contents_in_treeview = all_content_in_treeview
+
+
+    @classmethod
+    def sort_tree_items(cls, content_list: [NodeTreeItem])-> [Content]:
+        news = []
+        for item in content_list:
+            news.append(item)
+
+        content_list.sort(key=cmp_to_key(compare_tree_items_for_sorting_by_type_and_name))
+
+        return content_list
+
+
+    @classmethod
+    def sort_content(cls, content_list: [Content])-> [Content]:
+        content_list.sort(key=cmp_to_key(compare_content_for_sorting_by_type_and_name))
+        return content_list
+
 
     def _base_query(self, workspace: Workspace=None):
         result = DBSession.query(Content)
 
         return result
 
-    def get_child_folders(self, parent: Content=None, workspace: Workspace=None, filter_by_allowed_content_types: list=[], removed_item_ids: list=[]) -> [Content]:
+    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]:
+        """
+        This method returns child items (folders or items) for left bar treeview.
+
+        :param parent:
+        :param workspace:
+        :param filter_by_allowed_content_types:
+        :param removed_item_ids:
+        :param allowed_node_types:
+        :return:
+        """
+        if not allowed_node_types:
+            allowed_node_types = [ContentType.Folder]
+        elif allowed_node_types==ContentType.Any:
+            allowed_node_types = ContentType.all()
 
         parent_id = parent.content_id if parent else None
         folders = self._base_query(workspace).\
             filter(Content.parent_id==parent_id).\
-            filter(Content.type==ContentType.Folder).\
+            filter(Content.type.in_(allowed_node_types)).\
             filter(Content.content_id.notin_(removed_item_ids)).\
             all()
 
         result = []
         for folder in folders:
             for allowed_content_type in filter_by_allowed_content_types:
-                if folder.properties['allowed_content'][allowed_content_type]==True:
+                if folder.type==ContentType.Folder and folder.properties['allowed_content'][allowed_content_type]==True:
                     result.append(folder)
 
         return result

tracim/tracim/lib/helpers.py

     try:
         content_data = content_str.split(CST.TREEVIEW_MENU.ID_SEPARATOR)
         content_id = int(content_data[1])
-        content = ContentApi(tg.tmpl_context.current_user).get_one(content_id, ContentType.Folder)
+        content = ContentApi(tg.tmpl_context.current_user).get_one(content_id, ContentType.Any)
     except (IndexError, ValueError) as e:
         content = None
 

tracim/tracim/lib/workspace.py

     def get_notifiable_roles(self, workspace: Workspace) -> [UserRoleInWorkspace]:
         roles = []
         for role in workspace.roles:
-            print(role.user.email)
             if role.do_notify==True and role.user!=self._user:
                 roles.append(role)
         return roles

tracim/tracim/model/data.py

                 return role.role
         return UserRoleInWorkspace.NOT_APPLICABLE
 
-
+    def get_label(self):
+        """ this method is for interoperability with Content class"""
+        return self.label
 
 class UserRoleInWorkspace(DeclarativeBase):
 
         'comment': 'apps/internet-group-chat',
     }
 
+    _ORDER_WEIGHT = {
+        'folder': 0,
+        'page': 1,
+        'thread': 2,
+        'file': 3,
+        'comment': 4,
+    }
+
     @classmethod
     def icon(cls, type: str):
         assert(type in ContentType._ICONS) # DYN_REMOVE
         return ContentType._ICONS[type]
 
     @classmethod
+    def all(cls):
+        return cls.allowed_types()
+
+    @classmethod
     def allowed_types(cls):
         return [cls.Folder, cls.File, cls.Comment, cls.Thread, cls.Page]
 
                 allowed_types.append(item)
         return allowed_types
 
+    @classmethod
+    def fill_url(cls, content: 'Content'):
+        # TODO - DYNDATATYPE - D.A. - 2014-12-02
+        # Make this code dynamic loading data types
+
+        if content.type==ContentType.Folder:
+            return '/workspaces/{}/folders/{}'.format(content.workspace_id, content.content_id)
+        elif content.type==ContentType.File:
+            return '/workspaces/{}/folders/{}/files/{}'.format(content.workspace_id, content.parent_id, content.content_id)
+        elif content.type==ContentType.Thread:
+            return '/workspaces/{}/folders/{}/threads/{}'.format(content.workspace_id, content.parent_id, content.content_id)
+        elif content.type==ContentType.Page:
+            return '/workspaces/{}/folders/{}/pages/{}'.format(content.workspace_id, content.parent_id, content.content_id)
+
+    @classmethod
+    def fill_url_for_workspace(cls, workspace: Workspace):
+        # TODO - DYNDATATYPE - D.A. - 2014-12-02
+        # Make this code dynamic loading data types
+        return '/workspaces/{}'.format(workspace.workspace_id)
+
+
 class Content(DeclarativeBase):
 
     __tablename__ = 'contents'
                     child_nb = child_nb+1
         return child_nb
 
+    def get_label(self):
+        return self.label if self.label else self.file_name if self.file_name else ''
+
     def get_status(self) -> ContentStatus:
         return ContentStatus(self.status, self.type.__str__())
 

tracim/tracim/model/serializers.py

     result = DictLikeClass(
         id = CST.TREEVIEW_MENU.ID_TEMPLATE__FULL.format(workspace_id, content_id),
         children = True, # TODO: make this dynamic
-        text = content.label,
-        a_attr = { 'href' : context.url('/workspaces/{}/folders/{}'.format(workspace_id, content_id)) },
-        li_attr = { 'title': content.label, 'class': 'tracim-tree-item-is-a-folder' },
+        text = content.get_label(),
+        a_attr = { 'href' : context.url(ContentType.fill_url(content)) },
+        li_attr = { 'title': content.get_label(), 'class': 'tracim-tree-item-is-a-folder' },
         type = content.type,
         state = { 'opened': False, 'selected': False }
     )
 @pod_serializer(NodeTreeItem, CTX.MENU_API_BUILD_FROM_TREE_ITEM)
 def serialize_node_tree_item_for_menu_api_tree(item: NodeTreeItem, context: Context):
     if isinstance(item.node, Content):
+        ContentType.fill_url(item.node)
         return DictLikeClass(
             id=CST.TREEVIEW_MENU.ID_TEMPLATE__FULL.format(item.node.workspace_id, item.node.content_id),
-            children=True if len(item.children)<=0 else context.toDict(item.children),
-            text=item.node.label,
-            a_attr={'href': context.url('/workspaces/{}/folders/{}'.format(item.node.workspace_id, item.node.content_id)) },
-            li_attr={'title': item.node.label, 'class': 'tracim-tree-item-is-a-folder'},
-            type='folder',
-            state={'opened': True if len(item.children)>0 else False, 'selected': item.is_selected}
+            children=True if ContentType.Folder==item.node.type and len(item.children)<=0 else context.toDict(item.children),
+            text=item.node.get_label(),
+            a_attr={'href': context.url(ContentType.fill_url(item.node)) },
+            li_attr={'title': item.node.get_label()},
+            # type='folder',
+            type=item.node.type,
+            state={'opened': True if ContentType.Folder==item.node.type and len(item.children)>0 else False, 'selected': item.is_selected}
         )
     elif isinstance(item.node, Workspace):
         return DictLikeClass(
             id=CST.TREEVIEW_MENU.ID_TEMPLATE__WORKSPACE_ONLY.format(item.node.workspace_id),
             children=True if len(item.children)<=0 else context.toDict(item.children),
             text=item.node.label,
-            a_attr={'href': context.url('/workspaces/{}'.format(item.node.workspace_id))},
-            li_attr={'title': item.node.label, 'class': 'tracim-tree-item-is-a-workspace'},
+            a_attr={'href': context.url(ContentType.fill_url_for_workspace(item.node))},
+            li_attr={'title': item.node.get_label()},
             type='workspace',
             state={'opened': True if len(item.children)>0 else False, 'selected': item.is_selected}
         )

tracim/tracim/templates/user_workspace_folder_file_get_one.mak

 
 <%def name="SIDEBAR_LEFT_CONTENT()">
     <h4>${_('Workspaces')}</h4>
-    ${WIDGETS.TREEVIEW('sidebar-left-menu', 'workspace_{}__folder_{}'.format(result.file.workspace.id, result.file.parent.id))}
+    ${WIDGETS.TREEVIEW('sidebar-left-menu', 'workspace_{}__item_{}'.format(result.file.workspace.id, result.file.id))}
     <hr/>
 </%def>
 

tracim/tracim/templates/user_workspace_folder_get_one.mak

 
 <%def name="SIDEBAR_LEFT_CONTENT()">
     <h4>${_('Workspaces')}</h4>
-    ${WIDGETS.TREEVIEW('sidebar-left-menu', 'workspace_{}__folder_{}'.format(result.folder.workspace.id, result.folder.id))}
+    ${WIDGETS.TREEVIEW('sidebar-left-menu', 'workspace_{}__item_{}'.format(result.folder.workspace.id, result.folder.id))}
     <hr/>
 </%def>
 

tracim/tracim/templates/user_workspace_folder_page_get_one.mak

 
 <%def name="SIDEBAR_LEFT_CONTENT()">
     <h4>${_('Workspaces')}</h4>
-    ${WIDGETS.TREEVIEW('sidebar-left-menu', 'workspace_{}__folder_{}'.format(result.page.workspace.id, result.page.parent.id))}
+    ${WIDGETS.TREEVIEW('sidebar-left-menu', 'workspace_{}__item_{}'.format(result.page.workspace.id, result.page.id))}
     <hr/>
 </%def>
 

tracim/tracim/templates/user_workspace_folder_thread_get_one.mak

 
 <%def name="SIDEBAR_LEFT_CONTENT()">
     <h4>${_('Workspaces')}</h4>
-    ${WIDGETS.TREEVIEW('sidebar-left-menu', 'workspace_{}__folder_{}'.format(result.thread.workspace.id, result.thread.parent.id))}
+    ${WIDGETS.TREEVIEW('sidebar-left-menu', 'workspace_{}__item_{}'.format(result.thread.workspace.id, result.thread.id))}
     <hr/>
 </%def>
 
 
 <%def name="REQUIRED_DIALOGS()">
     ${TIM.MODAL_DIALOG('thread-edit-modal-dialog', 'modal-lg')}
+    ${TIM.MODAL_DIALOG('thread-move-modal-dialog')}
 </%def>
 
 ############################################################################

tracim/tracim/templates/user_workspace_widgets.mak

                         "default" : {
                             "icon" : "${TIM.ICO_URL(16, 'places/jstree-folder')}"
                         },
+                        "page" : {
+                            "icon" : "${TIM.ICO_URL(16, 'mimetypes/text-html')}"
+                        },
+                        "file" : {
+                            "icon" : "${TIM.ICO_URL(16, 'status/mail-attachment')}"
+                        },
+                        "thread" : {
+                            "icon" : "${TIM.ICO_URL(16, 'apps/internet-group-chat')}"
+                        },
                         "workspace" : {
                             "icon" : "${TIM.ICO_URL(16, 'places/folder-remote')}"
                         },
                                 };
                             },
                             'success': function (new_data) {
-                                console.log('loaded new menu data' + new_data)
+                                console.log('loaded new menu data' + JSON.stringify(new_data))
                                 return new_data;
                             },
                         },