1 #

     2 # Copyright (c) 2008-2018 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.footer.interfaces import IFooterTarget, IFooterSettings, IFooterRenderer, \

    20     IFooterRendererSettings

    21 from pyams_form.interfaces.form import IWidgetForm, IUncheckedEditFormButtons, IInnerSubForm, \

    22     IWidgetsSuffixViewletsManager

    23 from pyams_portal.interfaces import MANAGE_TEMPLATE_PERMISSION

    24 from pyams_portal.zmi.interfaces import IPortalContextTemplatePropertiesMenu

    25 from pyams_skin.interfaces import IInnerPage

    26 from pyams_skin.layer import IPyAMSLayer

    27 from pyams_utils.interfaces.data import IObjectData

    28 from pyams_utils.interfaces.inherit import IInheritInfo

    29 from z3c.form.interfaces import INPUT_MODE

    30 

    31 # import packages

    32 from pyams_form.form import AJAXEditForm

    33 from pyams_form.group import NamedWidgetsGroup

    34 from pyams_pagelet.pagelet import pagelet_config

    35 from pyams_skin.viewlet.menu import MenuItem, MenuDivider

    36 from pyams_template.template import template_config

    37 from pyams_utils.adapter import adapter_config

    38 from pyams_utils.url import absolute_url

    39 from pyams_viewlet.viewlet import viewlet_config, Viewlet

    40 from pyams_zmi.form import AdminEditForm, InnerAdminEditForm

    41 from pyramid.exceptions import NotFound

    42 from pyramid.response import Response

    43 from pyramid.view import view_config

    44 from z3c.form import field, button

    45 from z3c.form.browser.checkbox import SingleCheckBoxFieldWidget

    46 from zope.interface import implementer, alsoProvides, Interface

    47 

    48 from pyams_content import _

    49 

    50 

    51 @viewlet_config(name='footer-settings.menu', context=IFooterTarget, layer=IPyAMSLayer,

    52                 manager=IPortalContextTemplatePropertiesMenu, permission=MANAGE_TEMPLATE_PERMISSION, weight=102)

    53 class FooterSettingsMenu(MenuItem):

    54     """Footer settings menu"""

    55 

    56     label = _("Page footer")

    57     url = '#footer-settings.html'

    58 

    59 

    60 class IFooterSettingsGroup(Interface):

    61     """Footer settings group marker interface"""

    62 

    63 

    64 @pagelet_config(name='footer-settings.html', context=IFooterTarget, layer=IPyAMSLayer,

    65                 permission=MANAGE_TEMPLATE_PERMISSION)

    66 @implementer(IWidgetForm, IInnerPage)

    67 class FooterSettingsEditForm(AdminEditForm):

    68     """Footer settings edit form"""

    69 

    70     @property

    71     def title(self):

    72         return self.context.title

    73 

    74     legend = _("Edit footer settings")

    75 

    76     def getContent(self):

    77         return IFooterSettings(self.context)

    78 

    79     @property

    80     def fields(self):

    81         if self.getContent().can_inherit:

    82             fields = field.Fields(IFooterSettings).select('no_inherit')

    83             fields['no_inherit'].widgetFactory = SingleCheckBoxFieldWidget

    84         else:

    85             fields = field.Fields(Interface)

    86         return fields

    87 

    88     @property

    89     def buttons(self):

    90         if self.mode == INPUT_MODE:

    91             return button.Buttons(IUncheckedEditFormButtons)

    92         else:

    93             return button.Buttons(Interface)

    94 

    95     ajax_handler = 'footer-settings.json'

    96 

    97     def updateGroups(self):

    98         if self.getContent().can_inherit:

    99             group = NamedWidgetsGroup(self, 'footer', self.widgets,

   100                                       ('no_inherit', ),

   101                                       legend=_("Don't inherit parent footer"),

   102                                       css_class='inner',

   103                                       switch=True,

   104                                       checkbox_switch=True,

   105                                       checkbox_mode='disable',

   106                                       checkbox_field=IFooterSettings['no_inherit'])

   107         else:

   108             group = NamedWidgetsGroup(self, 'footer', self.widgets, (), css_class='inner')

   109         alsoProvides(group, IFooterSettingsGroup)

   110         self.add_group(group)

   111         super(FooterSettingsEditForm, self).updateGroups()

   112 

   113 

   114 @view_config(name='footer-settings.json', context=IFooterTarget, request_type=IPyAMSLayer,

   115              permission=MANAGE_TEMPLATE_PERMISSION, renderer='json', xhr=True)

   116 class FooterSettingsAJAXEditForm(AJAXEditForm, FooterSettingsEditForm):

   117     """Footer settings edit form, JSON renderer"""

   118 

   119     def get_ajax_output(self, changes):

   120         output = super(FooterSettingsAJAXEditForm, self).get_ajax_output(changes) or {}

   121         if 'no_inherit' in changes.get(IInheritInfo, ()):

   122             output['status'] = 'reload'

   123         return output

   124 

   125 

   126 @adapter_config(name='renderer', context=(IFooterTarget, IPyAMSLayer, IFooterSettingsGroup), provides=IInnerSubForm)

   127 class FooterSettingsRendererEditSubform(InnerAdminEditForm):

   128     """Footer settings renderer edit form"""

   129 

   130     legend = None

   131 

   132     fields = field.Fields(IFooterSettings).select('renderer')

   133     weight = 1

   134 

   135     def __init__(self, context, request, group):

   136         context = IFooterSettings(context)

   137         super(FooterSettingsRendererEditSubform, self).__init__(context, request, group)

   138 

   139     def updateWidgets(self, prefix=None):

   140         super(FooterSettingsRendererEditSubform, self).updateWidgets(prefix)

   141         if 'renderer' in self.widgets:

   142             widget = self.widgets['renderer']

   143             widget.object_data = {

   144                 'ams-change-handler': 'MyAMS.helpers.select2ChangeHelper',

   145                 'ams-change-stop-propagation': 'true',

   146                 'ams-select2-helper-type': 'html',

   147                 'ams-select2-helper-url': absolute_url(self.context, self.request,

   148                                                        'get-footer-settings-renderer-form.html'),

   149                 'ams-select2-helper-argument': 'form.widgets.renderer',

   150                 'ams-select2-helper-target': '#renderer-settings-helper'

   151             }

   152             alsoProvides(widget, IObjectData)

   153 

   154     def get_forms(self, include_self=True):

   155         if include_self and self.request.method == 'POST':

   156             data, errors = self.extractData()

   157             if not errors:

   158                 self.applyChanges(data)

   159         for form in super(FooterSettingsRendererEditSubform, self).get_forms(include_self):

   160             yield form

   161 

   162 

   163 @adapter_config(name='footer-renderer-settings-form',

   164                 context=(IFooterRendererSettings, IPyAMSLayer, FooterSettingsRendererEditSubform),

   165                 provides=IInnerSubForm)

   166 @adapter_config(name='footer-renderer-settings-form',

   167                 context=(IFooterTarget, IPyAMSLayer, FooterSettingsAJAXEditForm),

   168                 provides=IInnerSubForm)

   169 class FooterSettingsRendererSettingsEditForm(InnerAdminEditForm):

   170     """Footer settings renderer settings edit form"""

   171 

   172     legend = _("Footer renderer settings")

   173 

   174     def __new__(cls, context, request, view=None):

   175         settings = IFooterRendererSettings(context, None)

   176         if settings is None:

   177             return None

   178         return InnerAdminEditForm.__new__(cls)

   179 

   180     def __init__(self, context, request, view=None):

   181         context = IFooterRendererSettings(context)

   182         super(FooterSettingsRendererSettingsEditForm, self).__init__(context, request, view)

   183 

   184 

   185 @viewlet_config(name='footer-renderer-settings', context=IFooterSettings, layer=IPyAMSLayer,

   186                 view=FooterSettingsRendererEditSubform, manager=IWidgetsSuffixViewletsManager)

   187 @template_config(template='templates/renderer-settings.pt', layer=IPyAMSLayer)

   188 class FooterSettingsRendererSettingsWidgetsSuffix(Viewlet):

   189     """Footer settings renderer settings viewlet"""

   190 

   191     def render_edit_form(self):

   192         settings = IFooterSettings(self.context)

   193         renderer = settings.get_renderer(self.request)

   194         if (renderer is None) or (renderer.settings_interface is None):

   195             return ''

   196         renderer_settings = IFooterRendererSettings(settings)

   197         form = FooterSettingsRendererSettingsEditForm(renderer_settings, self.request)

   198         form.update()

   199         return form.render()

   200 

   201 

   202 @view_config(name='get-footer-settings-renderer-form.html', context=IFooterSettings,

   203              request_type=IPyAMSLayer, permission=MANAGE_TEMPLATE_PERMISSION, xhr=True)

   204 def get_footer_settings_renderer_form(request):

   205     """Footer settings renderer settings form"""

   206     renderer_name = request.params.get('form.widgets.renderer')

   207     if renderer_name is None:

   208         raise NotFound("No provided renderer argument")

   209     if not renderer_name:

   210         renderer_name = ''

   211     renderer = request.registry.queryMultiAdapter((request.context, request), IFooterRenderer, name=renderer_name)

   212     if (renderer is None) or (renderer.settings_interface is None):

   213         return Response('')

   214     settings = IFooterSettings(request.context)

   215     renderer_settings = IFooterRendererSettings(settings)

   216     form = FooterSettingsRendererSettingsEditForm(renderer_settings, request)

   217     form.update()

   218     return Response(form.render())