show full history on pages and files

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

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/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/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_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>