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 ajax_config

    33 from pyams_form.group import NamedWidgetsGroup

    34 from pyams_pagelet.pagelet import pagelet_config

    35 from pyams_skin.viewlet.menu import MenuItem

    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 @ajax_config(name='footer-settings.json', context=IFooterTarget, layer=IPyAMSLayer,

    67              permission=MANAGE_TEMPLATE_PERMISSION)

    68 @implementer(IWidgetForm, IInnerPage)

    69 class FooterSettingsEditForm(AdminEditForm):

    70     """Footer settings edit form"""

    71 

    72     @property

    73     def title(self):

    74         return self.context.title

    75 

    76     legend = _("Edit footer settings")

    77 

    78     def getContent(self):

    79         return IFooterSettings(self.context)

    80 

    81     @property

    82     def fields(self):

    83         if self.getContent().can_inherit:

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

    85             fields['no_inherit'].widgetFactory = SingleCheckBoxFieldWidget

    86         else:

    87             fields = field.Fields(Interface)

    88         return fields

    89 

    90     @property

    91     def buttons(self):

    92         if self.mode == INPUT_MODE:

    93             return button.Buttons(IUncheckedEditFormButtons)

    94         else:

    95             return button.Buttons(Interface)

    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     def get_ajax_output(self, changes):

   114         output = super(self.__class__, self).get_ajax_output(changes) or {}

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

   116             output['status'] = 'reload'

   117         return output

   118 

   119 

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

   121 class FooterSettingsRendererEditSubform(InnerAdminEditForm):

   122     """Footer settings renderer edit form"""

   123 

   124     legend = None

   125 

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

   127     weight = 1

   128 

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

   130         context = IFooterSettings(context)

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

   132 

   133     def updateWidgets(self, prefix=None):

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

   135         if 'renderer' in self.widgets:

   136             widget = self.widgets['renderer']

   137             widget.object_data = {

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

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

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

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

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

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

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

   145             }

   146             alsoProvides(widget, IObjectData)

   147 

   148     def get_forms(self, include_self=True):

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

   150             data, errors = self.extractData()

   151             if not errors:

   152                 self.applyChanges(data)

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

   154             yield form

   155 

   156 

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

   158                 context=(IFooterRendererSettings, IPyAMSLayer, FooterSettingsRendererEditSubform),

   159                 provides=IInnerSubForm)

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

   161 #                 context=(IFooterTarget, IPyAMSLayer, FooterSettingsEditForm),

   162 #                 provides=IInnerSubForm)

   163 class FooterSettingsRendererSettingsEditForm(InnerAdminEditForm):

   164     """Footer settings renderer settings edit form"""

   165 

   166     legend = _("Footer renderer settings")

   167 

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

   169         settings = IFooterRendererSettings(context, None)

   170         if settings is None:

   171             return None

   172         return InnerAdminEditForm.__new__(cls)

   173 

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

   175         context = IFooterRendererSettings(context)

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

   177 

   178 

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

   180                 view=FooterSettingsRendererEditSubform, manager=IWidgetsSuffixViewletsManager)

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

   182 class FooterSettingsRendererSettingsWidgetsSuffix(Viewlet):

   183     """Footer settings renderer settings viewlet"""

   184 

   185     def render_edit_form(self):

   186         settings = IFooterSettings(self.context)

   187         renderer = settings.get_renderer(self.request)

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

   189             return ''

   190         renderer_settings = IFooterRendererSettings(settings)

   191         form = FooterSettingsRendererSettingsEditForm(renderer_settings, self.request)

   192         form.update()

   193         return form.render()

   194 

   195 

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

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

   198 def get_footer_settings_renderer_form(request):

   199     """Footer settings renderer settings form"""

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

   201     if renderer_name is None:

   202         raise NotFound("No provided renderer argument")

   203     if not renderer_name:

   204         renderer_name = ''

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

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

   207         return Response('')

   208     settings = IFooterSettings(request.context)

   209     renderer_settings = IFooterRendererSettings(settings)

   210     form = FooterSettingsRendererSettingsEditForm(renderer_settings, request)

   211     form.update()

   212     return Response(form.render())