Merge pull request #22 from lebouquetin/feature/full-history-for-files-and-pages

tracim/tracim/controllers/admin/user.py

 from formencode.validators import FieldsMatch
 
 from tracim.controllers import TIMRestController
+from tracim.controllers.user import UserWorkspaceRestController
+
 from tracim.lib import CST
 from tracim.lib import helpers as h
 from tracim.lib.base import logger
         tg.redirect(next_url)
 
 
+class UserWorkspaceRestController(TIMRestController):
+
+    def _before(self, *args, **kw):
+        """
+        Instantiate the current workspace in tg.tmpl_context
+        :param args:
+        :param kw:
+        :return:
+        """
+        super(self.__class__, self)._before(args, kw)
+
+        api = UserApi(tg.tmpl_context.current_user)
+        user_id = tg.request.controller_state.routing_args.get('user_id')
+        user = api.get_one(user_id)
+        tg.tmpl_context.user_id = user_id
+        tg.tmpl_context.user = user
+
+    @tg.expose()
+    def enable_notifications(self, workspace_id, next_url=None):
+        workspace_id = int(workspace_id)
+        api = WorkspaceApi(tg.tmpl_context.current_user)
+
+        workspace = api.get_one(workspace_id)
+        api.enable_notifications(tg.tmpl_context.user, workspace)
+        tg.flash(_('User {}: notification enabled for workspace {}').format(
+            tg.tmpl_context.user.get_display_name(), workspace.label))
+
+        if next_url:
+            tg.redirect(tg.url(next_url))
+        tg.redirect(self.parent_controller.url(None, 'me'))
+
+    @tg.expose()
+    def disable_notifications(self, workspace_id, next_url=None):
+        workspace_id = int(workspace_id)
+        api = WorkspaceApi(tg.tmpl_context.current_user)
+
+        workspace = api.get_one(workspace_id)
+        api.disable_notifications(tg.tmpl_context.user, workspace)
+        tg.flash(_('User {}: notification disabled for workspace {}').format(
+            tg.tmpl_context.user.get_display_name(), workspace.label))
+
+        if next_url:
+            tg.redirect(tg.url(next_url))
+        tg.redirect(self.parent_controller.url(None, 'me'))
+
+
 class UserRestController(TIMRestController):
     """
      CRUD Controller allowing to manage Users
 
     password = UserPasswordAdminRestController()
     profile = UserProfileAdminRestController()
+    workspaces = UserWorkspaceRestController()
 
     @classmethod
     def current_item_id_key_in_context(cls):
 
         user = api.get_one(user_id) # FIXME
 
-        dictified_user = Context(CTX.USER).toDict(user, 'user')
+        role_api = RoleApi(tg.tmpl_context.current_user)
+        role_list = role_api.get_roles_for_select_field()
+
+        dictified_user = Context(CTX.ADMIN_USER).toDict(user, 'user')
         current_user_content = Context(CTX.CURRENT_USER).toDict(tmpl_context.current_user)
-        fake_api_content = DictLikeClass(current_user=current_user_content)
-        fake_api = Context(CTX.WORKSPACE).toDict(fake_api_content)
+        fake_api_content = DictLikeClass(current_user=current_user_content,
+                                         role_types=role_list)
+        fake_api = Context(CTX.ADMIN_USER).toDict(fake_api_content)
 
         return DictLikeClass(result = dictified_user, fake_api=fake_api)
 

tracim/tracim/controllers/admin/workspace.py

     def get_one(self, user_id):
         pass
 
-
     def put(self, *args, **kw):
         pass
 
     def undelete(self, user_id, old_role):
         user_id = int(user_id)
         role_id = int(old_role)
-        self._add_user_with_role(user_id, role_id, _('User {} restored in workspace {} as {}'))
+        self._add_user_with_role(user_id, role_id, None, _('User {} restored in workspace {} as {}'))
         tg.redirect(self.parent_controller.url(tg.tmpl_context.workspace_id))
 
     @tg.expose()
-    def post(self, user_id, role_id):
+    def post(self, user_id, role_id, with_notif=False):
         user_id = int(user_id)
         role_id = int(role_id)
-        self._add_user_with_role(user_id, role_id, _('User {} added to workspace {} as {}'))
+        self._add_user_with_role(user_id, role_id, with_notif, _('User {} added to workspace {} as {}'))
         tg.redirect(self.parent_controller.url(tg.tmpl_context.workspace_id))
 
-    def _add_user_with_role(self, user_id: int, role_id: int, flash_msg_template)-> UserRoleInWorkspace:
+    def _add_user_with_role(self, user_id: int, role_id: int, with_notif: bool, flash_msg_template)-> UserRoleInWorkspace:
         user_api = UserApi(tg.tmpl_context.current_user)
         user = user_api.get_one(user_id)
 
         role_api = RoleApi(tg.tmpl_context.current_user)
-        role = role_api.create_one(user, tg.tmpl_context.workspace, role_id)
+        role = role_api.create_one(user, tg.tmpl_context.workspace, role_id, with_notif)
 
         tg.flash(flash_msg_template.format(
             role.user.get_display_name(),

tracim/tracim/controllers/workspace.py

 
         if not current_id:
             # Default case is to return list of workspaces
-            print('ignore : ', ignored_ids)
             api = WorkspaceApi(tmpl_context.current_user)
             workspaces = api.get_all_for_user(tmpl_context.current_user,
                                               ignored_ids)

tracim/tracim/lib/content.py

         elif new_workspace:
             item.workspace = new_workspace
 
-        item.revision_type = ActionDescription.EDITION
+        item.revision_type = ActionDescription.MOVE
 
     def move_recursively(self, item: Content,
                          new_parent: Content, new_workspace: Workspace):
         self.move(item, new_parent, False, new_workspace)
         self.save(item, do_notify=False)
-        print('saved item #', item.content_id, new_workspace)
+
         for child in item.children:
             self.move_recursively(child, item, new_workspace)
         return

tracim/tracim/lib/helpers.py

     return ContentType._DELETE_LABEL[item.type]
 
 def is_item_still_editable(item):
+    if item.type.id != 'comment':
+        return False
+
     # HACK - D.A - 2014-12-24 - item contains a datetime object!!!
     # 'item' is a variable which is created by serialization and it should be an instance of DictLikeClass.
     # therefore, it contains strins, integers and booleans (something json-ready or almost json-ready)

tracim/tracim/lib/userworkspace.py

     def get_one(self, user_id, workspace_id):
         return self._get_one_rsc(user_id, workspace_id).one()
 
-    def create_one(self, user: User, workspace: Workspace, role_level: int, flush: bool=True) -> UserRoleInWorkspace:
+    def create_one(self, user: User, workspace: Workspace, role_level: int, with_notif: bool, flush: bool=True) -> UserRoleInWorkspace:
         role = self.create_role()
         role.user_id = user.user_id
         role.workspace = workspace
         role.role = role_level
+        if with_notif is not None:
+            role.do_notify = with_notif
         if flush:
             DBSession.flush()
         return role

tracim/tracim/lib/workspace.py

         workspace.description = description
 
         # By default, we force the current user to be the workspace manager
-        role = RoleApi(self._user).create_one(self._user, workspace, UserRoleInWorkspace.WORKSPACE_MANAGER)
+        # And to receive email notifications
+        role = RoleApi(self._user).create_one(self._user, workspace,
+                                              UserRoleInWorkspace.WORKSPACE_MANAGER,
+                                              with_notif=True)
 
         DBSession.add(workspace)
         DBSession.add(role)

tracim/tracim/model/auth.py

 
     def get_role(self, workspace: 'Workspace') -> int:
         for role in self.roles:
-            print('IS EQUALS ? ', role.workspace, workspace)
             if role.workspace == workspace:
                 return role.role
 

tracim/tracim/model/data.py

 from sqlalchemy.types import Text
 from sqlalchemy.types import Unicode
 
-from tg.i18n import lazy_ugettext as l_
+from tg.i18n import lazy_ugettext as l_, ugettext as _
 
 from tracim.model import DeclarativeBase
 from tracim.model.auth import User
     STATUS_UPDATE = 'status-update'
     UNARCHIVING = 'unarchiving'
     UNDELETION = 'undeletion'
+    MOVE = 'move'
 
     _ICONS = {
         'archiving': 'fa fa-archive',
         'content-comment': 'fa-comment-o',
         'creation': 'fa-magic',
-        'deletion': 'fa fa-trash',
-        'edition': 'fa fa-edit',
+        'deletion': 'fa-trash',
+        'edition': 'fa-edit',
         'revision': 'fa-history',
         'status-update': 'fa-random',
-        'unarchiving': 'fa fa-file-archive-o',
-        'undeletion': 'fa-trash-o'
+        'unarchiving': 'fa-file-archive-o',
+        'undeletion': 'fa-trash-o',
+        'move': 'fa-arrows'
     }
 
     _LABELS = {
         'archiving': l_('archive'),
-        'content-comment': l_('commente'),
-        'creation': l_('creation'),
-        'deletion': l_('deletion'),
-        'edition': l_('modified'),
-        'revision': l_('revision'),
-        'status-update': l_('statut'),
-        'unarchiving': l_('un-archived'),
-        'undeletion': l_('un-deleted'),
+        'content-comment': l_('Item commented'),
+        'creation': l_('Item created'),
+        'deletion': l_('Item deleted'),
+        'edition': l_('item modified'),
+        'revision': l_('New revision'),
+        'status-update': l_('New status'),
+        'unarchiving': l_('Item unarchived'),
+        'undeletion': l_('Item undeleted'),
+        'move': l_('Item moved')
     }
 
     def __init__(self, id):
         self.id = id
         self.label = ActionDescription._LABELS[id]
         self.icon = ActionDescription._ICONS[id]
+        self.css = ''
 
     @classmethod
     def allowed_values(cls):
                 cls.REVISION,
                 cls.STATUS_UPDATE,
                 cls.UNARCHIVING,
-                cls.UNDELETION]
+                cls.UNDELETION,
+                cls.MOVE]
 
 
 class ContentStatus(object):
     def sorted(cls, types: ['ContentType']) -> ['ContentType']:
         return sorted(types, key=lambda content_type: content_type.priority)
 
+    @property
+    def type(self):
+        return self.id
+
     def __init__(self, type):
-        self.type = type
+        self.id = type
         self.icon = ContentType._CSS_ICONS[type]
-        self.color = ContentType._CSS_COLORS[type]
+        self.color = ContentType._CSS_COLORS[type]  # deprecated
+        self.css = ContentType._CSS_COLORS[type]
         self.label = ContentType._LABEL[type]
         self.priority = ContentType._ORDER_WEIGHT[type]
 
         except Exception as e:
             print(e.__str__())
             print('----- /*\ *****')
-            raise ValueError('No allowed content property')
+            raise ValueError('Not allowed content property')
 
         return ContentType.sorted(types)
 
+    def get_history(self) -> '[VirtualEvent]':
+        events = []
+        for comment in self.get_comments():
+            events.append(VirtualEvent.create_from_content(comment))
+        for revision in self.revisions:
+            events.append(VirtualEvent.create_from_content_revision(revision))
+
+        sorted_events = sorted(events,
+                               key=lambda event: event.created, reverse=True)
+        return sorted_events
+
 
 class ContentChecker(object):
 
     file_mimetype = Column(Unicode(255),  unique=False, nullable=False, default='')
     file_content = deferred(Column(LargeBinary(), unique=False, nullable=False, default=None))
 
+    type = Column(Unicode(32), unique=False, nullable=False)
     status = Column(Unicode(32), unique=False, nullable=False)
     created = Column(DateTime, unique=False, nullable=False)
     updated = Column(DateTime, unique=False, nullable=False)
     def get_status(self):
         return ContentStatus(self.status)
 
+    def get_label(self):
+        return self.label if self.label else self.file_name if self.file_name else ''
+
     def get_last_action(self) -> ActionDescription:
         return ActionDescription(self.revision_type)
 
         self.node = node
         self.children = children
         self.is_selected = is_selected
+
+class VirtualEvent(object):
+    @classmethod
+    def create_from(cls, object):
+        if Content == object.__class__:
+            return cls.create_from_content(object)
+        elif ContentRevisionRO == object.__class__:
+            return cls.create_from_content_revision(object)
+
+    @classmethod
+    def create_from_content(cls, content: Content):
+        content_type = ContentType(content.type)
+
+        label = content.get_label()
+        if content.type==ContentType.Comment:
+            label = _('<strong>{}</strong> wrote:').format(content.owner.get_display_name())
+
+        return VirtualEvent(id=content.content_id,
+                            created=content.created,
+                            owner=content.owner,
+                            type=content_type,
+                            label=label,
+                            content=content.description,
+                            ref_object=content)
+
+    @classmethod
+    def create_from_content_revision(cls, revision: ContentRevisionRO):
+        action_description = ActionDescription(revision.revision_type)
+
+        return VirtualEvent(id=revision.revision_id,
+                            created=revision.created,
+                            owner=revision.owner,
+                            type=action_description,
+                            label=action_description.label,
+                            content='',
+                            ref_object=revision)
+
+    def __init__(self, id, created, owner, type, label, content, ref_object):
+        self.id = id
+        self.created = created
+        self.owner = owner
+        self.type = type
+        self.label = label
+        self.content = content
+        self.ref_object = ref_object
+
+        print(type)
+        assert hasattr(type, 'id')
+        assert hasattr(type, 'css')
+        assert hasattr(type, 'icon')
+        assert hasattr(type, 'label')
+
+    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])

tracim/tracim/model/serializers.py

 from tracim.model.data import ContentType
 from tracim.model.data import RoleType
 from tracim.model.data import UserRoleInWorkspace
+from tracim.model.data import VirtualEvent
 from tracim.model.data import Workspace
 
 from tracim.model import data as pmd
 
 class CTX(object):
     """ constants that are used for serialization / dictification of models"""
+    ADMIN_USER = 'ADMIN_USER'
     ADMIN_WORKSPACE = 'ADMIN_WORKSPACE'
     ADMIN_WORKSPACES = 'ADMIN_WORKSPACES'
     CONTENT_LIST = 'CONTENT_LIST'
+    CONTENT_HISTORY = 'CONTENT_HISTORY'
     CURRENT_USER = 'CURRENT_USER'
     DEFAULT = 'DEFAULT' # default context. This will allow to define a serialization method to be used by default
     EMAIL_NOTIFICATION = 'EMAIL_NOTIFICATION'
     if content.type in (ContentType.Page, ContentType.File) :
         data_container = content
 
-
-
         # The following properties are overriden by revision values
         if content.revision_to_serialize>0:
             for revision in content.revisions:
                     break
 
         result = DictLikeClass(
-            id = content.content_id,
-            parent = context.toDict(content.parent),
-            workspace = context.toDict(content.workspace),
-            type = content.type,
-
-            content = data_container.description,
-            created = data_container.created,
-            label = data_container.label,
-            icon = ContentType.get_icon(content.type),
-            owner = context.toDict(data_container.owner),
-            status = context.toDict(data_container.get_status()),
-            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
+            id=content.content_id,
+            parent=context.toDict(content.parent),
+            workspace=context.toDict(content.workspace),
+            type=content.type,
+
+            content=data_container.description,
+            created=data_container.created,
+            label=data_container.label,
+            icon=ContentType.get_icon(content.type),
+            owner=context.toDict(data_container.owner),
+            status=context.toDict(data_container.get_status()),
+            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())
         )
 
         if content.type==ContentType.File:
     raise NotImplementedError
 
 
+@pod_serializer(VirtualEvent, CTX.CONTENT_HISTORY)
+def serialize_content_for_history(event: VirtualEvent, context: Context):
+    urls = DictLikeClass({'delete': None})
+    if ContentType.Comment == event.type.id:
+        urls = context.toDict({
+          'delete': context.url('/workspaces/{wid}/folders/{fid}/{ctype}/{cid}/comments/{commentid}/put_delete'.format(
+              wid = event.ref_object.workspace_id,
+              fid=event.ref_object.parent.parent_id,
+              ctype=event.ref_object.parent.type+'s',
+              cid=event.ref_object.parent.content_id,
+              commentid=event.ref_object.content_id))
+        })
+
+    return DictLikeClass(
+        owner=context.toDict(event.owner),
+        id=event.id,
+        label=event.label,
+        type=context.toDict(event.type),
+        created=event.created,
+        created_as_delta=event.created_as_delta(),
+        content=event.content,
+        urls = urls
+    )
+
+
 @pod_serializer(Content, CTX.THREAD)
 def serialize_node_for_page(item: Content, context: Context):
     if item.type==ContentType.Thread:
             status = context.toDict(item.get_status()),
             type = item.type,
             workspace = context.toDict(item.workspace),
-            comments = reversed(context.toDict(item.get_comments()))
+            comments = reversed(context.toDict(item.get_comments())),
+            history = Context(CTX.CONTENT_HISTORY).toDict(item.get_history())
         )
 
     if item.type==ContentType.Comment:
 def serialize_breadcrumb_item(content_type: ContentType, context: Context):
     return DictLikeClass(content_type.toDict())
 
+
 @pod_serializer(Content, CTX.SEARCH)
 def serialize_content_for_search_result(content: Content, context: Context):
 
 
 
 @pod_serializer(RoleType, CTX.ADMIN_WORKSPACE)
+@pod_serializer(RoleType, CTX.ADMIN_USER)
 def serialize_role_list_for_select_field_in_workspace(role_type: RoleType, context: Context):
     """
     Actually, roles are serialized as users (with minimal information)
 
 
 @pod_serializer(User, CTX.USER)
