def setup_form(self):
self.buttons = button.Buttons()
self.handlers = button.Handlers()
if self.form_type() == 'addform':
preview = button.Button(title=_(u'Continue'), name='save')
self.buttons += button.Buttons(preview)
preview_handler = button.Handler(preview,
self.__class__.handle_preview)
self.handlers.addHandler(preview, preview_handler)
self.ignoreContext = True
self.ignoreReadonly = True
else:
update = button.Button(title=_(u'Continue'), name='save')
self.buttons += button.Buttons(update)
update_handler = button.Handler(update,
self.__class__.handle_update)
self.handlers.addHandler(update, update_handler)
self.context = self.event
cancel = button.Button(title=_(u'Cancel'), name='cancel')
self.buttons += button.Buttons(cancel)
cancel_handler = button.Handler(cancel, self.__class__.handle_cancel)
self.handlers.addHandler(cancel, cancel_handler)
def updateActions(self):
btn = button.Button(name='save', title=_(u'Save'))
self.buttons += button.Buttons(btn)
self.handlers.addHandler(btn, self.handleApply)
if ISaveAndActionButtons.providedBy(self.context):
append_action_buttons(self)
if ICancelButton.providedBy(self.context):
btn = button.Button(name='cancel', title=_(u'Cancel'))
self.buttons += button.Buttons(btn)
self.handlers.addHandler(btn, self.handleCancel)
super(SubmissionEditForm, self).updateActions()
def extends(*args, **kwargs):
frame = sys._getframe(1)
f_locals = frame.f_locals
if not kwargs.get('ignoreFields', False):
f_locals['fields'] = field.Fields()
for arg in args:
f_locals['fields'] += getattr(arg, 'fields', field.Fields())
if not kwargs.get('ignoreHandlers', False):
f_locals['buttons'] = button.Buttons()
for arg in args:
f_locals['buttons'] += getattr(arg, 'buttons', button.Buttons())
if not kwargs.get('ignoreHandlers', False):
f_locals['handlers'] = button.Handlers()
for arg in args:
f_locals['handlers'] += getattr(arg, 'handlers', button.Handlers())
class SchemaView(DefaultEditForm):
buttons = button.Buttons()
def label(self):
return self.context.title
def description(self):
return self.context.description
@property
@view.memoize
def schema(self):
language = negotiate(context=self.request) or u''
try:
return load_schema(
aq_base(self.context).schema,
language=language,
cache_key=aq_base(self.context).schema_digest,
)
except AttributeError:
self.request.response.redirect(
'{0:s}/@@design'.format(self.context.absolute_url()), )
return load_schema(DEFAULT_SCHEMA, cache_key=None)
additionalSchemata = ()
class ButtonForm(layout.FormLayoutSupport, form.Form):
buttons = button.Buttons(IButtons)
fields = field.Fields(IFields)
@jsevent.handler(buttons['show'])
def apply(self, id):
return '$("#javascript").slideDown()'
@jsevent.handler(buttons['hide'])
def apply(self, id):
return '$("#javascript").slideUp()'
@jsevent.handler(fields['file'], event=jsevent.CHANGE)
def handleFileChange(self, id):
return '''
$(".code").hide();
$("#"+$("#%s").val().replace(".","-")).show();''' % id
def updateWidgets(self):
'''See interfaces.IForm'''
self.widgets = zope.component.getMultiAdapter(
(self, self.request, self.getContent()), IWidgets)
self.widgets.ignoreContext = True
self.widgets.update()
def getFile(self, filename):
here = os.path.dirname(os.path.abspath(__file__))
f = open(os.path.join(here, filename), 'r')
data = f.read()
f.close()
return data
class PopulateForm(ExtensibleForm, form.Form):
ignoreContext = True
fields = field.Fields(IPopulateFormSchema)
buttons = button.Buttons(IPopulateFormButtons)
def updateFields(self):
super(PopulateForm, self).updateFields()
self.fields['formatting'].widgetFactory = CheckBoxFieldWidget
context = aq_inner(self.context)
if shasattr(context, 'getLocallyAllowedTypes'):
self.fields['portal_type'].field.default = \
list(context.getLocallyAllowedTypes())
elif shasattr(context, 'allowedContentTypes'):
self.fields['portal_type'].field.default = \
[t.id for t in context.allowedContentTypes()]
@button.handler(IPopulateFormButtons['create'])
def create(self, action):
data, errors = self.extractData()
if errors:
self.status = '\n'.join([
error.error.__str__() for error in errors])
return
context = aq_inner(self.context)
total = create_subobjects(context, context, data, 0)
addStatusMessage(
self.request,
_(u'Successfully created %d dummy objects.') % total,
type='info')
self.request.response.redirect(self.context.REQUEST.get('URL'))
class ReadOnlySchemaListing(SchemaListing):
buttons = button.Buttons()
def edit_url(self, field):
return
delete_url = edit_url
def create_buttons(self, schema):
return button.Buttons(
*[
GeneratedButton(str(e["id"]), title=e["title"])
for e in schema.get("actions", [])
]
)
class Form(BaseForm):
"""The Form."""
buttons = button.Buttons()
method = FieldProperty(interfaces.IInputForm['method'])
enctype = FieldProperty(interfaces.IInputForm['enctype'])
acceptCharset = FieldProperty(interfaces.IInputForm['acceptCharset'])
accept = FieldProperty(interfaces.IInputForm['accept'])
actions = FieldProperty(interfaces.IActionForm['actions'])
refreshActions = FieldProperty(interfaces.IActionForm['refreshActions'])
# common string for use in validation status messages
formErrorsMessage = _('There were some errors.')
@property
def action(self):
"""See interfaces.IInputForm"""
return self.request.getURL()
@property
def name(self):
"""See interfaces.IInputForm"""
return self.prefix.strip('.')
@property
def id(self):
return self.name.replace('.', '-')
def updateActions(self):
self.actions = zope.component.getMultiAdapter(
(self, self.request, self.getContent()), interfaces.IActions)
self.actions.update()
def update(self):
super(Form, self).update()
self.updateActions()
self.actions.execute()
if self.refreshActions:
self.updateActions()
def __call__(self):
self.update()
# Don't render anything if we are doing a redirect
if self.request.response.getStatus() in (
300,
301,
302,
303,
304,
305,
307,
):
return u''
return self.render()
class Add(add.DefaultAddForm):
"""
Add Experiment
"""
template = ViewPageTemplateFile("experiment_add.pt")
extends(view.DefaultView,
ignoreButtons=True)
buttons = button.Buttons(add.DefaultAddForm.buttons['cancel'])
@button.buttonAndHandler(_('Create and start'), name='save')
def handleAdd(self, action):
data, errors = self.extractData()
self.validateAction(data)
if errors:
self.status = self.formErrorsMessage
return
# TODO: this is prob. a bug in base form, because createAndAdd
# does not return the wrapped object.
obj = self.createAndAdd(data)
if obj is None:
# TODO: this is probably an error here?
# object creation/add failed for some reason
return
# get wrapped instance fo new object (see above)
obj = self.context[obj.id]
# mark only as finished if we get the new object
self._finishedAdd = True
IStatusMessage(self.request).addStatusMessage(_(u"Item created"),
"info")
# auto start job here
jt = IJobTracker(obj)
msgtype, msg = jt.start_job(self.request)
if msgtype is not None:
IStatusMessage(self.request).add(msg, type=msgtype)
@button.buttonAndHandler(_('Create'), name='create')
def handleCreate(self, action):
data, errors = self.extractData()
self.validateAction(data)
if errors:
self.status = self.formErrorsMessage
return
# TODO: this is prob. a bug in base form, because createAndAdd
# does not return the wrapped object.
obj = self.createAndAdd(data)
if obj is None:
# TODO: this is probably an error here?
# object creation/add failed for some reason
return
# get wrapped instance fo new object (see above)
obj = self.context[obj.id]
# mark only as finished if we get the new object
self._finishedAdd = True
IStatusMessage(self.request).addStatusMessage(_(u"Item created"),
"info")
def setup_form(self):
self.buttons = button.Buttons()
self.handlers = button.Handlers()
save = button.Button(title=_(u'Save Event'), name='save')
self.buttons += button.Buttons(save)
save_handler = button.Handler(save, self.__class__.handle_save)
self.handlers.addHandler(save, save_handler)
self.event = self.context
cancel = button.Button(title=_(u'Cancel Event Submission'),
name='cancel')
self.buttons += button.Buttons(cancel)
cancel_handler = button.Handler(cancel, self.__class__.handle_cancel)
self.handlers.addHandler(cancel, cancel_handler)
def __init__(self, context, request):
super(SubmissionEditForm, self).__init__(context, request)
language = negotiate(context=request) or u''
context_language = get_navigation_root_language(self.context)
if context_language.startswith(language or context_language):
self._locale_postfix = ''
else:
self._locale_postfix = '_' + language
self.buttons = button.Buttons()
self.handlers = button.Handlers()
class SelectedPeriodsAddView(form.AddForm):
template = ViewPageTemplateFile('templates/selected_periods_add.pt')
fields = field.Fields(ISelectedPeriodsAddForm)
_object_added = None
buttons = button.Buttons(
button.Button('add', title=_('Add')),
button.Button('cancel', title=_('Cancel')))
@property
def owner(self):
return IHaveSchedule(self.context)
@property
def term(self):
return ITerm(self.owner, None)
@button.handler(buttons["add"])
def handleAdd(self, action):
return form.AddForm.handleAdd.func(self, action)
@button.handler(buttons["cancel"])
def handleCancel(self, action):
url = absoluteURL(self.context, self.request)
self.request.response.redirect(url)
def updateActions(self):
super(SelectedPeriodsAddView, self).updateActions()
self.actions['add'].addClass('button-ok')
self.actions['cancel'].addClass('button-cancel')
def create(self, data):
timetable = data['timetable']
schedule = SelectedPeriodsSchedule(
timetable, data['first'], data['last'],
title=timetable.title,
timezone=timetable.timezone)
return schedule
def add(self, schedule):
chooser = INameChooser(self.context)
name = chooser.chooseName('', schedule)
self.context[name] = schedule
self._object_added = schedule
def nextURL(self):
if self._object_added is not None:
return '%s/edit.html' % (
absoluteURL(self._object_added, self.request))
return absoluteURL(self.context, self.request)
def __init__(self, context, request):
super(FlowSubmitForm, self).__init__(context, request)
language = negotiate(context=self.request) or u''
context_language = get_navigation_root_language(self.context)
if context_language.startswith(language or context_language):
self.localized_context = context
else:
proxy = LanguageFieldsProxy(self.context)
proxy._language = language
self.localized_context = proxy
self.buttons = button.Buttons()
self.handlers = button.Handlers()
if 'disable_border' in self.request.form:
del self.request.form['disable_border']
class CalculatorForm(layout.FormLayoutSupport, form.Form):
buttons = button.Buttons(IButtons)
def updateActions(self):
self.actions = GridButtonActions(self, self.request, self.context)
self.actions.update()
@jsevent.handler(Operator)
def handleOperator(self, id):
return '''var operator = $("#operator .value").html();
var newOperator = $("#%s").val();
var current = $("#current .value").html();
var stack = $("#stack .value").html();
if (operator == ""){
stack = current;
operator = newOperator;
} else if(newOperator == "="){
current = eval(stack+operator+current);
stack = "";
operator = "";
} else {
current = eval(stack+operator+current);
stack = current;
}
$("#operator .value").html(operator);
$("#stack .value").html(stack);
$("#recentOperator .value").html("True");
$("#current .value").html(current);''' % id
@jsevent.handler(Literal)
def handleLiteral(self, id):
return '''var recentOperator = $("#recentOperator .value").html();
var current = $("#current .value").html();
var number = $("#%s").val();
if (recentOperator != ""){
current = "";
}
current = current+number;
$("#current .value").html(current);
$("#recentOperator .value").html("");
''' % id
@jsevent.handler(buttons['clear'])
def handlerClear(self, id):
return '''$("#stack .value").html("");
def append_action_buttons(form):
# Get currently available workflow actions (re-use from menu)
actions = {}
menu = getUtility(IBrowserMenu, name='plone_contentmenu_workflow')
def lower_first(s):
if s and isinstance(s, unicode) and len(s) > 1:
return s[0].lower() + s[1:]
elif s and isinstance(s, unicode):
return s.lower()
return s
for action in menu.getMenuItems(form.context, form.request):
item_id = action.get('extra', {}).get('id', u'') or u''
action_id = re.sub('^workflow-transition-(.*)', '\\1', item_id)
actions[action_id] = action
for action in ['advanced', 'policy']: # blacklisted menuitems
if action in actions:
del actions[action]
form.buttons = form.buttons.copy()
for action_id, action in actions.iteritems():
new_button = button.Button(
name=re.sub('^workflow-transition-(.*)', '\\1', action_id),
title=u' '.join([
translate(
_(u'Save and'),
context=form.request,
),
lower_first(
translate(
action['title'],
domain='plone',
context=form.request,
),
),
]),
)
form.buttons += button.Buttons(new_button)
form.handlers.addHandler(
new_button,
button.Handler(
new_button,
functools.partial(form.redirect, action['action']),
),
)
class MultiWidget(HTMLFormElement, widget.MultiWidget, FormMixin):
"""Multi widget implementation."""
buttons = button.Buttons()
prefix = 'widget'
klass = u'multi-widget'
css = u'multi'
items = ()
showLabel = True # show labels for item subwidgets or not
# Internal attributes
_adapterValueAttributes = widget.MultiWidget._adapterValueAttributes + \
('showLabel',)
def updateActions(self):
self.updateAllowAddRemove()
if self.name is not None:
self.prefix = self.name
self.actions = zope.component.getMultiAdapter(
(self, self.request, self), interfaces.IActions)
self.actions.update()
def update(self):
"""See z3c.form.interfaces.IWidget."""
super(MultiWidget, self).update()
self.updateActions()
self.actions.execute()
self.updateActions() # Update again, as conditions may change
@button.buttonAndHandler(_('Add'),
name='add',
condition=attrgetter('allowAdding'))
def handleAdd(self, action):
self.appendAddingWidget()
@button.buttonAndHandler(_('Remove selected'),
name='remove',
condition=attrgetter('allowRemoving'))
def handleRemove(self, action):
self.removeWidgets([
widget.name for widget in self.widgets
if ('%s.remove' % (widget.name)) in self.request
])
class EditForm(edit.DefaultEditForm):
""" """
buttons = edit.DefaultEditForm.buttons
preview = button.Buttons(
button.Button('preview', title=u'Save and preview'))
buttons = preview + buttons
buttons['cancel'].title = _(u'Clear unsaved changes')
handlers = edit.DefaultEditForm.handlers
def nextURL(self):
return 'edit'
@button.handler(buttons['preview'])
def handle_preview(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
self.applyChanges(data)
self.request.response.redirect('nuplone-view')
notify(EditFinishedEvent(self.context))
class AllFieldsForm(mars.form.FormView, form.EditForm):
"""A form showing all fields."""
grok.name('widgets')
grok.context(zope.interface.Interface)
form.extends(form.EditForm)
fields = field.Fields(interfaces.IAllFields).omit('dictField',
'objectField')
fields['checkboxBoolField'].widgetFactory = \
checkbox.SingleCheckBoxFieldWidget
buttons = form.EditForm.buttons + \
button.Buttons(
button.ImageButton(name='pressme', image=u'pressme.png')
)
label = 'Widgets Demo'
@button.handler(buttons['pressme'])
def handlePressMe(self, action):
self.status = u'Press me was clicked!'
def getContent(self):
return interfaces.IAllFields(self.context)
def updateWidgets(self):
self.widgets = zope.component.getMultiAdapter(
(self, self.request, self.getContent()), IWidgets)
self.widgets.update()
self.widgets['hiddenField'].mode = HIDDEN_MODE
self.widgets['promptChoiceField'].prompt = True
self.widgets['promptChoiceField'].update()
def __call__(self):
self.update()
layout = zope.component.getMultiAdapter((self, self.request),
ILayoutTemplate)
return layout(self)
class Form(BaseForm):
"""The Form."""
zope.interface.implements(interfaces.IInputForm, interfaces.IButtonForm,
interfaces.IHandlerForm)
buttons = button.Buttons()
method = FieldProperty(interfaces.IInputForm['method'])
enctype = FieldProperty(interfaces.IInputForm['enctype'])
acceptCharset = FieldProperty(interfaces.IInputForm['acceptCharset'])
accept = FieldProperty(interfaces.IInputForm['accept'])
@property
def action(self):
"""See interfaces.IInputForm"""
return self.request.getURL()
@property
def name(self):
"""See interfaces.IInputForm"""
return self.prefix.strip('.')
id = name
def updateActions(self):
self.actions = zope.component.getMultiAdapter(
(self, self.request, self.getContent()), interfaces.IActions)
self.actions.update()
def update(self):
super(Form, self).update()
self.updateActions()
self.actions.execute()
def __call__(self):
self.update()
return self.render()
class FieldsSchemaListing(SchemaListing):
template = ViewPageTemplateFile('fields_listing.pt')
@property
def default_fieldset_label(self):
return (self.context.aq_parent.default_fieldset_label
or super(FieldsSchemaListing, self).default_fieldset_label)
def handleModelEdit(self, action):
self.request.response.redirect('@@modeleditor')
if HAVE_RESOURCE_EDITOR:
but = button.Button("modeleditor", title=_(u'Edit XML Fields Model'))
FieldsSchemaListing.buttons += button.Buttons(but)
handler = button.Handler(but, FieldsSchemaListing.handleModelEdit)
FieldsSchemaListing.handlers.addHandler(but, handler)
class EasyFormFieldsListingPage(SchemaListingPage):
""" Form wrapper so we can get a form with layout.
We define an explicit subclass rather than using the wrap_form method
from plone.z3cform.layout so that we can inject the schema name into
the form label.
"""
form = FieldsSchemaListing
index = ViewPageTemplateFile('model_listing.pt')
class Wizard(form.Form):
"""Wizard form.
The wizard is responsible for manage the steps and offers the wizard menu
navigation and knows the step order. The wizard can check the conditions
given from the steps. The wizard is also responsible for delegate the
back, next and complete actions to the steps.
This IWizard object is modelled as a Controller known from the MVC
(Model, view, controller) patter version 2.0 and the step is implemented as
a view.
"""
buttons = button.Buttons(interfaces.IWizardButtons)
# customize this part if needed
stepInterface = interfaces.IStep
firstStepAsDefault = True
adjustStep = True
confirmationPageName = None
nextURL = None
cssActive = 'selected'
cssInActive = None # None will skip class attribute in DOM element
# for internal use
__name__ = None
steps = None
step = None
@property
def baseURL(self):
return absoluteURL(self, self.request)
def setUpSteps(self):
"""Return a list of steps. This implementation uses IStep adapters.
Take a look at the addStep method defined in step.py. This method
allows you to setup steps directly in the method and offers an API for
customized step setup.
"""
steps = list(
zope.component.getAdapters((self.context, self.request, self),
self.stepInterface))
return [nameStep(step, name) for name, step in steps]
def filterSteps(self, steps):
"""Make sure to only select available steps and we give a name."""
return [step for step in steps if step.available]
def orderSteps(self, steps):
# order steps by it's weight
return sorted(steps, key=lambda step: step.weight)
@property
def steps(self):
steps = self.setUpSteps()
steps = self.filterSteps(steps)
return self.orderSteps(steps)
@property
def completed(self):
for step in self.steps:
if not step.completed:
return False
return True
@property
def isFirstStep(self):
"""See interfaces.IWizard"""
return self.step and self.step.__name__ == self.steps[0].__name__
@property
def isLastStep(self):
"""See interfaces.IWizard"""
return self.step and self.step.__name__ == self.steps[-1].__name__
@property
def showBackButton(self):
"""Ask the step."""
return self.step and self.step.showBackButton
@property
def showNextButton(self):
"""Ask the step."""
return self.step and self.step.showNextButton
@property
def showCompleteButton(self):
"""Ask the step."""
return self.step.showCompleteButton
@property
def previousStepName(self):
if self.step is None:
return
stepNames = [step.__name__ for step in self.steps]
idx = stepNames.index(self.step.__name__)
if idx == 0:
return
return stepNames[idx - 1]
@property
def nextStepName(self):
if self.step is None:
return
stepNames = [step.__name__ for step in self.steps]
idx = stepNames.index(self.step.__name__)
if idx == len(stepNames) - 1:
return
return stepNames[idx + 1]
@property
def stepMenu(self):
items = []
append = items.append
lenght = len(self.steps) - 1
for idx, step in enumerate(self.steps):
firstStep = False
lastStep = False
if step.visible:
isSelected = self.step and self.step.__name__ == step.__name__
cssClass = isSelected and self.cssActive or self.cssInActive
if idx == 0:
firstStep = True
if idx == lenght:
lastStep = True
append({
'name': step.__name__,
'title': step.label,
'number': str(idx + 1),
'url': '%s/%s' % (self.baseURL, step.__name__),
'selected': self.step.__name__ == step.__name__,
'class': cssClass,
'first': firstStep,
'last': lastStep
})
return items
def getDefaultStep(self):
"""Can return the first or first not completed step as default."""
# return first step if this option is set
if self.firstStepAsDefault:
return self.steps[0]
# return first not completed step
for step in self.steps:
if not step.completed:
return step
# fallback to first step if all steps completed
return self.steps[0]
def doAdjustStep(self):
# Make sure all previous steps got completed. If not, redirect to the
# last incomplete step
if not self.adjustStep:
return False
for step in self.steps:
if step.__name__ is self.step.__name__:
break
if not step.completed:
# prepare redirect to not completed step and return True
self.nextURL = '%s/%s' % (self.baseURL, step.__name__)
return True
# or return False
return False
def updateActions(self):
self.actions = WizardButtonActions(self, self.request, self.context)
self.actions.update()
def update(self):
if self.doAdjustStep():
return
self.updateActions()
def publishTraverse(self, request, name):
"""Traverse to step by it's name."""
# Remove HTML ending
if '.' in name:
rawName = name.rsplit('.', 1)[0]
else:
rawName = name
# Find the active step
for step in self.steps:
if step.__name__ == rawName:
self.step = step
return self.step
raise NotFound(self, name, request)
def browserDefault(self, request):
"""The default step is our browserDefault traversal setp."""
if self.step is None:
step = self.getDefaultStep()
# always return default step as default view for our wizard
return self, (step.__name__, )
def goToStep(self, stepName):
self.nextURL = '%s/%s' % (self.baseURL, stepName)
def goToBack(self):
# redirect to next step if previous get sucessfuly processed
self.goToStep(self.previousStepName)
def goToNext(self):
# redirect to next step if previous get sucessfuly processed
self.goToStep(self.nextStepName)
def doBack(self, action):
if self.step.doBack(action):
self.goToBack()
def doNext(self, action):
if self.step.doNext(action):
self.goToNext()
def doComplete(self, action):
if self.step.doComplete(action):
# do finsih after step get completed is completed
self.doFinish()
def doFinish(self):
"""Force redirect after doComplete if confirmationPageName is given."""
if self.confirmationPageName is not None:
self.nextURL = '%s/%s' % (absoluteURL(
self.context, self.request), self.confirmationPageName)
@button.handler(interfaces.IWizardButtons['back'])
def handleBack(self, action):
self.doBack(action)
@button.handler(interfaces.IWizardButtons['next'])
def handleNext(self, action):
self.doNext(action)
@button.handler(interfaces.IWizardButtons['complete'])
def handleComplete(self, action):
self.doComplete(action)
def render(self, *args, **kws):
raise NotImplementedError('render is no supported')
def __repr__(self):
return "<%s '%s'>" % (self.__class__.__name__, self.__name__)
class ActionEditView(layout.FormWrapper):
form = ActionEditForm
def __init__(self, context, request):
super(ActionEditView, self).__init__(context, request)
self.field = context.field
@lazy_property
def label(self):
return _(u"Edit Action '${fieldname}'",
mapping={'fieldname': self.field.__name__})
if HAVE_RESOURCE_EDITOR:
but = button.Button("modeleditor", title=_(u'Edit XML Actions Model'))
EasyFormActionsListing.buttons += button.Buttons(but)
handler = button.Handler(but, EasyFormActionsListing.handleModelEdit)
EasyFormActionsListing.handlers.addHandler(but, handler)
class ModelEditorView(BrowserView):
""" editor view """
title = _(u'Edit XML Actions Model')
def modelSource(self):
return self.context.aq_parent.actions_model
class AjaxSaveHandler(AjaxSaveHandler):
""" handle AJAX save posts """
def save(self, source):
class Add(add.DefaultAddForm):
"""
Add Experiment
"""
template = ViewPageTemplateFile("experiment_add.pt")
extends(view.DefaultView, ignoreButtons=True)
buttons = button.Buttons(add.DefaultAddForm.buttons['cancel'])
@button.buttonAndHandler(_('Create and start'), name='save')
def handleAdd(self, action):
data, errors = self.extractData()
self.validateAction(data)
if errors:
self.status = self.formErrorsMessage
return
# TODO: this is prob. a bug in base form, because createAndAdd
# does not return the wrapped object.
obj = self.createAndAdd(data)
if obj is None:
# TODO: this is probably an error here?
# object creation/add failed for some reason
return
# get wrapped instance fo new object (see above)
obj = self.context[obj.id]
# mark only as finished if we get the new object
self._finishedAdd = True
IStatusMessage(self.request).addStatusMessage(_(u"Item created"),
"info")
# auto start job here
jt = IExperimentJobTracker(obj)
msgtype, msg = jt.start_job(self.request)
if msgtype is not None:
IStatusMessage(self.request).add(msg, type=msgtype)
@button.buttonAndHandler(_('Create'), name='create')
def handleCreate(self, action):
data, errors = self.extractData()
self.validateAction(data)
if errors:
self.status = self.formErrorsMessage
return
# TODO: this is prob. a bug in base form, because createAndAdd
# does not return the wrapped object.
obj = self.createAndAdd(data)
if obj is None:
# TODO: this is probably an error here?
# object creation/add failed for some reason
return
# get wrapped instance fo new object (see above)
obj = self.context[obj.id]
# mark only as finished if we get the new object
self._finishedAdd = True
IStatusMessage(self.request).addStatusMessage(_(u"Item created"),
"info")
def updateWidgets(self):
super(Add, self).updateWidgets()
# Pre-fill widget fields with field values from the specified SDM.
uuid = self.request.get('uuid')
if uuid:
expobj = uuidToObject(uuid)
self.widgets["IDublinCore.title"].value = expobj.title
self.widgets["IDublinCore.description"].value = expobj.description
for name in self.widgets.keys():
if name not in [
"IDublinCore.title", "IDublinCore.description"
]:
conv = getMultiAdapter(
(self.fields[name].field, self.widgets[name]),
IDataConverter)
self.widgets[name].value = conv.toWidgetValue(
getattr(expobj, name))
def update(self):
self.form.buttons = button.Buttons(
self.form.buttons, button.Button('cancel', _(u'Cancel')))
super(CancelActions, self).update()
class ControlPanelEditForm(controlpanel.RegistryEditForm):
schema = IFeedSettings
fields = field.Fields(IControlPanel)
label = _(u"MailChimp settings")
description = _(u"Please configure an API-key and define one or more "
u"feeds.")
fields['urls'].mode = "display"
fields['urls'].widgetFactory = UrlsWidget.factory
fields['lists'].mode = "display"
fields['lists'].widgetFactory = UrlsWidget.factory
if textlines is not None:
fields['feeds'].widgetFactory = textlines.TextLinesFieldWidget
buttons = button.Buttons()
buttons += controlpanel.RegistryEditForm.buttons
handlers = controlpanel.RegistryEditForm.handlers.copy()
def updateActions(self):
# This prevents a redirect to the main control panel page
self.request.response.setStatus(200, lock=True)
super(ControlPanelEditForm, self).updateActions()
def render(self):
if switch_on is not None:
switch_on(self)
urls = self.widgets['urls']
urls.update()
if not urls.value:
del self.widgets['urls']
return super(ControlPanelEditForm, self).render()
def getContent(self):
content = super(ControlPanelEditForm, self).getContent()
return ImplicitAcquisitionWrapper(content, self.context)
@button.buttonAndHandler(_(u"Repair"), name='repair')
def handleRepair(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
query = Indexed('chimpfeeds')
brains = self.context.portal_catalog.evalAdvancedQuery(query)
context = self.getContent()
vocabulary = feeds_factory(context)
all_feeds = set(term.value for term in vocabulary)
count = 0
bad = set()
changed = []
for i, brain in enumerate(brains):
try:
feeds = set(brain.chimpfeeds)
except TypeError:
continue
missing = feeds - all_feeds
bad |= missing
if missing:
count += 1
obj = brain.getObject()
try:
field = obj.getField('feeds')
except AttributeError:
feeds = obj.feeds
field = None
else:
feeds = set(field.get(obj))
fixed = feeds - missing
if field is None:
obj.feeds = fixed
else:
field.set(obj, fixed)
changed.append(obj)
for obj in changed:
modified(obj)
obj.reindexObject()
logger.info("Repair complete; %d items updated." % count)
if bad:
logger.info("Feeds removed: %s." %
(", ".join(bad).encode('utf-8')))
IStatusMessage(self.request).addStatusMessage(
_(u"Repaired ${count} items.", mapping={'count': count}), "info")
def update(self):
self.buttons = button.Buttons(
self.buttons, button.Button('catalogupdate', _(u'Catalog Update')),
button.Button('reindex', _(u'Catalog Reindex')),
button.Button('unindex', _(u'Catalog Unindex')))
super(SQLTypeOverviewForm, self).update()
HAVE_RESOURCE_EDITOR = True
except ImportError:
HAVE_RESOURCE_EDITOR = False
# We want to add a Plone-specific feature to the SchemaListing
# form from plone.schemaeditor. We'll do this by subclassing, then
# adding the plone-specific button for the ace model editor.
class EnhancedSchemaListing(SchemaListing):
def handleModelEdit(self, action):
self.request.response.redirect('@@modeleditor')
if HAVE_RESOURCE_EDITOR:
but = button.Button("modeleditor", title=u'Edit XML Field Model')
EnhancedSchemaListing.buttons += button.Buttons(but)
handler = button.Handler(but, EnhancedSchemaListing.handleModelEdit)
EnhancedSchemaListing.handlers.addHandler(but, handler)
class TypeFieldsPage(TypeFormLayout):
label = _(u'Fields')
@property
def form(self):
if self.context.fti.hasDynamicSchema:
return EnhancedSchemaListing
else:
return ReadOnlySchemaListing
def update(self):
self.buttons = button.Buttons()
super(SQLViewForm, self).update()
class FlourishSelectedPeriodsAddTermsView(FlourishSelectedPeriodsAddView):
fields = field.Fields(ISelectedPeriodsAddTermsForm)
_objects_added = None
_objects_created = None
buttons = button.Buttons(
button.Button('add', title=_('Add')),
button.Button('cancel', title=_('Cancel')))
@property
def owner(self):
return IHaveSchedule(self.context)
@button.handler(buttons["add"])
def handleAdd(self, action):
return form.AddForm.handleAdd.func(self, action)
@button.handler(buttons["cancel"])
def handleCancel(self, action):
url = absoluteURL(self.context, self.request)
self.request.response.redirect(url)
def updateActions(self):
super(SelectedPeriodsAddView, self).updateActions()
self.actions['add'].addClass('button-ok')
self.actions['cancel'].addClass('button-cancel')
def create(self, data):
section = self.owner
linked = section.linked_sections
terms = [(ITerm(s), s) for s in linked]
terms = [(term, section) for term, section in terms
if (term.first >= data['first'].first and
term.last <= data['last'].last)]
self._objects_created = []
timetable = data['timetable']
for term, section in terms:
schedule = SelectedPeriodsSchedule(
timetable, term.first, term.last,
title=timetable.title,
timezone=timetable.timezone)
self._objects_created.append((section, schedule))
return self._objects_created
def add(self, schedules):
self._objects_added = []
for section, schedule in self._objects_created:
schedules = IScheduleContainer(section)
chooser = INameChooser(schedules)
name = chooser.chooseName('', schedule)
schedules[name] = schedule
self._objects_added.append(schedule)
def nextURL(self):
if self._objects_added:
int_ids = getUtility(IIntIds)
also_apply = ''
this_section = self.owner
n = 0
for schedule in self._objects_added:
section = IHaveSchedule(schedule)
if sameProxiedObjects(this_section, section):
continue
also_apply = '&'.join(
[also_apply,
'section-%d=%s&schedule-%d=%s' % (
n, int_ids.getId(removeSecurityProxy(section)),
n, urllib.quote(schedule.__name__)),
])
n += 1
if also_apply:
also_apply = '?' + also_apply
return '%s/edit_multi.html%s' % (
absoluteURL(self._objects_added[0], self.request),
also_apply)
return absoluteURL(self.context, self.request)
