Merge pull request #24 from lebouquetin/feature/read-not-read-content

tracim/migration/versions/43a323cc661_add_read_not_read_content_status.py

+"""add read/not read content status
+
+Revision ID: 43a323cc661
+Revises: None
+Create Date: 2015-08-26 11:23:03.466554
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = '43a323cc661'
+down_revision = None
+
+from alembic import op
+import sqlalchemy as sa
+
+
+def upgrade():
+    op.create_table(
+        'revision_read_status',
+        sa.Column('revision_id', sa.Integer, sa.ForeignKey('content_revisions.revision_id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True),
+        sa.Column('user_id', sa.Integer, sa.ForeignKey('users.user_id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True),
+        sa.Column('view_datetime', sa.DateTime, server_default=sa.func.now(), unique=False, nullable=False)
+    )
+
+
+def downgrade():
+    op.drop_table('revision_read_status')
+

tracim/tracim/controllers/__init__.py

 from tg import RestController
 from tg import tmpl_context
 from tg.i18n import ugettext as _
+from tg.predicates import not_anonymous
 
 from tracim.lib import CST
 from tracim.lib.base import BaseController
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(next_url)
 
-
     @tg.require(current_user_is_content_manager())
     @tg.expose()
     def put_archive_undo(self, item_id):
             tg.flash(msg, CST.STATUS_ERROR)
             tg.redirect(back_url)
 
+    @tg.expose()
+    @tg.require(not_anonymous())
+    def put_read(self, item_id):
+        item_id = int(item_id)
+        content_api = ContentApi(tmpl_context.current_user, True, True) # Here we do not filter deleted items
+        item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
+
+        item_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
+
+        try:
+            msg = _('{} marked as read.').format(self._item_type_label)
+            content_api.mark_read(item)
+
+            tg.flash(msg, CST.STATUS_OK)
+            tg.redirect(item_url)
+
+        except ValueError as e:
+            logger.debug(self, 'Exception: {}'.format(e.__str__))
+            msg = _('{} not marked as read: {}').format(self._item_type_label, str(e))
+            tg.flash(msg, CST.STATUS_ERROR)
+            tg.redirect(item_url)
+
+    @tg.expose()
+    @tg.require(not_anonymous())
+    def put_unread(self, item_id):
+        item_id = int(item_id)
+        content_api = ContentApi(tmpl_context.current_user, True, True) # Here we do not filter deleted items
+        item = content_api.get_one(item_id, self._item_type, tmpl_context.workspace)
+
+        item_url = self._std_url.format(item.workspace_id, item.parent_id, item.content_id)
+
+        try:
+            msg = _('{} marked unread.').format(self._item_type_label)
+            content_api.mark_unread(item)
+
+            tg.flash(msg, CST.STATUS_OK)
+            tg.redirect(item_url)
+
+        except ValueError as e:
+            logger.debug(self, 'Exception: {}'.format(e.__str__))
+            msg = _('{} not marked unread: {}').format(self._item_type_label, str(e))
+            tg.flash(msg, CST.STATUS_ERROR)
+            tg.redirect(item_url)
 
 class StandardController(BaseController):
 

tracim/tracim/controllers/content.py

         workspace = tmpl_context.workspace
         workspace_id = tmpl_context.workspace_id
 
-        current_user_content = Context(CTX.CURRENT_USER).toDict(user)
+        current_user_content = Context(CTX.CURRENT_USER,
+                                       current_user=user).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
         content_api = ContentApi(user)
 
         fake_api_breadcrumb = self.get_breadcrumb(file_id)
         fake_api_content = DictLikeClass(breadcrumb=fake_api_breadcrumb, current_user=current_user_content)
-        fake_api = Context(CTX.FOLDER).toDict(fake_api_content)
+        fake_api = Context(CTX.FOLDER,
+                           current_user=user).toDict(fake_api_content)
 
-        dictified_file = Context(self._get_one_context).toDict(file, 'file')
+        dictified_file = Context(self._get_one_context,
+                                 current_user=user).toDict(file, 'file')
         return DictLikeClass(result = dictified_file, fake_api=fake_api)
 
     @tg.require(current_user_is_reader())
         workspace = tmpl_context.workspace
         workspace_id = tmpl_context.workspace_id
 
-        current_user_content = Context(CTX.CURRENT_USER).toDict(user)
+        current_user_content = Context(CTX.CURRENT_USER,
+                                       current_user=user).toDict(user)
         current_user_content.roles.sort(key=lambda role: role.workspace.name)
 
         content_api = ContentApi(user)

tracim/tracim/controllers/root.py

         last_active_contents = ContentApi(user).get_last_active(None, ContentType.Any, None)
         fake_api.last_actives = Context(CTX.CONTENT_LIST).toDict(last_active_contents, 'contents', 'nb')
 
+        unread_contents = ContentApi(user).get_last_unread(None, ContentType.Any, None)
+        fake_api.last_unread = Context(CTX.CONTENT_LIST).toDict(unread_contents, 'contents', 'nb')
+
         # INFO - D.A. - 2015-05-20
         # For now, we do not have favorties and read/unread status
         # so we only show:

tracim/tracim/lib/content.py

 
 __author__ = 'damien'
 
+import datetime
 import re
 
 import tg
 from sqlalchemy.orm import joinedload
 from sqlalchemy.orm.attributes import get_history
 from sqlalchemy import desc
+from sqlalchemy import distinct
 from sqlalchemy import not_
 from sqlalchemy import or_
 from tracim.lib import cmp_to_key
 from tracim.model.data import Content
 from tracim.model.data import ContentType
 from tracim.model.data import NodeTreeItem
-from tracim.model.data import Workspace
+from tracim.model.data import RevisionReadStatus
 from tracim.model.data import UserRoleInWorkspace
+from tracim.model.data import Workspace
 
 def compare_content_for_sorting_by_type_and_name(content1: Content,
                                                  content2: Content):
 
         return result
 
+    def __revisions_real_base_query(self, workspace: Workspace=None):
+        result = DBSession.query(ContentRevisionRO)
+
+        if workspace:
+            result = result.filter(ContentRevisionRO.workspace_id==workspace.workspace_id)
+
+        if self._user:
+            user = DBSession.query(User).get(self._user_id)
+            # Filter according to user workspaces
+            workspace_ids = [r.workspace_id for r in user.roles \
+                             if r.role>=UserRoleInWorkspace.READER]
+            result = result.filter(ContentRevisionRO.workspace_id.in_(workspace_ids))
+
+        return result
+
+    def _revisions_base_query(self, workspace: Workspace=None):
+        result = self.__revisions_real_base_query(workspace)
+
+        if not self._show_deleted:
+            result = result.filter(ContentRevisionRO.is_deleted==False)
+
+        if not self._show_archived:
+            result = result.filter(ContentRevisionRO.is_archived==False)
+
+        return result
+
     def _hard_filtered_base_query(self, workspace: Workspace=None):
         """
         If set to True, then filterign on is_deleted and is_archived will also
 
         return resultset.all()
 