+@pod_serializer(User, CTX.ADMIN_USER)
 @pod_serializer(User, CTX.CURRENT_USER)
 def serialize_user_for_user(user: User, context: Context):
     """
     result['style'] = role.style
     result['role_description'] = role.role_as_label()
     result['email'] = role.user.email
-    result['user'] = role.user
+    result['user'] = context.toDict(role.user)
     result['notifications_subscribed'] = role.do_notify
     return result
 
 
 @pod_serializer(UserRoleInWorkspace, CTX.USER)
 @pod_serializer(UserRoleInWorkspace, CTX.CURRENT_USER)
+@pod_serializer(UserRoleInWorkspace, CTX.ADMIN_USER)
 def serialize_role_in_list_for_user(role: UserRoleInWorkspace, context: Context):
     """
     Actually, roles are serialized as users (with minimal information)
     result['label'] = role.role_as_label()
     result['style'] = RoleType(role.role).css_style
     result['workspace'] =  context.toDict(role.workspace)
-    result['user'] = role.user
+    result['user'] = Context(CTX.DEFAULT).toDict(role.user)
     result['notifications_subscribed'] = role.do_notify
 
     # result['workspace_name'] = role.workspace.label
 def serialize_workspace_default(workspace: Workspace, context: Context):
     result = DictLikeClass(
         id = workspace.workspace_id,
-        label = workspace.label,
+        label = workspace.label,  # FIXME - 2015-08-20 - remove this property
+        name = workspace.label,  # use name instead of label
         url = context.url('/workspaces/{}'.format(workspace.workspace_id))
     )
     return result

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

     padding: 0;
     position: absolute;
     top: 0;
