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__