-    def get_last_active(self, parent_id: int, content_type: str, workspace: Workspace=None, limit=10) -> Content:
+    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
         assert isinstance(content_type, str) # DYN_REMOVE
 
         return result
 
+    def get_last_unread(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
+        assert isinstance(content_type, str) # DYN_REMOVE
+
+        read_revision_ids = DBSession.query(RevisionReadStatus.revision_id) \
+            .filter(RevisionReadStatus.user_id==self._user_id)
+
+        not_read_revisions = self._revisions_base_query(workspace) \
+            .filter(~ContentRevisionRO.revision_id.in_(read_revision_ids)) \
+            .subquery()
+
+        not_read_content_ids = DBSession.query(
+            distinct(not_read_revisions.c.content_id)).all()
+
+        not_read_contents = self._base_query(workspace) \
+            .filter(Content.content_id.in_(not_read_content_ids)) \
+            .order_by(desc(Content.updated))
+
+        if content_type != ContentType.Any:
+            not_read_contents = not_read_contents.filter(
+                Content.type==content_type)
+        else:
+            not_read_contents = not_read_contents.filter(
+                Content.type!=ContentType.Folder)
+
+        if parent_id:
+            not_read_contents = not_read_contents.filter(
+                Content.parent_id==parent_id)
+
+        result = []
+        for item in not_read_contents:
+            new_item = None
+            if ContentType.Comment == item.type:
+                new_item = item.parent
+            else:
+                new_item = item
+
+            # INFO - D.A. - 2015-05-20
+            # We do not want to show only one item if the last 10 items are
+            # comments about one thread for example
+            if new_item not in result:
+                result.append(new_item)
+
+            if len(result) >= limit:
+                break
+
+        return result
+
     def set_allowed_content(self, folder: Content, allowed_content_dict:dict):
         """
         :param folder: the given folder instance
         properties = dict(allowed_content = allowed_content_dict)
         folder.properties = properties
 
-
     def set_status(self, content: Content, new_status: str):
         if new_status in ContentStatus.allowed_values():
             content.status = new_status
         else:
             raise ValueError('The given value {} is not allowed'.format(new_status))
 
-
     def move(self, item: Content,
              new_parent: Content,
              must_stay_in_same_workspace:bool=True,
         content.is_deleted = False
         content.revision_type = ActionDescription.UNDELETION
 
+    def mark_read(self, content: Content,
+                  read_datetime: datetime=None,
+                  do_flush=True) -> Content:
+
+        assert self._user
+        assert content
+
+        # The algorithm is:
+        # 1. define the read datetime
+        # 2. update all revisions related to current Content
+        # 3. do the same for all child revisions
+        #    (ie parent_id is content_id of current content)
+
+        if not read_datetime:
+            read_datetime = datetime.datetime.now()
+
+        viewed_revisions = DBSession.query(ContentRevisionRO) \
+            .filter(ContentRevisionRO.content_id==content.content_id).all()
+
+        for revision in viewed_revisions:
+            revision.read_by[self._user] = read_datetime
+
+        for child in content.get_valid_children():
+            self.mark_read(child, read_datetime=read_datetime, do_flush=False)
+
+        if do_flush:
+            self.flush()
+
+        return content
+
+    def mark_unread(self, content: Content, do_flush=True) -> Content:
+        assert self._user
+        assert content
+
+        revisions = DBSession.query(ContentRevisionRO) \
+            .filter(ContentRevisionRO.content_id==content.content_id).all()
+
+        for revision in revisions:
+            del revision.read_by[self._user]
+
+        for child in content.get_valid_children():
+            self.mark_unread(child, do_flush=False)
+
+        if do_flush:
+            self.flush()
+
+        return content
+
     def flush(self):
         DBSession.flush()
 
         if action_description:
             content.revision_type = action_description
 
-
         if do_flush:
             DBSession.add(content)
             DBSession.flush()

tracim/tracim/lib/user.py

 
     @classmethod
     def get_current_user(cls) -> User:
-        identity = tg.request.identity
-
-        if tg.request.identity:
-            return cls._get_user(tg.request.identity['repoze.who.userid'])
+        # HACK - D.A. - 2015-09-02
+        # In tests, the tg.request.identity may not be set
+        # (this is a buggy case, but for now this is how the software is;)
+        if tg.request != None:
+            if hasattr(tg.request, 'identity'):
+                if tg.request.identity != None:
+                    return cls._get_user(tg.request.identity['repoze.who.userid'])
 
         return None
 

tracim/tracim/model/data.py

 import datetime as datetime_root
 import json
 
+from sqlalchemy.ext.associationproxy import association_proxy
 from sqlalchemy import Column
+from sqlalchemy import func
 from sqlalchemy import ForeignKey
 from sqlalchemy import Sequence
 
 from sqlalchemy.ext.hybrid import hybrid_property
 
+from sqlalchemy.orm import backref
 from sqlalchemy.orm import relationship
 from sqlalchemy.orm import deferred
+from sqlalchemy.orm.collections import attribute_mapped_collection
 
 from sqlalchemy.types import Boolean
 from sqlalchemy.types import DateTime
     parent = relationship('Content', remote_side=[content_id], backref='children')
     owner = relationship('User', remote_side=[User.user_id])
 
-    def get_valid_children(self, content_types: list=None):
+    def get_valid_children(self, content_types: list=None) -> ['Content']:
         for child in self.children:
             if not child.is_deleted and not child.is_archived:
                 if not content_types or child.type in content_types:
     def created_as_delta(self, delta_from_datetime:datetime=None):
         if not delta_from_datetime:
             delta_from_datetime = datetime.now()
+
         return format_timedelta(delta_from_datetime - self.created,
                                 locale=tg.i18n.get_lang()[0])
 
                 last_revision_date = child.updated
         return last_revision_date
 
+    def has_new_information_for(self, user: User) -> bool:
+        """
+        :param user: the session current user
+        :return: bool, True if there is new information for given user else False
+                       False if the user is None
+        """
+        revision = self.get_current_revision()
+
+        if not user:
+            return False
+
+        if user not in revision.read_by.keys():
+            # The user did not read this item, so yes!
+            return True
+
+        for child in self.get_valid_children():
+            if child.has_new_information_for(user):
+                return True
+
+        return False
+
     def get_comments(self):
         children = []
         for child in self.children:
 
         return None
 
+    def get_current_revision(self) -> 'ContentRevisionRO':
+        # TODO - D.A. - 2015-08-26
+        # This code is not efficient at all!!!
+        # We should get the revision id directly from the view
+        rev_ids = [revision.revision_id for revision in self.revisions]
+        rev_ids.sort()
+
+        for revision in self.revisions:
+            if revision.revision_id == rev_ids[-1]:
+                return revision
+
+        return None
+
     def description_as_raw_text(self):
         # 'html.parser' fixes a hanging bug
         # see http://stackoverflow.com/questions/12618567/problems-running-beautifulsoup4-within-apache-mod-python-django
                                key=lambda event: event.created, reverse=True)
         return sorted_events
 
+    @classmethod
+    def format_path(cls, url_template: str, content: 'Content') -> str:
+        wid = content.workspace.workspace_id
+        fid = content.parent_id  # May be None if no parent
+        ctype = content.type
+        cid = content.content_id
+        return url_template.format(wid=wid, fid=fid, ctype=ctype, cid=cid)
+
 
 class ContentChecker(object):
 
     def get_last_action(self) -> ActionDescription:
         return ActionDescription(self.revision_type)
 
+    # Read by must be used like this:
+    # read_datetime = revision.ready_by[<User instance>]
+    # if user did not read the content, then a key error is raised
+    read_by = association_proxy(
+        'revision_read_statuses',  # name of the attribute
+        'view_datetime',  # attribute the value is taken from
+        creator=lambda k, v: \
+            RevisionReadStatus(user=k, view_datetime=v)
+    )
+
+    def has_new_information_for(self, user: User) -> bool:
+        """
+        :param user: the session current user
+        :return: bool, True if there is new information for given user else False
+                       False if the user is None
+        """
+        if not user:
+            return False
+
+        if user not in self.read_by.keys():
+            return True
+
+        return False
+
+class RevisionReadStatus(DeclarativeBase):
+
+    __tablename__ = 'revision_read_status'
+
+    revision_id = Column(Integer, ForeignKey('content_revisions.revision_id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True)
+    user_id = Column(Integer, ForeignKey('users.user_id', ondelete='CASCADE', onupdate='CASCADE'), primary_key=True)
+    view_datetime = Column(DateTime, unique=False, nullable=False, server_default=func.now())
+
+    # content_revision = relationship(
+    #     'ContentRevisionRO',
+    #     remote_side=[ContentRevisionRO.revision_id],
+    #     backref='revision_read_statuses')
+
+    content_revision = relationship(
+        'ContentRevisionRO',
+        backref=backref(
+            'revision_read_statuses',
+            collection_class=attribute_mapped_collection('user'),
+            cascade='all, delete-orphan'
+        ))
+
+    user = relationship('User', backref=backref(
+        'revision_readers',
+        collection_class=attribute_mapped_collection('view_datetime'),
+        cascade='all, delete-orphan'
+    ))
+
 
 class NodeTreeItem(object):
     """

tracim/tracim/model/serializers.py

 from tg.i18n import ugettext as _
 from tg.util import LazyString
 from tracim.lib.base import logger
+from tracim.lib.user import UserStaticApi
 from tracim.lib.utils import exec_time_monitor
 from tracim.model.auth import Profile
 from tracim.model.auth import User
 
             raise ContextConverterNotFoundException(context_string, model_class)
 
-    def __init__(self, context_string, base_url=''):
+    def __init__(self, context_string, base_url='', current_user=None):
         """
         """
         self.context_string = context_string
+        self._current_user = current_user  # Allow to define the current user if any
+        if not current_user:
+            self._current_user = UserStaticApi.get_current_user()
+
         self._base_url = base_url # real root url like http://mydomain.com:8080
 
     def url(self, base_url='/', params=None, qualified=False) -> str:
             url = '{}{}'.format(self._base_url, url)
         return  url
 
+    def get_user(self):
+        return self._current_user
+
     def toDict(self, serializableObject, key_value_for_a_list_object='', key_value_for_list_item_nb=''):
         """
         Converts a given object into a recursive dictionnary like structure.
 @pod_serializer(Content, CTX.PAGE)
 @pod_serializer(Content, CTX.FILE)
 def serialize_node_for_page(content: Content, context: Context):
+
     if content.type in (ContentType.Page, ContentType.File) :
         data_container = content
 
             parent=context.toDict(content.parent),
             workspace=context.toDict(content.workspace),
             type=content.type,
-
+            is_new=content.has_new_information_for(context.get_user()),
             content=data_container.description,
             created=data_container.created,
             label=data_container.label,
             links=context.toDict(content.extract_links_from_content(data_container.description)),
             revisions=context.toDict(sorted(content.revisions, key=lambda v: v.created, reverse=True)),
             selected_revision='latest' if content.revision_to_serialize<=0 else content.revision_to_serialize,
-            history=Context(CTX.CONTENT_HISTORY).toDict(content.get_history())
+            history=Context(CTX.CONTENT_HISTORY).toDict(content.get_history()),
+            urls = context.toDict({
+                'mark_read': context.url(Content.format_path('/workspaces/{wid}/folders/{fid}/{ctype}s/{cid}/put_read', content)),
+                'mark_unread': context.url(Content.format_path('/workspaces/{wid}/folders/{fid}/{ctype}s/{cid}/put_unread', content))
+            })
         )
 
         if content.type==ContentType.File:
 
     if content.type==ContentType.Folder:
         value = DictLikeClass(
-            id = content.content_id,
-            label = content.label,
+            id=content.content_id,
+            label=content.label,
+            is_new=content.has_new_information_for(context.get_user()),
         )
         return value
 
         created=event.created,
         created_as_delta=event.created_as_delta(),
         content=event.content,
+        is_new=event.ref_object.has_new_information_for(context.get_user()),
         urls = urls
     )
 
-
 @pod_serializer(Content, CTX.THREAD)
 def serialize_node_for_page(item: Content, context: Context):
     if item.type==ContentType.Thread:
             type = item.type,
             workspace = context.toDict(item.workspace),
             comments = reversed(context.toDict(item.get_comments())),
-            history = Context(CTX.CONTENT_HISTORY).toDict(item.get_history())
+            is_new=item.has_new_information_for(context.get_user()),
+            history = Context(CTX.CONTENT_HISTORY).toDict(item.get_history()),
+            urls = context.toDict({
+                'mark_read': context.url(Content.format_path('/workspaces/{wid}/folders/{fid}/{ctype}s/{cid}/put_read', item)),
+                'mark_unread': context.url(Content.format_path('/workspaces/{wid}/folders/{fid}/{ctype}s/{cid}/put_unread', item))
+            }),
         )
 
     if item.type==ContentType.Comment:
         return DictLikeClass(
+            is_new=item.has_new_information_for(context.get_user()),
             content = item.description,
             created = item.created,
             created_as_delta = item.created_as_delta(),

tracim/tracim/public/assets/css/dashboard.css

     border-bottom-width: 4px;
 }
 
-h3 { background-color: #f5f5f5;}
+/* FIXME - 2015-09-01 - D.A. - CAN WE REMOVE THIS ? h3 { background-color: #f5f5f5;}*/
 
 
 .sidebar .list-group-item { background-color: transparent; }
 #t-full-app-alert-message-id > div.alert {
     box-shadow: 0px 0px 5px 5px rgba(0, 0, 0, 0.3);
 }
+
+tr.t-is-new-content td, div.row.t-is-new-content {
+    background-color: #DFF0D8;
+}
+
+.panel-heading > h3 { font-size: 1.5em;}

tracim/tracim/templates/file/toolbar.mak

 <%namespace name="TIM" file="tracim.templates.pod"/>
 <%namespace name="ICON" file="tracim.templates.widgets.icon"/>
+<%namespace name="BUTTON" file="tracim.templates.widgets.button"/>
 
 <%def name="SECURED_FILE(user, workspace, file)">
+    <div class="btn-group btn-group-vertical text-center">
+        ${BUTTON.MARK_CONTENT_READ_OR_UNREAD(user, workspace, file)}
+    </div>
+    <p></p>
+
     <% download_url = tg.url('/workspaces/{}/folders/{}/files/{}/download?revision_id={}'.format(result.file.workspace.id, result.file.parent.id,result.file.id,result.file.selected_revision)) %>
     <% edit_disabled = ('', 'disabled')[file.selected_revision!='latest' or file.status.id[:6]=='closed'] %>
     <% delete_or_archive_disabled = ('', 'disabled')[file.selected_revision!='latest'] %> 

tracim/tracim/templates/home.mak

 <div class="container-fluid">
     <div class="row-fluid">
         <div>
-            <div class="row">
+            ## NOT READ
+            <div class="row" id="unread-content-panel">
                 <div class="col-md-offset-3 col-sm-7">
                     <div class="row t-spacer-above">
-##                        <div class="col-sm-6">
-##                            <div class="panel panel-default">
-##                              <div class="panel-heading">
-##                                <h3 class="panel-title"><i class="fa fa-eye-slash"></i> ${_('Unread content')}</h3>
-##                              </div>
-##                              <div class="panel-body">
-##                                Panel content
-##                              </div>
-##                            </div>
-##                        </div>
+                        <div class="col-sm-12">
+                            <div class="t-half-spacer-above">
+                                <div class="panel panel-success">
+                                    <div class="panel-heading">
+                                        <h3 class="panel-title"><i class="fa fa-fw fa-eye-slash"></i> ${_('Unread')}</h3>
+                                    </div>
+                                    <div class="panel-body">
+                                        % if fake_api.last_unread.nb <= 0:
+                                            ${P.EMPTY_CONTENT(_('No unread content.'))}
+                                        % else:
+                                            <table class="table table-hover">
+                                                % for item in fake_api.last_unread.contents:
+                                                    <tr>
+                                                        <td>
+                                                            <i class="${item.type.icon} fa-fw ${item.type.color}"></i>
+                                                            <a href="${item.url}">${item.label}</a>
+                                                            <br/>
+                                                            <span class="t-less-visible">${item.workspace.label}</span>
+                                                        </td>
+                                                        <td title="${_('Last activity: {datetime}').format(datetime=item.last_activity.label)}">
+                                                            ${item.last_activity.delta}
+                                                        </td>
+                                                    </tr>
+                                                % endfor
+                                            </table>
+                                        % endif
+                                     </div>
+                                 </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
 
+            ## RECENT ACTIVITY
+            <div class="row" id="recent-activity-panel">
+                <div class="col-md-offset-3 col-sm-7">
+                    <div class="row t-spacer-above">
                         <div class="col-sm-12">
-                            <div class="panel panel-default">
-                                <div class="panel-heading">
-                                    <h3 class="panel-title"><i class="fa fa-line-chart"></i> ${_('Recent activity')}</h3>
+                            <div class="t-half-spacer-above">
+                                <div class="panel panel-warning">
+                                    <div class="panel-heading">
+                                        <h3 class="panel-title"><i class="fa fa-fw fa-line-chart"></i> ${_('Recent Activity')}</h3>
+                                    </div>
+                                    <div class="panel-body">
+                                        % if fake_api.last_actives.nb <= 0:
+                                            ${P.EMPTY_CONTENT(_('There\'s no activity yet.'))}
+                                        % else:
+                                            <table class="table table-hover">
+                                                % for item in fake_api.last_actives.contents:
+                                                    <tr>
+                                                        <td>
+                                                            <i class="${item.type.icon} fa-fw ${item.type.color}"></i>
+                                                            <a href="${item.url}">${item.label}</a>
+                                                            <br/>
+                                                            <span class="t-less-visible">${item.workspace.label}</span>
+                                                        </td>
+                                                        <td title="${_('Last activity: {datetime}').format(datetime=item.last_activity.label)}">
+                                                            ${item.last_activity.delta}
+                                                        </td>
+                                                    </tr>
+                                                % endfor
+                                            </table>
+                                        % endif
+                                    </div>
                                 </div>
-                                % if fake_api.last_actives.nb <= 0:
-                                    ${P.EMPTY_CONTENT(_('There\'s no activity yet.'))}
-                                % else:
-                                    <table class="table table-hover">
-                                        % for item in fake_api.last_actives.contents:
-                                            <tr>
-                                                <td>
-                                                    <i class="${item.type.icon} fa-fw ${item.type.color}"></i>
-                                                    <a href="${item.url}">${item.label}</a>
-                                                    <br/>
-                                                    <span class="t-less-visible">${item.workspace.label}</span>
-                                                </td>
-                                                <td title="${_('Last activity: {datetime}').format(datetime=item.last_activity.label)}">
-                                                    ${item.last_activity.delta}
-                                                </td>
-                                            </tr>
-                                        % endfor
-                                    </table>
-                                % endif
                             </div>
                         </div>
-
-##                        <div class="col-sm-6">
-##                            <div class="panel panel-default">
-##                                <div class="panel-heading">
-##                                    <h3 class="panel-title"><i class="fa fa-thumbs-down"></i> ${_('Still open after...')}</h3>
-##                                </div>
-##                                % if fake_api.oldest_opens.nb <= 0:
-##                                    ${P.EMPTY_CONTENT(_('Nothing to close.'))}
-##                                % else:
-##                                    <table class="table table-hover">
-##                                        % for item in fake_api.oldest_opens.contents:
-##                                            <tr>
-##                                                <td>
-##                                                    <i class="${item.type.icon} fa-fw ${item.type.color}"></i>
-##                                                    <a href="${item.url}">${item.label}</a>
-##                                                </td>
-##                                                <td title="${_('Last activity: {datetime}').format(datetime=item.last_activity.label)}">
-##                                                    ${item.last_activity.delta}
-##                                                </td>
-##                                            </tr>
-##                                        % endfor
-##                                    </table>
-##                                % endif
-##                            </div>
-##                        </div>
-
-
-##                        <div class="col-sm-6">
-##                            <div class="panel panel-default">
-##                                <div class="panel-heading">
-##                                    <h3 class="panel-title"><i class="fa fa-star"></i> ${_('Favorites')}</h3>
-##                                </div>
-##
-##                                last_active_contents
-##
-##                                    % if fake_api.favorites.nb <= 0:
-##                                        ${P.EMPTY_CONTENT(_('You did not set any favorite yet.'))}
-##                                    % else:
-##                                        <table class="table table-hover">
-##                                            % for item in fake_api.favorites.contents:
-##                                                <tr>
-##                                                    <td>
-##                                                        <i class="${item.type.icon} fa-fw ${item.type.color}"></i>
-##                                                        <a href="${item.url}">${item.label}</a>
-##                                                    </td>
-##                                                    <td class="text-right">
-##                                                        <i class="${item.status.icon} fa-fw ${item.status.css}" title="${item.status.label}"></i>
-##                                                    </td>
-##                                                </tr>
-##                                            % endfor
-##                                        </table>
-##                                    % endif
-####                                </div>
-##                            </div>
-##                        </div>
                     </div>
+                </div>
+            </div>
 
-                    ## Workspace list and notifications
-                    <div class="row">
+            ## Workspace list and notifications
+            <div class="row t-half-spacer-above" id="workspaces-panel">
+                <div class="col-md-offset-3 col-sm-7">
+                    <div class="row t-spacer-above">
                         <div class="col-sm-12">
-                            <div class="panel panel-default">
+                            <div class="panel panel-info">
                                 <div class="panel-heading">
                                     <h3 class="panel-title"><i class="fa fa-bank"></i> ${_('Your workspaces')}</h3>
                                 </div>

tracim/tracim/templates/page/toolbar.mak

 <%namespace name="TIM" file="tracim.templates.pod"/>
+<%namespace name="BUTTON" file="tracim.templates.widgets.button"/>
 
 <%def name="SECURED_PAGE(user, workspace, page)">
+    <div class="btn-group btn-group-vertical">
+        ${BUTTON.MARK_CONTENT_READ_OR_UNREAD(user, workspace, page)}
+    </div>
+    <p></p>
+
     <% edit_disabled = ('', 'disabled')[page.selected_revision!='latest' or page.status.id[:6]=='closed'] %>
     <% delete_or_archive_disabled = ('', 'disabled')[page.selected_revision!='latest'] %> 
     % if h.user_role(user, workspace)>1:

tracim/tracim/templates/thread/toolbar.mak

 <%namespace name="TIM" file="tracim.templates.pod"/>
 <%namespace name="ICON" file="tracim.templates.widgets.icon"/>
+<%namespace name="BUTTON" file="tracim.templates.widgets.button"/>
 
 <%def name="SECURED_THREAD(user, workspace, thread)">
+    <div class="btn-group btn-group-vertical">
+        ${BUTTON.MARK_CONTENT_READ_OR_UNREAD(user, workspace, thread)}
+    </div>
+    <p></p>
+
     <% edit_disabled = ('', 'disabled')[thread.selected_revision!='latest' or thread.status.id[:6]=='closed'] %>
     <% delete_or_archive_disabled = ('', 'disabled')[thread.selected_revision!='latest'] %> 
     % if h.user_role(user, workspace)>1:

tracim/tracim/templates/user_toolbars.mak

                 user_edit_url = tg.url('/user/{}/edit'.format(current_user.id), {'next_url': '/home'})
                 user_password_edit_url = tg.url('/user/{}/password/edit'.format(current_user.id))
             %>
-        <a title="${_('Edit my profile')}" class="btn btn-default" data-toggle="modal" data-target="#user-edit-modal-dialog" data-remote="${user_edit_url}" >${ICON.FA('fa-edit t-less-visible')} ${_('Edit my profile')}</a>
+            <a title="${_('Edit my profile')}" class="btn btn-default" data-toggle="modal" data-target="#user-edit-modal-dialog" data-remote="${user_edit_url}" >${ICON.FA('fa-edit t-less-visible')} ${_('Edit my profile')}</a>
             <a title="${_('Change password')}" class="btn btn-default" data-toggle="modal" data-target="#user-edit-password-modal-dialog" data-remote="${user_password_edit_url}" >${ICON.FA('fa-key t-less-visible')} ${_('Password')}</a>
         </div>
         <p></p>
+        <h3 class="t-spacer-above" style="margin-top: 1em;">
+            <i class="fa fa-flash"></i> ${_('Go to...')}
+        </h3>
+
+        <div class="btn-group btn-group-vertical">
+            <%
+                user_edit_url = tg.url('/user/{}/edit'.format(current_user.id), {'next_url': '/home'})
+                user_password_edit_url = tg.url('/user/{}/password/edit'.format(current_user.id))
+            %>
+            <a title="${_('Unread')}" class="btn btn-default" href="#unread-content-panel" >${ICON.FA('fa-fw fa-eye-slash t-less-visible')} ${_('Unread')}</a>
+            <a title="${_('Recent Activity')}" class="btn btn-default" href="#recent-activity-panel" >${ICON.FA('fa-fw fa-line-chart t-less-visible')} ${_('Activity')}</a>
+            <a title="${_('My Workspaces')}" class="btn btn-default" href="#workspaces-panel" >${ICON.FA('fa-fw fa-bank t-less-visible')} ${_('Spaces')}</a>
+        </div>
+        <p></p>
     </div> <!-- # End of side bar right -->
     ## SIDEBAR RIGHT [END]
 </%def>

tracim/tracim/templates/user_workspace_widgets.mak

 </%def>
 
 <%def name="SECURED_HISTORY_VIRTUAL_EVENT(user, event)">
-    <div class="row t-odd-or-even t-hacky-thread-comment-border-top">
+    <% is_new_css_class = 't-is-new-content' if event.is_new else '' %>
+
+    <div class="row t-odd-or-even t-hacky-thread-comment-border-top ${is_new_css_class}">
         <div class="col-sm-7 col-sm-offset-3">
             <div class="t-timeline-item">
 ##                <i class="fa fa-fw fa-3x fa-comment-o t-less-visible" style="margin-left: -1.5em; float:left;"></i>
 </%def>
 
 <%def name="SECURED_HISTORY_VIRTUAL_EVENT_AS_TABLE_ROW(user, event, current_revision_id)">
-    <% warning_or_not = ('', 'warning')[current_revision_id==event.id] %>
-    <tr class="${warning_or_not}">
+    <%
+        warning_or_not = ('', 'warning')[current_revision_id==event.id]
+        row_css = 't-is-new-content' if event.is_new else warning_or_not
+    %>
+    <tr class="${row_css}">
         <td class="t-less-visible">
             <span class="label label-default">${ICON.FA_FW(event.type.icon)} ${event.type.label}</span>
         </td>

tracim/tracim/templates/widgets/button.mak

         % endif
     </div>
 </%def>
+
+<%def name="MARK_CONTENT_READ_OR_UNREAD(current_user, workspace, content)">
+    <%
+        disabled_or_not = ''
+        if 'latest' != content.selected_revision:
+            disabled_or_not = 'disabled'
+    %>
+    % if content.is_new:
+       <a href="${content.urls.mark_read}" class="btn btn-success ${disabled_or_not}" style="text-align: center;">
+           <i class="fa fa-4x fa-fw fa-eye"></i><br/>
+           <span style="color: #FFF">${_('Mark read')}</span>
+       </a>
+    % else:
+       <a href="${content.urls.mark_unread}" class="btn btn-default ${disabled_or_not}" style="text-align: center;">
+           <i class="fa fa-4x fa-fw fa-eye-slash tracim-less-visible"></i><br/>
+           <span class="tracim-less-visible">${_('Mark unread')}</span>
+       </a>
+    % endif
+</%def>

tracim/tracim/tests/__init__.py

 from webtest import TestApp
 
 from gearbox.commands.setup_app import SetupAppCommand
+
+import tg
 from tg import config
 from tg.util import Bunch
 
 
 class TestStandard(object):
 
+    application_under_test = application_name
+
     def setUp(self):
-        self.app = load_app('main')
+        self.app = load_app(self.application_under_test)
 
         logger.debug(self, 'Start setUp() by trying to clean database...')
         try:
         setup_db()
         logger.debug(self, 'Start Database Setup... -> done')
 
+        self.app.get('/_test_vars')  # Allow to create fake context
+        tg.i18n.set_lang('en')  # Set a default lang
+
     def tearDown(self):
         transaction.commit()
 

tracim/tracim/tests/library/test_serializers.py

 # -*- coding: utf-8 -*-
 
+from datetime import datetime
 from nose.tools import eq_
 from nose.tools import ok_
 from nose.tools import raises
 from sqlalchemy.orm.exc import NoResultFound
 
 import transaction
+import tg
 
 from tracim.model import DBSession
 
         eq_(3, len(res.keys()))
 
     def test_serialize_Content_DEFAULT(self):
+        self.app.get('/_test_vars')  # Allow to create fake context
+
         obj = Content()
         obj.content_id = 132
         obj.label = 'Some label'
         eq_(None, res.workspace, res)
         eq_(4, len(res.keys()), res)
 
+    def test_serialize_Content_comment_THREAD(self):
+        wor = Workspace()
+        wor.workspace_id = 4
 
+        fol = Content()
+        fol.type = ContentType.Folder
+        fol.content_id = 72
+        fol.workspace = wor
 
-    # def test_serialize_Content_comment_THREAD(self):
-    #
-    #     wor = Workspace()
-    #     wor.workspace_id = 4
-    #
-    #     fol = Content()
-    #     fol.type = ContentType.Folder
-    #     fol.content_id = 72
-    #     fol.workspace = wor
-    #
-    #     par = Content()
-    #     par.type = ContentType.Thread
-    #     par.content_id = 37
-    #     par.parent = fol
-    #     par.workspace = wor
-    #
-    #     obj = Content()
-    #     obj.type = ContentType.Comment
-    #     obj.content_id = 132
-    #     obj.label = 'some label'
-    #     obj.description = 'Some Description'
-    #     obj.parent = par
-    #
-    #     res = Context(CTX.THREAD).toDict(obj)
-    #     eq_(res.__class__, DictLikeClass, res)
-    #
-    #     ok_('label' in res.keys())
-    #     eq_(obj.label, res.label, res)
-    #
-    #     ok_('content' in res.keys())
-    #     eq_(obj.description, res.content, res)
-    #
-    #     ok_('created' in res.keys())
-    #
-    #     ok_('icon' in res.keys())
-    #     eq_(ContentType.icon(obj.type), res.icon, res)
-    #
-    #     ok_('id' in res.folder.keys())
-    #     eq_(obj.content_id, res.id, res)
-    #
-    #     ok_('owner' in res.folder.keys())
-    #     eq_(None, res.owner, res) # TODO - test with a owner value
-    #
-    #     ok_('type' in res.folder.keys())
-    #     eq_(obj.type, res.type, res)
-    #
-    #     ok_('urls' in res.folder.keys())
-    #     ok_('delete' in res.urls.keys())
-    #
-    #     eq_(8, len(res.keys()), res)
+        par = Content()
+        par.type = ContentType.Thread
+        par.content_id = 37
+        par.parent = fol
+        par.workspace = wor
+        par.created = datetime.now()
 
-    def test_serializer_get_converter_return_CTX_DEFAULT(self):
+        obj = Content()
+        obj.type = ContentType.Comment
+        obj.content_id = 132
+        obj.label = 'some label'
+        obj.description = 'Some Description'
+        obj.parent = par
+        obj.created = datetime.now()
+
+        print('LANGUAGES #2 ARE', tg.i18n.get_lang())
+        res = Context(CTX.THREAD).toDict(obj)
+        eq_(res.__class__, DictLikeClass, res)
+
+        ok_('label' in res.keys())
+        eq_(obj.label, res.label, res)
+
+        ok_('content' in res.keys())
+        eq_(obj.description, res.content, res)
 
+        ok_('created' in res.keys())
+
+        ok_('icon' in res.keys())
+        eq_(ContentType.get_icon(obj.type), res.icon, res)
+
+        ok_('delete' in res.urls.keys())
+
+        eq_(10, len(res.keys()), len(res.keys()))
+
+    def test_serializer_get_converter_return_CTX_DEFAULT(self):
         class A(object):
             pass
 
 
         converter = Context.get_converter(CTX.FILE, A)
 
-    def test_serializer_toDict_int_str_and_LazyString(self):
 
+
+    def test_serializer_toDict_int_str_and_LazyString(self):
         s = Context(CTX.DEFAULT).toDict(5)
         ok_(isinstance(s, int))
         eq_(5, s)
         eq_(lazystr, s3)
 
     def test_serializer_toDict_for_list_of_objects(self):
-
         class A(object):
             def __init__(self, name):
                 self.name = name
 
 
     def test_serializer_content__menui_api_context__children(self):
-        self.app.get('/_test_vars')  # Allow to create fake context
-
         folder_without_child = Content()
         folder_without_child.type = ContentType.Folder
         res = Context(CTX.MENU_API).toDict(folder_without_child)