-}
+}
+
+#t-full-app-alert-message-id > div.alert {
+    box-shadow: 0px 0px 5px 5px rgba(0, 0, 0, 0.3);
+}

tracim/tracim/templates/admin/user_getone.mak

                             ${ICON.FA('fa-bar-chart t-less-visible')}
                             ${_('Global profile')}
                         </h3>
-                        ${P.USER_PROFILE(result.user)}
+                        ${P.USER_PROFILE(fake_api.current_user, result.user)}
                     </div>
                     <div style="margin-top: 4em;">
                         <h3>
                                     </tr>
                                 </thead>
                                 % for role in result.user.roles:
-                                    ${TABLE_ROW.USER_ROLE_IN_WORKSPACE(role)}
+<%
+    enable_link = '/admin/users/{user}/workspaces/{workspace}/enable_notifications?next_url=/admin/users/{user}'
+    disable_link = '/admin/users/{user}/workspaces/{workspace}/disable_notifications?next_url=/admin/users/{user}'
+%>
+                                    ${TABLE_ROW.USER_ROLE_IN_WORKSPACE(fake_api.current_user, role, show_id=True, enable_link=enable_link, disable_link=disable_link)}
                                 % endfor
                             </table>
                         % endif

tracim/tracim/templates/admin/workspace_getone.mak

                                             % endfor
                                         </div>
 
