class EditForm(GrokkedForm, z3c.form.form.EditForm):
"""A standard edit form
"""
martian.baseclass()
@z3c.form.button.buttonAndHandler(_(u'Save'), name='save')
def handleApply(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
self.applyChanges(data)
IStatusMessage(self.request).addStatusMessage(_(u"Changes saved"),
"info")
self.request.response.redirect(self.context.absolute_url())
@z3c.form.button.buttonAndHandler(_(u'Cancel'), name='cancel')
def handleCancel(self, action):
IStatusMessage(self.request).addStatusMessage(_(u"Edit cancelled"),
"info")
self.request.response.redirect(self.context.absolute_url())
def updateActions(self):
super(EditForm, self).updateActions()
self.actions["save"].addClass("context")
self.actions["cancel"].addClass("standalone")
class JsonView(BaseJsonView):
martian.baseclass()
grok.layer(ICMSAPISkinLayer)
_security_manager = None
def has_permission(self, permission, context=None):
if context is None:
context = self.context
if self._security_manager is None:
self._security_manager = getSecurityManager()
return self._security_manager.checkPermission(permission, context)
def update_object(self, attributes, schema, context=None, input=None):
if context is None:
context = self.context
if input is None:
input = self.input
permissions = get_write_permissions(schema)
try:
for (field, attribute, getter) in attributes:
value = getter(input, field)
if value is None:
continue
ztk_permission = permissions.get(attribute, None)
if ztk_permission is not None:
permission = getUtility(IPermission, name=ztk_permission).title
else:
permission = ModifyPortalContent
if not self.has_permission(permission, context):
raise Unauthorized()
schema[attribute].validate(value)
setattr(context, attribute, value)
except Invalid as e:
raise ValueError(str(e))
class EditForm(GrokForm, formbase.EditForm, View):
martian.baseclass()
template = default_form_template
# grokcore.formlib defines empty actions since 1.1. Restore save
# option here.
actions = formbase.EditForm.actions
class WizardForm(GrokForm, wizard.Wizard, grokcore.view.View):
"""Base Class for a z3c.wizdard.
"""
martian.baseclass()
def update(self):
self.updateForm()
class JsonView(BaseJsonView):
martian.baseclass()
grok.layer(IClientAPISkinLayer)
phase = 'identification'
previous_phase = None
next_phase = None
question_filter = None
check_update = False
def _step(self, info, key, finder, next_phase=None):
node = finder(self.context, self.request.survey_session,
self.question_filter)
if node is not None:
info[key] = '%s/%s/%s' % \
(self.request.survey_session.absolute_url(),
'/'.join(node.short_path), self.phase)
elif next_phase:
info[key] = '%s/%s' % \
(self.request.survey_session.absolute_url(),
next_phase)
def __call__(self):
if self.check_update and wasSurveyUpdated(
self.request.survey_session, self.request.survey):
url = '%s/update' % self.request.survey_session.absolute_url()
self.response.setHeader('Content-Type', 'application/json')
return json.dumps(
{'type': 'update',
'next-step': url})
return super(JsonView, self).__call__()
class ViewletManager(BaseViewletManager, ZopeTwoBaseViewletManager):
martian.baseclass()
def filter(self, viewlets):
# XXX Need Zope 2 filter
return ZopeTwoBaseViewletManager.filter(self, viewlets)
def __getitem__(self, key):
# XXX Need Zope 2 __getitem__
return ZopeTwoBaseViewletManager.__getitem__(self, key)
class TranslatedTitleEditForm(EditForm, TranslatedTitleFormMixin):
martian.baseclass()
def updateFields(self):
super(EditForm, self).updateFields()
self.omit_non_active_language_fields()
def updateWidgets(self):
super(EditForm, self).updateWidgets()
self.adjust_title_on_language_fields()
class View(grokcore.view.View):
martian.baseclass()
def __init__(self, context, request):
super(View, self).__init__(context, request)
if self.static is not None:
# Set parent so that we have an acquisition chain
self.static.__parent__ = context
def redirect(self, url, status=302, trusted=False):
""" We don't need trusted in Zope2 """
self.request.response.redirect(url, status=status)
class ExtBaseModel(object):
""" Base model for all model used in extjs.
All model inherit form this class will automatically grokked.
You will know what a grokker is? So read: https://pypi.python.org/pypi/martian
"""
martian.baseclass()
def instance(self):
""" return new object of same class
"""
return self.__class__()
class PersistentTile(GrokkedTile, plone.tiles.PersistentTile):
"""Grokked persistent tile. This uses the same logic as a groked view, but
supports additional directives and provides the ``data`` attribute found
in ``plone.tiles.Tile``.
"""
martian.baseclass()
# Make sure this interface is more specific than the ones from the view
five.grok.implementsOnly(plone.tiles.interfaces.IPersistentTile)
# Take these from the tile class instead of grok.View
__getitem__ = plone.tiles.PersistentTile.__getitem__
url = plone.tiles.PersistentTile.url
class JsonView(grok.View):
"""Generic base class for JSON views.
This class does two things:
1. it renders the result as JSON
2. if a request has a body it will try to JSON-parse it and
store the result as ``self.input``.
"""
martian.baseclass()
grok.layer(IAPISkinLayer)
input = None
def render(self):
# Workaround for grok silliness
pass
def do_OPTIONS(self):
methods = [name[3:] for name in dir(self) if name.startswith('do_')]
self.response.setHeader('Allow', ','.join(sorted(methods)))
return None
def __call__(self):
input = self.request.stdin.getvalue()
if input:
try:
self.input = json.loads(input)
except ValueError:
self.response.setHeader('Content-Type', 'application/json')
return json.dumps({
'type': 'error',
'message': 'Invalid JSON input'
})
mapply(self.update, (), self.request)
if self.response.getStatus() in [302, 303]:
return # Shortcircuit on redirect, no need to render
self.response.setHeader('Content-Type', 'application/json')
method = self.request.get('REQUEST_METHOD', 'GET').upper()
renderer = getattr(self, 'do_%s' % method, None)
if renderer is None:
log.info('Invalid HTTP method %s attempted for %s', method,
'/'.join(self.context.getPhysicalPath()))
self.response.setStatus(405)
response = {'type': 'error', 'message': 'HTTP method not allowed'}
else:
response = mapply(renderer, (), self.request)
return json.dumps(response)
class AddForm(GrokkedForm, z3c.form.form.AddForm):
"""A standard add form.
"""
martian.baseclass()
immediate_view = None
def __init__(self, context, request):
super(AddForm, self).__init__(context, request)
self.request['disable_border'] = True
def render(self):
if self._finishedAdd:
self.request.response.redirect(self.nextURL())
return ""
return super(AddForm, self).render()
def nextURL(self):
if self.immediate_view is not None:
return self.immediate_view
else:
return self.context.absolute_url()
# Buttons
@z3c.form.button.buttonAndHandler(_('Save'), name='save')
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
obj = self.createAndAdd(data)
if obj is not None:
# mark only as finished if we get the new object
self._finishedAdd = True
IStatusMessage(self.request).addStatusMessage(
_(u"Changes saved"), "info")
@z3c.form.button.buttonAndHandler(_(u'Cancel'), name='cancel')
def handleCancel(self, action):
IStatusMessage(self.request).addStatusMessage(
_(u"Add New Item operation cancelled"), "info")
self.request.response.redirect(self.nextURL())
def updateActions(self):
super(AddForm, self).updateActions()
self.actions["save"].addClass("context")
self.actions["cancel"].addClass("standalone")
class DisplayForm(view.DefaultView, five.grok.View):
"""Base class for grokked display forms
"""
martian.baseclass()
def __init__(self, context, request):
view.DefaultView.__init__(self, context, request)
five.grok.View.__init__(self, context, request)
def render(self):
template = getattr(self, 'template', None)
if template is not None:
return self.template.render(self)
return zope.publisher.publish.mapply(self.render, (), self.request)
render.base_method = True
class DisplayForm(plone.autoform.view.WidgetsView, five.grok.View):
"""A view that knows about field widgets, but otherwise has all the
goodness of a grok.View, including automatic templates.
"""
martian.baseclass()
def __init__(self, context, request):
plone.autoform.view.WidgetsView.__init__(self, context, request)
five.grok.View.__init__(self, context, request)
def render(self):
template = getattr(self, 'template', None)
if template is not None:
return self.template.render(self)
return super(DisplayForm, self).render()
render.base_method = False
class ApplicationContext(GlobalUtility):
""" Represent a ExtJs Application. This is abstract
class and need to subclass in your project.
"""
baseclass()
name(DEFAULT_EXTJS_APPLICATION)
credentials_pluggins = ()
authentication_pluggins = ()
def __init__(self):
super(ApplicationContext, self).__init__()
self._sitemanager = LocalComponentsRegistry(self.application)
def getSiteManager(self):
return self._sitemanager
def setSiteManager(self, sitemanager):
self._sitemanager = sitemanager
class TemplateGrokker(martian.ClassGrokker):
martian.baseclass()
_template_order = sys.maxint / 2
def grok(self, name, factory, module_info, **kw):
# Need to store the module info to look for a template
factory.module_info = module_info
return super(TemplateGrokker, self).grok(name, factory, module_info,
**kw)
def execute(self, factory, config, **kw):
# Associate templates to a view or a component. We set the
# configuration action order to a number quite high, to do it
# after all templates have be registered to the shared template
# registry, and yet before unassociated templates are checked.
config.action(discriminator=None,
callable=self.associate_template,
args=(factory.module_info, factory),
order=self._template_order)
# We increase _template_order to maintain the relative order of
# template association between the different Grok extensions
# (like an implicit template can be inherited between two
# different Grok extensions).
self._template_order += 1
return True
def associate_template(self, module_info, factory):
component_name = martian.component.bind().get(self).__name__.lower()
templatereg.associate_template(module_info, factory, component_name,
self.has_render, self.has_no_render)
def has_render(self, factory):
render = getattr(factory, 'render', None)
base_method = getattr(render, 'base_method', False)
return render and not base_method
def has_no_render(self, factory):
return not self.has_render(factory)
class AddForm(GrokkedDexterityForm, add.DefaultAddForm):
"""Base class for grokked add forms
"""
martian.baseclass()
def __init__(self, context, request, ti=None):
super(AddForm, self).__init__(context, request)
if ti is not None:
self.ti = ti
self.portal_type = ti.getId()
def __of__(self, context):
# compatibility with CMFCore which tries to wrap the add view
return self
def render(self):
if self._finishedAdd:
self.request.response.redirect(self.nextURL())
return ""
return super(AddForm, self).render()
render.base_method = True
class Alpha(object):
martian.baseclass()
class GrokkedTile(five.grok.View):
"""Base class for grokked tiles - not to be used directly.
"""
martian.baseclass()
class Form(GrokkedForm, z3c.form.form.Form):
"""A basic form.
"""
martian.baseclass()
class EditForm(GrokkedDexterityForm, edit.DefaultEditForm):
"""Base class for grokked edit forms
"""
martian.baseclass()
class SchemaForm(plone.autoform.form.AutoExtensibleForm, Form):
"""A basic extensible form
"""
martian.baseclass()
schema = None # Must be set by subclass
class DisplayForm(GrokForm, formbase.DisplayForm, View):
martian.baseclass()
template = default_display_template
class SchemaAddForm(plone.autoform.form.AutoExtensibleForm, AddForm):
"""An extensible add form.
"""
martian.baseclass()
schema = None # Must be set by subclass
class AddForm(GrokForm, formbase.AddForm, View):
martian.baseclass()
template = default_form_template
class SchemaEditForm(plone.autoform.form.AutoExtensibleForm, EditForm):
"""An extensible edit form
"""
martian.baseclass()
schema = None # Must be set by subclass
class GrokkedForm(object):
"""Mixin class for all grokked forms, which provides grok.View-like
semantics for template association, static resources, etc.
Do not use directly.
"""
martian.baseclass()
# Emulate grokcore.view.View
def __init__(self, context, request):
super(GrokkedForm, self).__init__(context, request)
# Set the view __name__
self.__name__ = getattr(self, '__view_name__', None)
# Set up the view.static resource directory reference
if getattr(self, 'module_info', None) is not None:
self.static = zope.component.queryAdapter(
self.request,
zope.interface.Interface,
name=self.module_info.package_dotted_name)
else:
self.static = None
def render(self):
# Render a grok-style templat if we have one
if (getattr(self, 'template') and
grokcore.view.interfaces.ITemplate.providedBy(self.template)):
return self._render_template()
else:
return super(GrokkedForm, self).render()
render.base_method = True
@property
def response(self):
return self.request.response
def _render_template(self):
return self.template.render(self)
def default_namespace(self):
namespace = {}
namespace['context'] = self.context
namespace['request'] = self.request
namespace['static'] = self.static
namespace['view'] = self
return namespace
def namespace(self):
return {}
def url(self, obj=None, name=None, data=None):
"""Return string for the URL based on the obj and name. The data
argument is used to form a CGI query string.
"""
if isinstance(obj, basestring):
if name is not None:
raise TypeError(
'url() takes either obj argument, obj, string arguments, '
'or string argument')
name = obj
obj = None
if name is None and obj is None:
# create URL to view itself
obj = self
elif name is not None and obj is None:
# create URL to view on context
obj = self.context
if data is None:
data = {}
else:
if not isinstance(data, dict):
raise TypeError('url() data argument must be a dict.')
return grokcore.view.util.url(self.request, obj, name, data=data)
def redirect(self, url):
return self.request.response.redirect(url)
# BBB: makes the form have the most important properties that were
# exposed by the wrapper view
@property
def form_instance(self):
return self
@property
def form(self):
return self.__class__