1 #

     2 # Copyright (c) 2008-2015 Thierry Florac <tflorac AT ulthar.net>

     3 # All Rights Reserved.

     4 #

     5 # This software is subject to the provisions of the Zope Public License,

     6 # Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.

     7 # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED

     8 # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

     9 # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS

    10 # FOR A PARTICULAR PURPOSE.

    11 #

    12 

    13 __docformat__ = 'restructuredtext'

    14 

    15 

    16 # import standard library

    17 

    18 # import interfaces

    19 from pyams_content.shared.common.interfaces import IWfSharedContent, ISharedTool

    20 from pyams_form.interfaces.form import IInnerTabForm

    21 from pyams_i18n.interfaces import II18n

    22 from pyams_security.interfaces import ISecurityManager

    23 from pyams_sequence.interfaces import ISequentialIntIds, ISequentialIdInfo

    24 from pyams_skin.layer import IPyAMSLayer

    25 from pyams_workflow.interfaces import IWorkflowState, IWorkflow, IWorkflowStateLabel, IWorkflowVersions

    26 

    27 # import packages

    28 from pyams_template.template import template_config

    29 from pyams_utils.date import format_datetime

    30 from pyams_utils.registry import get_utility

    31 from pyams_utils.traversing import get_parent

    32 from pyams_utils.url import absolute_url

    33 from pyams_viewlet.viewlet import contentprovider_config

    34 from zope.interface import Interface

    35 

    36 from pyams_content import _

    37 

    38 

    39 @contentprovider_config(name='content_header', context=IWfSharedContent, view=Interface, layer=IPyAMSLayer)

    40 @template_config(template='templates/header.pt', layer=IPyAMSLayer)

    41 class SharedContentHeaderContentProvider(object):

    42     """Header for shared contents"""

    43 

    44     back_url = '#summary.html'

    45     back_target = None

    46 

    47     icon_class = ''

    48 

    49     def __init__(self, context, request, view):

    50         super(SharedContentHeaderContentProvider, self).__init__(context, request, view)

    51         # sequence

    52         sequence = get_utility(ISequentialIntIds)

    53         self.oid = sequence.get_short_oid(ISequentialIdInfo(context).oid)

    54         # security

    55         security = get_utility(ISecurityManager)

    56         owner = next(iter(context.owner))

    57         self.owner = security.get_principal(owner).title

    58         # workflow

    59         translate = request.localizer.translate

    60         workflow = IWorkflow(context)

    61         versions = IWorkflowVersions(context)

    62         state = IWorkflowState(context)

    63         self.version_id = state.version_id

    64         state_label = request.registry.queryAdapter(workflow, IWorkflowStateLabel, name=state.state)

    65         if state_label is None:

    66             state_label = request.registry.queryAdapter(workflow, IWorkflowStateLabel)

    67         if state_label is None:

    68             self.state = translate(_("{state} by {{principal}}")).format(

    69                 state=translate(workflow.get_state_label(state.state)))

    70         else:

    71             self.state = state_label.get_label(context, request, format=False)

    72         principal_class = 'text-danger' if state.state_principal != owner else 'txt-color-text'

    73         self.state = self.state.replace('{principal}',

    74                                         '<span class="{0}">{{principal}}</span>'.format(principal_class))

    75         state_class = 'text-danger' if state.state in workflow.update_states else None

    76         if state_class:

    77             self.state = '<span class="{state_class}">{state}</span>'.format(state_class=state_class,

    78                                                                              state=self.state)

    79         self.state = self.state.format(principal=security.get_principal(state.state_principal).title)

    80         self.state_date = translate(_("since {date}")).format(date=format_datetime(state.state_date, request=request))

    81         if state.state not in workflow.update_states and versions.has_version(workflow.update_states):

    82             target = sorted(versions.get_versions(workflow.update_states),

    83                             key=lambda x: IWorkflowState(x).version_id,

    84                             reverse=True)[-1]

    85             self.version_link = {

    86                 'css_class': 'text-danger',

    87                 'href': absolute_url(target, request, 'admin.html'),

    88                 'title': translate(_("access new version"))

    89             }

    90         elif state.state not in workflow.published_states and versions.has_version(workflow.published_states):

    91             target = sorted(versions.get_versions(workflow.published_states),

    92                             key=lambda x: IWorkflowState(x).version_id,

    93                             reverse=True)[-1]

    94             self.version_link = {

    95                 'css_class': 'txt-color-text',

    96                 'href': absolute_url(target, request, 'admin.html'),

    97                 'title': translate(_("access published version"))

    98             }

    99         else:

   100             self.version_link = None

   101 

   102     @property

   103     def title(self):

   104         tool = get_parent(self.context, ISharedTool)

   105         return II18n(tool).query_attribute('title', request=self.request)

   106 

   107 

   108 @contentprovider_config(name='content_header', context=IWfSharedContent, view=IInnerTabForm, layer=IPyAMSLayer)

   109 class SharedContentInnerPageHeaderContentProvider(object):

   110     """Inner page header content provider"""

   111 

   112     def update(self):

   113         pass

   114 

   115     def render(self):

   116         return ''