+                                        <div class="checkbox">
+                                            <label>
+                                                <input type="checkbox" id="with_notif" name="with_notif" checked="checked"/> ${_('Subscribe to mail notifications')}
+                                            </label>
+                                        </div>
+
                                         <span class="pull-right" style="margin-top: 0.5em;">
                                             <button id="current-document-add-comment-save-button" type="submit" class="btn btn-small btn-success" title="Add first comment"><i class=" fa fa-check"></i> ${_('Validate')}</button>
                                         </span>

tracim/tracim/templates/file/getone.mak

     <div class="col-sm-7 col-sm-offset-3">
         <div class="t-spacer-above">
             <span id="associated-revisions" ></span>
-            <h4 class="anchored-title">${_('File revisions')}</h4>
+            <h4 class="anchored-title">${_('File history')}</h4>
             <div>
                 <table class="table table-striped table-hover">
-                    % for revid, revision in reversed(list(enumerate(reversed(result.file.revisions)))):
-                        <% warning_or_not = ('', 'warning')[result.file.selected_revision==revision.id] %>
-                        <tr class="${warning_or_not}">
-## FIXME - 2015-07-22 - D.A. - Do we really need to show a rev. id ?!
-## <td><span class="label label-default">v${revid}</span></td>
-                            <td class="t-less-visible">
-                                <span class="label label-default">${ICON.FA_FW(revision.action.icon)}
-                                ${revision.action.label}</span>
-                            </td>
-                            <td>${h.date(revision.created)}</td>
-                            <td>${h.time(revision.created)}</td>
-                            <td>${revision.owner.name}</td>
-                            <td><a href="${tg.url('/workspaces/{}/folders/{}/files/{}?revision_id={}').format(result.file.workspace.id, result.file.parent.id, result.file.id, revision.id)}">${revision.label}</a></td>
-                            <td class="t-less-visible" title="${_('Currently shown')}">
-                                % if warning_or_not:
-                                    ${ICON.FA_FW('fa fa-caret-left')} ${_('shown').format(result.file.selected_revision)}
-                                % endif
-                            </td>
-                        </tr>
+                    % for event in result.file.history:
+                        ${WIDGETS.SECURED_HISTORY_VIRTUAL_EVENT_AS_TABLE_ROW(fake_api.current_user, event, result.file.selected_revision)}
                     % endfor
                 </table>
             </div>
         </div>
     </div>
