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.features.checker.interfaces import IContentChecker, MISSING_VALUE, MISSING_LANG_VALUE, ERROR_VALUE

    20 from pyams_content.shared.logo.interfaces import ILogosParagraph

    21 from pyams_i18n.interfaces import II18nManager, INegotiator, II18n

    22 from pyams_workflow.interfaces import IWorkflow, IWorkflowState

    23 

    24 # import packages

    25 from pyams_content.component.paragraph import BaseParagraph, IParagraphFactory, BaseParagraphFactory, \

    26     BaseParagraphContentChecker

    27 from pyams_sequence.utility import get_reference_target

    28 from pyams_utils.adapter import adapter_config

    29 from pyams_utils.registry import utility_config, get_utility

    30 from pyams_utils.traversing import get_parent

    31 from zope.interface import implementer

    32 from zope.schema.fieldproperty import FieldProperty

    33 

    34 from pyams_content import _

    35 

    36 

    37 @implementer(ILogosParagraph)

    38 class LogosParagraph(BaseParagraph):

    39     """Logos paragraph"""

    40 

    41     icon_class = 'fa-th-large'

    42     icon_hint = _("Logos")

    43 

    44     references = FieldProperty(ILogosParagraph['references'])

    45 

    46     def get_targets(self, state=None, with_reference=False):

    47         for reference in self.references or ():

    48             if with_reference:

    49                 yield reference, get_reference_target(reference, state)

    50             else:

    51                 yield get_reference_target(reference, state)

    52 

    53 

    54 @utility_config(name='Logos', provides=IParagraphFactory)

    55 class LogosParagraphFactory(BaseParagraphFactory):

    56     """Logos paragraph factory"""

    57 

    58     name = _("Logos")

    59     content_type = LogosParagraph

    60 

    61 

    62 @adapter_config(context=ILogosParagraph, provides=IContentChecker)

    63 class LogosParagraphContentChecker(BaseParagraphContentChecker):

    64     """Logos paragraph content checker"""

    65 

    66     def inner_check(self, request):

    67         output = []

    68         translate = request.localizer.translate

    69         manager = get_parent(self.context, II18nManager)

    70         if manager is not None:

    71             langs = manager.get_languages()

    72         else:

    73             negotiator = get_utility(INegotiator)

    74             langs = (negotiator.server_language, )

    75         i18n = II18n(self.context)

    76         for lang in langs:

    77             value = i18n.get_attribute('title', lang, request)

    78             if not value:

    79                 field_title = translate(ILogosParagraph['title'].title)

    80                 if len(langs) == 1:

    81                     output.append(translate(MISSING_VALUE).format(field=field_title))

    82                 else:

    83                     output.append(translate(MISSING_LANG_VALUE).format(field=field_title, lang=lang))

    84         field_title = translate(ILogosParagraph['references'].title)

    85         if not self.context.references:

    86             output.append(translate(ERROR_VALUE).format(

    87                 field=field_title,

    88                 message=translate(_("no selected logo"))))

    89         else:

    90             for reference, target in self.context.get_targets(with_reference=True):

    91                 if target is None:

    92                     output.append(translate(ERROR_VALUE).format(

    93                         field=field_title,

    94                         message=translate(_("logo '{0}' can't be found")).format(reference)))

    95                 else:

    96                     workflow = IWorkflow(target, None)

    97                     if workflow is not None:

    98                         workflow_state = IWorkflowState(target)

    99                         if workflow_state.state not in workflow.published_states:

   100                             output.append(translate(ERROR_VALUE).format(

   101                                 field=field_title,

   102                                 message=translate(_("logo '{0}' is not published")).format(

   103                                     II18n(target).query_attribute('title', request=request))))

   104         return output