-<div/>
+<div/>
+

tracim/tracim/templates/home.mak

                                                 </tr>
                                             </thead>
                                             % for role in fake_api.current_user.roles:
-                                                ${TABLE_ROW.USER_ROLE_IN_WORKSPACE(role, show_id=False, enable_link='/user/me/workspaces/{workspace}/enable_notifications?next_url=/home', disable_link='/user/me/workspaces/{workspace}/disable_notifications?next_url=/home')}
+                                                ${TABLE_ROW.USER_ROLE_IN_WORKSPACE(fake_api.current_user, role, show_id=False, enable_link='/user/me/workspaces/{workspace}/enable_notifications?next_url=/home', disable_link='/user/me/workspaces/{workspace}/disable_notifications?next_url=/home')}
                                             % endfor
                                         </table>
                                     % endif

tracim/tracim/templates/page/getone.mak

     <div class="col-sm-7 col-sm-offset-3">
         <div class="t-spacer-above">
             <span id="associated-revisions" ></span>
-            <h4 class="anchored-title">${_('Page revisions')}</h4>
+            <h4 class="anchored-title">${_('Page history')}</h4>
             <div>
                 <table class="table table-striped table-hover">
-                    % for revid, revision in reversed(list(enumerate(reversed(result.page.revisions)))):
-                        <% warning_or_not = ('', 'warning')[result.page.selected_revision==revision.id] %>
-                        <tr class="${warning_or_not}">
-## FIXME - 2015-07-22 - D.A. - Do we really need to show a rev. id ?!
-## <td><span class="label label-default">v${revid}</span></td>
-                            <td class="t-less-visible">
-                                <span class="label label-default">${ICON.FA_FW(revision.action.icon)}
-                                ${revision.action.label}</span>
-                            </td>
-                            <td>${h.date(revision.created)}</td>
-                            <td>${h.time(revision.created)}</td>
-                            <td>${revision.owner.name}</td>
-                            <td><a href="${tg.url('/workspaces/{}/folders/{}/pages/{}?revision_id={}').format(result.page.workspace.id, result.page.parent.id, result.page.id, revision.id)}">${revision.label}</a></td>
-                            <td class="t-less-visible" title="${_('Currently shown')}">
-                                % if warning_or_not:
-                                    ${ICON.FA_FW('fa fa-caret-left')} ${_('shown').format(result.page.selected_revision)}
-                                % endif
-                            </td>
-                        </tr>
+                    % for event in result.page.history:
+                        ${WIDGETS.SECURED_HISTORY_VIRTUAL_EVENT_AS_TABLE_ROW(fake_api.current_user, event, result.page.selected_revision)}
                     % endfor
                 </table>
             </div>
         </div>
     </div>
 <div/>
+

tracim/tracim/templates/thread/getone.mak

     </div>
 </div>
 
-% for comment in result.thread.comments:
-    ${WIDGETS.SECURED_TIMELINE_ITEM(fake_api.current_user, comment)}
+% for event in result.thread.history:
+    ## TODO - D.A. - 2015-08-20
+    ## Allow to show full history (with status change and archive/unarchive)
+    % if event.type.id in ('comment', 'creation'):
+        ${WIDGETS.SECURED_HISTORY_VIRTUAL_EVENT(fake_api.current_user, event)}
+    % endif
 % endfor
 
-## <hr class="tracim-panel-separator"/>
-## <div>
-##     <h4 id="associated-links" class="anchored-title" >${_('Links extracted from the thread')}</h4>
-##     <div>
-##         % if len(result.thread.links)<=0:
-##             <p class="pod-empty">${_('No link found.')}</p>
-##         % else:
-##             <ul>
-##                 % for link in result.thread.links:
-##                     <li><a href="${link.href}">${link.label if link.label else link.href}</a></li>
-##                 % endfor
-##             </ul>
-##         % endif
-##     </div>
-##     <hr/>
-## 
-##     % for comment in result.thread.comments:
-##         ${comment}
-##     % endfor
-## </div>
+## % for comment in result.thread.comments:
+##     ${WIDGETS.SECURED_TIMELINE_ITEM(fake_api.current_user, comment)}
+## % endfor
+##

tracim/tracim/templates/user_get_me.mak

                             </table>
                         % endif
                     </div>
-                    % if len(result.user.roles)>0:
+                    % if len(result.user.roles) > 0:
                         <p class="alert alert-info">${_('You can configure your email notifications by clicking on the email icons above')}</p>
                     % endif
                 </div>

tracim/tracim/templates/user_workspace_widgets.mak

 </%def>
 
 <%def name="SECURED_TIMELINE_ITEM(user, item)">
+##     <div class="row t-odd-or-even t-hacky-thread-comment-border-top">
+##         <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>
+##                 ${ICON.FA_FW('fa fa-3x fa-comment-o t-less-visible t-timeline-item-icon')}
+##
+##                 <h5 style="margin: 0;">
+##                     <span class="tracim-less-visible">${_('<strong>{}</strong> wrote:').format(item.owner.name)|n}</span>
+##
+##                     <div class="pull-right text-right t-timeline-item-moment" title="${h.date_time(item.created)|n}">
+##                         ${_('{delta} ago').format(delta=item.created_as_delta)}
+##
+##                         % if h.is_item_still_editable(item) and item.owner.id==user.id:
+##                             <br/>
+## ##                            <div class="btn-group">
+##                                 <a class="t-timeline-comment-delete-button" href="${item.urls.delete}">
+##                                     ${_('delete')} ${ICON.FA('fa fa-trash-o')}
+## ##                                    ${TIM.ICO_TOOLTIP(16, 'status/user-trash-full', h.delete_label_for_item(item))}
+##                                 </a>
+## ##                            </div>
+##                         % endif
+##                     </div>
+##                 </h5>
+##                 <div class="t-timeline-item-content">
+##                     <div>${item.content|n}</div>
+##                     <br/>
+##                 </div>
+##             </div>
+##         </div>
+##     </div>
+</%def>
+
+<%def name="SECURED_HISTORY_VIRTUAL_EVENT(user, event)">
     <div class="row t-odd-or-even t-hacky-thread-comment-border-top">
         <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>
-                ${ICON.FA_FW('fa fa-3x fa-comment-o t-less-visible t-timeline-item-icon')}
+
+                ${ICON.FA_FW('fa fa-3x t-less-visible t-timeline-item-icon '+event.type.icon)}
 
                 <h5 style="margin: 0;">
-                    <span class="tracim-less-visible">${_('<strong>{}</strong> wrote:').format(item.owner.name)|n}</span>
 
-                    <div class="pull-right text-right t-timeline-item-moment" title="${h.date_time(item.created)|n}">
-                        ${_('{delta} ago').format(delta=item.created_as_delta)}
+                    % if 'comment' == event.type.id:
+                        <span class="tracim-less-visible">${_('<strong>{}</strong> wrote:').format(event.owner.name)|n}</span>
+                    %else:
+                        <span class="tracim-less-visible">${_('{} by <strong>{}</strong>').format(event.label, event.owner.name)|n}</span>
+                    % endif
+
+                    <div class="pull-right text-right t-timeline-item-moment" title="${h.date_time(event.created)|n}">
+                        ${_('{delta} ago').format(delta=event.created_as_delta)}
 
-                        % if h.is_item_still_editable(item) and item.owner.id==user.id:
+                        % if h.is_item_still_editable(event) and event.owner.id==user.id:
                             <br/>
-##                            <div class="btn-group">
-                                <a class="t-timeline-comment-delete-button" href="${item.urls.delete}">
+                                <a class="t-timeline-comment-delete-button" href="${event.urls.delete}">
                                     ${_('delete')} ${ICON.FA('fa fa-trash-o')}
-##                                    ${TIM.ICO_TOOLTIP(16, 'status/user-trash-full', h.delete_label_for_item(item))}
                                 </a>
-##                            </div>
                         % endif
                     </div>
                 </h5>
                 <div class="t-timeline-item-content">
-                    <div>${item.content|n}</div>
+                    <div>${event.content|n}</div>
                     <br/>
                 </div>
             </div>
         </div>
     </div>
 </%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}">
+        <td class="t-less-visible">
+            <span class="label label-default">${ICON.FA_FW(event.type.icon)} ${event.type.label}</span>
+        </td>
+        <td title="${h.date_time(event.created)|n}">${_('{delta} ago').format(delta=event.created_as_delta)}</td>
+        <td>${event.owner.name}</td>
+## FIXME - REMOVE                            <td>${event}</td>
+
+        % if 'comment' == event.type.id:
+            <td colspan="2">
+                ${event.content|n}
+            </td>
+        % else:
+
+            <td>
+                % if event.type.id in ('creation', 'edition', 'revision'):
+                    <a href="${'?revision_id={}'.format(event.id)}">${_('View revision')}</a>
+                % endif
+            </td>
+            <td class="t-less-visible" title="${_('Currently shown')}">
+                % if warning_or_not:
+                    ${ICON.FA_FW('fa fa-caret-left')}&nbsp;${_('shown')}
+                % endif
+            </td>
+        % endif
+    </tr>
+</%def>

tracim/tracim/templates/widgets/paragraph.mak

 <%namespace name="ICON" file="tracim.templates.widgets.icon"/>
 <%namespace name="BUTTON" file="tracim.templates.widgets.button"/>
 
-<%def name="USER_PROFILE(user)">
+<%def name="USER_PROFILE(current_user, user)">
     % if user.profile.id >= 1:
         <p>${ICON.FA('fa-male t-green fa-lg fa-fw')}<span> ${_('This user a standard user.')}</span></p>
     %else:

tracim/tracim/templates/widgets/table_row.mak

 <%namespace name="ICON" file="tracim.templates.widgets.icon"/>
 <%namespace name="SPAN" file="tracim.templates.widgets.span"/>
 
-<%def name="USER_ROLE_IN_WORKSPACE(role, show_id=True, enable_link=None, disable_link=None)">
+<%def name="USER_ROLE_IN_WORKSPACE(current_user, role, show_id=True, enable_link=None, disable_link=None, role_types=None)">
     <tr>
         % if show_id:
             <td class="text-right">${role.workspace.id}</td>
         % endif
         <td><a href="${tg.url('/admin/workspaces/{}').format(role.workspace.id)}">${role.workspace.name}</a></td>
-        <td><span style="${role.style}"><i class="fa ${role.icon}"></i> ${role.label}</span></td>
-        % if enable_link or disable_link:
+
+        % if role_types:
+            ## <td>${BUTTON.SECURED_ROLE_SELECTOR(fake_api.current_user, result.workspace, member, fake_api.role_types)}</td>
+            <td><span style="${role.style}"><i class="fa ${role.icon}"></i> ${role.label}</span></td>
+        % else:
+            <td><span style="${role.style}"><i class="fa ${role.icon}"></i> ${role.label}</span></td>
+        % endif
+
+        <%
+            user_is_himself = current_user.id == role.user.id
+            user_is_manager = h.user_role(current_user, role.workspace) >= 8
+            ## allow user to change notification status only if current user is manager on the given workspace
+        %>
+
+        % if (enable_link or disable_link) and (user_is_himself or user_is_manager) :
             <td>${SPAN.NOTIFICATION_SUBSCRIBED(role.user, role.workspace, role.notifications_subscribed, enable_link, disable_link)}</td>
         % else:
             <td>${SPAN.NOTIFICATION_SUBSCRIBED(role.user, role.workspace, role.notifications_subscribed)}</td>
         <td class="text-right">${member.id}</td>
         <td ><a href="${tg.url('/admin/users/{}'.format(member.id))}">${member.name}</a></td>
         <td>${BUTTON.SECURED_ROLE_SELECTOR(fake_api.current_user, result.workspace, member, fake_api.role_types)}</td>
-        <td>${SPAN.NOTIFICATION_SUBSCRIBED(member, workspace, member.notifications_subscribed)}</td>
+        <%
+            user_is_himself = current_user.id == member.id
+            user_is_manager = h.user_role(current_user, workspace) >= 8
+            ## allow user to change notification status only if current user is manager on the given workspace
+
+            enable_link = '/admin/users/{user}/workspaces/{workspace}/enable_notifications?next_url=/admin/workspaces/{workspace}'
+            disable_link = '/admin/users/{user}/workspaces/{workspace}/disable_notifications?next_url=/admin/workspaces/{workspace}'
+        %>
+        % if (enable_link or disable_link) and (user_is_himself or user_is_manager) :
+            <td>${SPAN.NOTIFICATION_SUBSCRIBED(member, workspace, member.notifications_subscribed, enable_link, disable_link)}</td>
+        % else:
+            <td>${SPAN.NOTIFICATION_SUBSCRIBED(member, workspace, member.notifications_subscribed)}</td>
+        % endif
+
         <td><a title="${_('Remove this user from the current workspace')}" class="t-less-visible t-red-on-hover t-red btn btn-default btn-xs" href="${tg.url('/admin/workspaces/{}/roles/{}/delete'.format(result.workspace.id, member.id))}">${ICON.FA('fa-remove fa-fw')}</a></td>
     </tr>
 </%def>

tracim/tracim/tests/library/test_content_api.py

 
         RoleApi(user1).create_one(user2, workspace,
                                   UserRoleInWorkspace.CONTENT_MANAGER,
+                                  with_notif=False,
                                   flush=True)
 
         # Test starts here
 
         RoleApi(user1).create_one(user2, workspace,
                                   UserRoleInWorkspace.CONTENT_MANAGER,
+                                  with_notif=True,
                                   flush=True)
 
         # Test starts here
 
         RoleApi(user1).create_one(user2, workspace,
                                   UserRoleInWorkspace.CONTENT_MANAGER,
+                                  with_notif=True,
                                   flush=True)
 
         # show archived is used at the top end of the test
 
         RoleApi(user1).create_one(user2, workspace,
                                   UserRoleInWorkspace.CONTENT_MANAGER,
+                                  with_notif=True,
                                   flush=True)
 
         # show archived is used at the top end of the test

tracim/tracim/tests/library/test_helpers.py

 
         h.CFG.DATA_UPDATE_ALLOWED_DURATION = 0
         item.created = datetime.datetime.now() - datetime.timedelta(0, 10)
+
+        item.type = DictLikeClass({'id': 5})
+        eq_(False, h.is_item_still_editable(item))
+
+        item.type.id = 'comment'
         eq_(False, h.is_item_still_editable(item))
 
         h.CFG.DATA_UPDATE_ALLOWED_DURATION = -1
+        item.type.id = 'comment'
         item.created = datetime.datetime.now() - datetime.timedelta(0, 10)
         eq_(True, h.is_item_still_editable(item))