class PortletSubscribeLinkForm(z3c.form.form.Form):
""" """
template = viewpagetemplatefile.ViewPageTemplateFile('titlelessform.pt')
ignoreContext = True
formErrorsMessage = _('There were some errors.')
def __init__(self, context, request):
super(PortletSubscribeLinkForm, self).__init__(context, request)
@property
def fields(self):
return z3c.form.field.Fields(self.context.composers[self.format].schema)
@z3c.form.button.buttonAndHandler(_('Proceed'), name='preceed')
def handleAdd(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
params = urlencode(dict([('composer.widgets.%s'%key, value)
for key, value in data.items()]))
subscribe_url = '%s/subscribe.html?%s' % (self.context.absolute_url(),
params)
self.request.response.redirect(subscribe_url)
return
class ChannelPreviewForm(z3c.form.form.Form):
"""Channel preview form.
Currently only allows an in-browser preview.
"""
interface.implements(ISendAndPreviewForm)
template = viewpagetemplatefile.ViewPageTemplateFile('form.pt')
description = _(u"See an in-browser preview of the newsletter.")
fields = z3c.form.field.Fields(ISendAndPreviewForm).select(
'include_collector_items')
include_collector_items = True
def getContent(self):
return self
@z3c.form.button.buttonAndHandler(_(u"Generate"), name='preview')
def handle_preview(self, action):
data, errors = self.extractData()
if errors:
self.status = form.EditForm.formErrorsMessage
return
collector_items = int(bool(data['include_collector_items']))
return self.request.response.redirect(
self.context.absolute_url()+\
'/preview-newsletter.html?include_collector_items=%d' % \
collector_items)
class EditChannelForm(z3c.form.form.EditForm):
"""Channel edit form.
As opposed to the crud form, this allows editing of all channel
settings.
Actions are also provided to preview and send the newsletter.
"""
template = viewpagetemplatefile.ViewPageTemplateFile('form.pt')
description = _(u"Edit the properties of the mailing-list.")
@property
def fields(self):
fields = z3c.form.field.Fields(IChannel).select('title')
collector = schema.Choice(__name__='collector',
title=IChannel['collector'].title,
required=False,
vocabulary='Collector Vocabulary')
scheduler = FactoryChoice(__name__='scheduler',
title=IChannel['scheduler'].title,
required=False,
vocabulary='Scheduler Vocabulary')
fields += field.Fields(collector, scheduler)
fields += field.Fields(IChannel).select('description', 'subscribeable',
'keep_sent_messages')
fields['description'].widgetFactory[
z3c.form.interfaces.INPUT_MODE] = wysiwyg.WysiwygFieldWidget
return fields
class EditTopicForm(subform.EditSubForm):
"""Edit a single collector.
"""
component.adapts(Products.ATContentTypes.content.topic.ATTopic, None,
z3c.form.interfaces.IEditForm)
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
fields = field.Fields(schema.TextLine(__name__='title', title=_(u"Title")))
@property
def css_class(self):
return "subform subform-level-%s" % self.level
@property
def label(self):
return _(u"Collection: ${title}",
mapping={'title': self.context.title})
prefix = property(prefix)
def contents_bottom(self):
return u'<a href="%s/criterion_edit_form">%s</a>' % (
self.context.absolute_url(),
self.context.translate(_(u"Edit the Smart Folder")))
heading = heading
class EditCollectorOptionsAddForm(z3c.form.form.Form):
"""Edit a single collectors options.
"""
template = viewpagetemplatefile.ViewPageTemplateFile(
'../subform.pt')
css_class = 'subForm subForm-level-1'
ignoreContext = True
prefix = property(prefix)
def __init__(self, context, request, channel, parentForm):
super(EditCollectorOptionsAddForm, self).__init__(context, request)
self.context = context
self.request = request
self.channel = channel
self.parentForm = self.__parent__ = parentForm
self.heading = 'Options for %s'%channel.Title()
@property
def fields(self):
return z3c.form.field.Fields(self.channel.collector.schema)
@property
def label(self):
return _(u"${channel} options", mapping={'channel':self.channel.Title()})
@property
def selected_channel(self):
return self.context == self.parentForm.context.channel
class EditTimedSchedulerForm(form.EditForm):
template = viewpagetemplatefile.ViewPageTemplateFile(
'form-with-subforms.pt')
@property
def fields(self):
return field.Fields(
collective.singing.interfaces.IScheduler).select('active')
def update(self):
self.subforms = []
for index, entry in enumerate(self.context.items):
sub = EditTimedSchedulerEntryForm(entry, self.request)
sub.prefix = '%s.' % index
sub.update()
self.subforms.append(sub)
super(EditTimedSchedulerForm, self).update()
@button.buttonAndHandler(_('Apply'), name='apply')
def handle_apply(self, action):
return super(EditTimedSchedulerForm,
self).handleApply.func(self, action)
@button.buttonAndHandler(_('Remove entries'), name='remove')
def handle_remove(self, action):
for subform in tuple(self.subforms):
data, errors = subform.extractData()
if data.get('selected'):
self.context.items.remove(subform.context)
self.subforms.remove(subform)
class SubscriptionEditForm(IncludeHiddenSecret, form.EditForm):
template = viewpagetemplatefile.ViewPageTemplateFile('form.pt')
successMessage = _('Your subscription was updated.')
removed = False
handlers = form.EditForm.handlers
@property
def description(self):
return self.context.channel.description
@property
def prefix(self):
return '%s.%s.' % (self.context.channel.name,
self.context.metadata['format'])
@property
def label(self):
subscription = self.context
value = subscription.channel.title
if len(subscription.channel.composers) > 1:
format = subscription.metadata['format']
value = u"%s (%s)" % (value,
subscription.channel.composers[format].title)
return value
@property
def fields(self):
if self.context.channel.collector is None:
return field.Fields()
return field.Fields(self.context.channel.collector.schema)
def update(self):
if len(self.fields) == 0:
self.buttons = self.buttons.omit('apply')
super(SubscriptionEditForm, self).update()
@button.buttonAndHandler(_('Apply changes'), name='apply')
def handleApply(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
changes = self.applyChanges(data)
if changes:
self.status = self.successMessage
else:
self.status = self.noChangesMessage
@button.buttonAndHandler(_('Unsubscribe from newsletter'),
name='unsubscribe')
def handle_unsubscribe(self, action):
secret = self.secret
subs = self.context.channel.subscriptions
for subscription in subs.query(secret=secret):
subs.remove_subscription(subscription)
self.removed = self.context
self.status = _(u"You unsubscribed successfully.")
class Step(utils.OverridableTemplate, form.Form):
index = viewpagetemplatefile.ViewPageTemplateFile('wizard-step.pt')
subforms = ()
label = u""
description = u""
ignoreContext = True
def __init__(self, context, request, parent):
super(Step, self).__init__(context, request)
self.parent = parent
class EditFilteredSubjectsCollectorForm(form.EditForm):
template = viewpagetemplatefile.ViewPageTemplateFile('form.pt')
@property
def fields(self):
schema = self.context.full_schema
field = schema[self.context.field_name]
field.__name__ = 'filtered_items'
field.interface = None
return z3c.form.field.Fields(schema)
class EditRootCollectorForm(AbstractEditCollectorForm, form.EditForm):
"""Edit a single collector.
"""
template = viewpagetemplatefile.ViewPageTemplateFile(
'form-with-subforms.pt')
fields = collector_fields
@property
def parent_form(self):
return self
class DeleteFromCollectorForm(form.Form):
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
css_class = "deleteform"
prefix = property(prefix)
@z3c.form.button.buttonAndHandler(_('Remove block'), name='remove')
def handle_remove(self, action):
self.context.aq_parent.manage_delObjects([self.context.id])
self.status = _("Item successfully deleted.")
class Renderer(base.Renderer):
"""Portlet renderer.
This is registered in configure.zcml. The referenced page template is
rendered, and the implicit variable 'view' will refer to an instance
of this class. Other methods can be added and referenced in the template.
"""
_template = ViewPageTemplateFile('channelsubscribe.pt')
form_template = viewpagetemplatefile.ViewPageTemplateFile('titlelessform.pt')
def __init__(self, *args):
base.Renderer.__init__(self, *args)
def setup_form(self):
switch_on(self)
if self.channel is not None:
if self.data.subscribe_directly:
self.form = PortletSubscriptionAddForm(self.channel, self.request)
self.form.assignment = self.data
else:
self.form = PortletSubscribeLinkForm(self.channel, self.request)
self.form.format = 'html'
self.form.update()
def render(self):
self.setup_form()
return self._template()
@property
def available(self):
return bool(self.data.channel)
@property
def channel(self):
return self.data.channel
channels = self.data.all_channels
if channels and self.data.channel:
for channel in channels:
if channel.name == self.data.channel.name:
return channel
return None
def channel_link(self):
link = {'url':'%s/subscribe.html'%self.channel.absolute_url(),
'title':self.getFooterText()}
return link
def getFooterText(self):
if bool(self.data.footer_text):
return self.data.footer_text
return self.channel.Title()
class GlobalMenuSubItem(ContextMenuItem):
"""Menu item viewlet generating global/site related links."""
template = viewpagetemplatefile.ViewPageTemplateFile('menu_sub_item.pt')
@property
def menu_class(self):
if self.posInManager > 0:
if self.selected:
return u"navsub selected"
else:
return u"navsub"
else:
if self.selected:
return u"navsub first selected"
else:
return u"navsub"
class CollectorDataForm(utils.OverridableTemplate, form.Form):
"""A subform for the collector specific data.
"""
index = viewpagetemplatefile.ViewPageTemplateFile('sub-edit.pt')
prefix = 'collector'
label = _(u"Filters")
ignoreContext = True
@property
def fields(self):
collector = self.context.collector
if collector is not None:
return field.Fields(collector.schema)
else:
return field.Fields()
class GlobalMenuMainItem(GlobalMenuItem):
"""Menu item viewlet generating global/site related links."""
template = viewpagetemplatefile.ViewPageTemplateFile('menu_main_item.pt')
@property
def menu_class(self):
if self.posInManager > 0:
if self.selected:
return u"navmainother selected"
else:
return u"navmainother"
else:
if self.selected:
return u"navmainstart selected"
else:
return u"navmainstart"
class EditTimedSchedulerEntryForm(form.Form):
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
ignoreContext = True
@property
def fields(self):
f = field.Field(
schema.Bool(__name__='selected',
title=unicode(self.context[0]),
required=False))
f.widgetFactory[z3c.form.interfaces.INPUT_MODE] = (
singlecheckboxwidget_factory)
return field.Fields(f)
def update(self):
super(EditTimedSchedulerEntryForm, self).update()
class EditComposersForm(z3c.form.form.EditForm):
"""
"""
template = viewpagetemplatefile.ViewPageTemplateFile(
'form-with-subforms.pt')
subforms = []
ignoreContext = True
semiSuccesMessage = _(u"Only some of your changes were saved")
def update(self):
super(EditComposersForm, self).update()
self.update_subforms()
def update_subforms(self):
self.subforms = []
for format, item in self.context.composers.items():
subform = component.getMultiAdapter((item, self.request, self),
z3c.form.interfaces.ISubForm)
subform.format = format
subform.update()
self.subforms.append(subform)
@z3c.form.button.buttonAndHandler(_('Save'), name='save')
def handleSave(self, action):
self.status = ''
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
changes = self.applyChanges(data)
if not changes:
self.update_subforms()
stati = [f.status for f in self.subforms]
if self.successMessage in stati:
if self.formErrorsMessage not in stati:
self.status = self.successMessage
else:
self.status = self.semiSuccesMessage
elif self.formErrorsMessage in stati:
self.status = self.formErrorsMessage
if not self.status:
if changes:
self.status = self.successMessage
else:
self.status = self.noChangesMessage
class ChannelSubscribePortletEditForm(z3c.form.form.EditForm):
""" """
template = viewpagetemplatefile.ViewPageTemplateFile('../form-with-subforms.pt')
fields = z3c.form.field.Fields(IChannelSubscribePortlet)
css_class = 'editForm portletEditForm'
heading = _(u"Edit Mailing-list Subscribe Portlet")
def update(self):
super(ChannelSubscribePortletEditForm, self).update()
self.subforms = []
for channel in self.context.all_channels:
if channel.collector is not None:
option_form = EditCollectorOptionsForm(channel,
self.request,
self)
option_form.update()
self.subforms.append(option_form)
class EditTextForm(subform.EditSubForm):
component.adapts(collector.ITextCollector, None,
z3c.form.interfaces.IEditForm)
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
fields = z3c.form.field.Fields(collector.ITextCollector).select(
'title', 'value')
fields['value'].widgetFactory[
z3c.form.interfaces.INPUT_MODE] = wysiwyg.WysiwygFieldWidget
@property
def css_class(self):
return "subform subform-level-%s" % self.level
@property
def label(self):
return _(u"Rich text: ${title}", mapping={'title': self.context.title})
prefix = property(prefix)
class MoveBlockForm(form.Form):
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
css_class = "moveform"
prefix = property(prefix)
def _info_idx(self):
infos = list(self.context.aq_parent._objects)
info = None
for info in infos:
if info['id'] == self.context.id:
break
if info in infos:
return infos.index(info)
else:
return 0
def _move(self, delta):
prev_index = self._info_idx()
parent = self.context.aq_parent
infos = list(parent._objects)
my_info = infos[prev_index]
del infos[prev_index]
infos.insert(prev_index + delta, my_info)
parent._objects = tuple(infos)
@z3c.form.button.buttonAndHandler(
_('Move block up'),
name='up',
condition=lambda form: form._info_idx() > 0)
def handle_moveup(self, action):
self._move(-1)
self.status = _("Item successfully moved.")
@z3c.form.button.buttonAndHandler(
_('Move block down'),
name='down',
condition=lambda form:
(form._info_idx() < len(form.context.aq_parent._objects) - 1))
def handle_movedown(self, action):
self._move(1)
self.status = _("Item successfully moved.")
class EditCollectorForm(AbstractEditCollectorForm, subform.EditSubForm):
"""Edit a single collector.
"""
component.adapts(collective.singing.interfaces.ICollector,
zope.publisher.interfaces.http.IHTTPRequest,
z3c.form.interfaces.IEditForm)
template = viewpagetemplatefile.ViewPageTemplateFile(
'form-with-subforms.pt')
fields = collector_fields
prefix = property(prefix)
@property
def label(self):
return _(u"Collector block: ${title}",
mapping={'title': self.context.title})
@property
def parent_form(self):
return self.parentForm
class ForgotSecret(utils.OverridableTemplate, form.Form):
ignoreContext = True
index = viewpagetemplatefile.ViewPageTemplateFile('form.pt')
label = _(u"Retrieve a link to your personalized subscription settings")
successMessage = _(u"Thanks. We sent you a message.")
notKnownMessage = _(u"Your subscription isn't known to us.")
fields = field.Fields(
schema.TextLine(
__name__='address',
title=_(u"Address"),
description=_(u"The address you're already subscribed with"),
),
)
@button.buttonAndHandler(_('Send'), name='send')
def handle_send(self, action):
data, errors = self.extractData()
if errors:
self.status = form.EditForm.formErrorsMessage
return
address = data['address'].lower()
for channel in channel_lookup():
subscriptions = channel.subscriptions.query(key=address)
if len(subscriptions):
subscription = tuple(subscriptions)[0]
composer = channel.composers[subscription.metadata['format']]
msg = composer.render_forgot_secret(subscription)
status, status_msg = message.dispatch(msg)
if status != u'sent':
raise RuntimeError(
"There was an error with sending your e-mail. Please "
"try again later.")
self.status = self.successMessage
break
else:
self.status = self.notKnownMessage
class SendAsNewsletterForm(form.Form):
template = viewpagetemplatefile.ViewPageTemplateFile('send-newsletter.pt')
factories = [SendForm, PreviewForm]
def update(self):
super(SendAsNewsletterForm, self).update()
self.subforms = [f(self, self.request) for f in self.factories]
for form in self.subforms:
form.update()
# XXX: We should find a more beautiful solution here!
if form.status:
IStatusMessage(self.request).addStatusMessage(form.status)
def timed_channels(self):
channels = []
for channel in collective.singing.channel.channel_lookup():
if isinstance(channel.scheduler,
collective.singing.scheduler.TimedScheduler):
channels.append(channel.name)
return channels
class EditPeriodicSchedulerForm(form.EditForm):
template = viewpagetemplatefile.ViewPageTemplateFile('form.pt')
@property
def fields(self):
return field.Fields(collective.singing.interfaces.IScheduler).select(
'triggered_last', 'active')
@button.buttonAndHandler(_('Apply'), name='apply')
def handle_apply(self, action):
return super(EditPeriodicSchedulerForm,
self).handleApply.func(self, action)
@button.buttonAndHandler(_('Trigger now'), name='trigger')
def handle_trigger(self, action):
queued = self.context.trigger(self.context.aq_inner.aq_parent,
self.request)
if queued:
self.status = _(u"${number} messages queued.",
mapping=dict(number=queued))
else:
self.status = _(u"No messages queued.")
class EditReferenceForm(subform.EditSubForm):
component.adapts(collector.IReferenceCollector, None,
z3c.form.interfaces.IEditForm)
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
fields = z3c.form.field.Fields(collector.IReferenceCollector,
query.IReferenceSelection).select(
'title', 'items')
fields['items'].widgetFactory[
z3c.form.interfaces.INPUT_MODE] = \
z3c.formwidget.query.widget.QuerySourceFieldCheckboxWidget
@property
def css_class(self):
return "subform subform-level-%s" % self.level
@property
def label(self):
return _(u"Rich text: ${title}", mapping={'title': self.context.title})
prefix = property(prefix)
class EditComposerForm(z3c.form.subform.EditSubForm):
"""Composer edit form.
This allows editing of composers settings.
"""
component.adapts(collective.singing.interfaces.IComposer,
zope.publisher.interfaces.http.IHTTPRequest,
z3c.form.form.EditForm)
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
description = _(u"Edit the properties of the composer.")
format = u""
@property
def fields(self):
return z3c.form.field.Fields(IComposer).omit('name', 'schema', 'title')
@property
def heading(self):
return _(u"Composer for format : ${format}",
mapping={'format': self.format})
@property
def prefix(self):
return 'composers.%s.' % self.format
@z3c.form.button.handler(EditComposersForm.buttons['save'])
def handleSave(self, action):
data, errors = self.widgets.extract()
if errors:
self.status = self.formErrorsMessage
return
content = self.getContent()
changed = z3c.form.form.applyChanges(self, content, data)
if changed:
zope.event.notify(zope.lifecycleevent.ObjectModifiedEvent(content))
self.status = self.successMessage
else:
self.status = self.noChangesMessage
class AddToCollectorForm(form.Form):
ignoreContext = True
ignoreRequest = True
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
css_class = "addform"
prefix = property(prefix)
heading = heading
@property
def label(self):
return _(u"Add item to ${title}",
mapping={'title': self.context.title})
@property
def fields(self):
factory = schema.Choice(
__name__='factory',
title=_(u"Type"),
vocabulary=zope.schema.vocabulary.SimpleVocabulary([
zope.schema.vocabulary.SimpleTerm(value=f, title=f.title)
for f in collector.collectors
]))
title = schema.TextLine(__name__='title', title=_(u"Title"))
return z3c.form.field.Fields(factory, title)
@z3c.form.button.buttonAndHandler(_('Add'), name='add')
def handle_add(self, action):
data, errors = self.extractData()
if errors:
self.status = z3c.form.form.EditForm.formErrorsMessage
return
obj = data['factory'](self.context.get_next_id(), data['title'])
self.context[obj.id] = obj
self.status = _(u"Item added successfully.")
class ChannelSubscribePortletAddForm(z3c.form.form.AddForm):
""" """
template = viewpagetemplatefile.ViewPageTemplateFile('../form-with-subforms.pt')
fields = z3c.form.field.Fields(IChannelSubscribePortlet)
css_class = 'addForm portletAddForm'
heading = _(u"Add Mailing-list Subscribe Portlet")
subforms = []
def create(self, data):
return Assignment(**data)
def add(self, object):
self.context.add(object)
def nextURL(self):
# XXX: this should be prettier/more stable
subscribe_directly = self.request.get(
'form.widgets.subscribe_directly', '') == [u'true']
if subscribe_directly:
return '../%s/edit' % (self.context.items()[-1][0])
else:
return '../../@@manage-portlets'
class PrettySubscriptionsForm(IncludeHiddenSecret, form.EditForm):
template = viewpagetemplatefile.ViewPageTemplateFile(
'prettysubscriptionsform.pt')
ignoreContext = True
#ignoreRequest = True
confirmation_sent = False
status_message = None
unsubscribed_all = False
def __init__(self, context, request, subs, channels):
super(PrettySubscriptionsForm, self).__init__(context, request)
self.subs = subs
self.channels = channels
self.key_fields = []
channels = channel_lookup(only_subscribeable=True)
if channels:
composers = reduce(lambda x, y: x + y,
[c.composers.values() for c in channels])
for composer in composers:
for name in composer.schema.names():
f = composer.schema.get(name)
if f and ISubscriptionKey.providedBy(f):
if f not in self.key_fields:
self.key_fields.append(f)
self.confirmation_sent = False
def status(self):
if self.status_message:
return self.status_message
stati = [form.status for form in self.forms]
for s in [
SubscriptionSubForm.status_already_subscribed,
SubscriptionSubForm.status_sent,
SubscriptionSubForm.successMessage
]:
if s in stati:
return s
for s in [
SubscriptionSubForm.status_subscribed,
SubscriptionSubForm.status_unsubscribed
]:
if s in stati:
return SubscriptionSubForm.successMessage
return ''
@property
def addforms(self):
return [f for f in self.subscription_addforms if not f.added]
@property
def editforms(self):
return [f for f in self.subscription_editforms if not f.removed]
@property
def forms(self):
return sorted(self.addforms + self.editforms,
key=operator.attrgetter('label'))
@property
def fields(self):
fields = field.Fields()
for kf in self.key_fields:
current = field.Field(kf)
if current.__name__ not in fields.keys():
fields += field.Fields(current)
if self.subs and not self.unsubscribed_all:
self.request.form['form.widgets.' + kf.getName()] = \
self.subs[0].composer_data[kf.getName()]
return fields
def updateWidgets(self):
super(PrettySubscriptionsForm, self).updateWidgets()
if self.subs and not self.unsubscribed_all:
for kf in self.key_fields:
self.widgets[kf.getName()].disabled = 'disabled'
def update(self):
super(PrettySubscriptionsForm, self).update()
# Let's set convert any 'pending' subscriptions to non-pending:
for sub in self.subs:
if sub.metadata.get('pending'):
sub.metadata['pending'] = False
# Assemble the list of edit forms
self.subscription_editforms = [
SubscriptionEditSubForm(s, self.request, self) for s in self.subs
]
# Assemble the list of add forms
self.subscription_addforms = []
for format, channel in self.channels:
addform = SubscriptionAddSubForm(channel, self.request, self)
addform.format = format
self.subscription_addforms.append(addform)
# The edit forms might have deleted a subscription. We'll
# take care of this while updating them:
for form in self.subscription_editforms:
form.update()
if form.removed:
subscription = form.context
addform = SubscriptionAddSubForm(subscription.channel,
self.request, self)
addform.format = subscription.metadata['format']
addform.ignoreRequest = True
addform.update()
self.subscription_addforms.append(addform)
addform.status = form.status
#elif form.status != form.noChangesMessage:
# self.status = form.status
# The edit forms might have deleted a subscription. We'll
# take care of this while updating them:
for form in self.subscription_editforms:
form.update()
if form.removed:
subscription = form.context
addform = SubscriptionAddSubForm(subscription.channel,
self.request, self)
addform.format = subscription.metadata['format']
addform.ignoreRequest = True
addform.update()
self.subscription_addforms.append(addform)
addform.status = form.status
#elif form.status != form.noChangesMessage:
# self.status = form.status
# Let's update the add forms now. One of them may have added
# a subscription:
for form in self.subscription_addforms:
form.update()
subscription = form.added
if subscription is not None:
editform = SubscriptionEditSubForm(subscription, self.request,
self)
editform.update()
self.subscription_editforms.append(editform)
#_(u"You subscribed successfully.")
editform.status = form.status
# check if all subscriptions are now cancelled
if not sum([len(c.subscriptions.query(secret=self.secret)) \
for c in channel_lookup(only_subscribeable=True)]):
self.unsubscribed_all = True
self.status_message = _(u"You were unsubscribed completely.")
# update after setting unsubscribed_all
self.updateWidgets()
del self.request.form['secret']
@button.buttonAndHandler(_('Apply'), name='apply')
def handle_apply(self, action):
# All the action happens in the subforms ;-)
# All we do here is check that key_fields were not altered
if self.subs:
data, errors = self.extractData()
for key, value in data.items():
if self.subs[0].composer_data[key] != value:
self.status_message = SubscriptionSubForm.status_error
def send_confirmation(self, channel, format, subscription):
if not self.confirmation_sent:
composer = channel.composers[format]
msg = composer.render_confirmation(subscription)
status, status_msg = collective.singing.message.dispatch(msg)
if status == u'sent':
self.status_message = _(u"Information on how to confirm your "
"subscription has been sent to you.")
self.confirmation_sent = True
else:
# This implicitely rolls back our transaction.
raise RuntimeError(
"There was an error with sending your e-mail. Please try "
"again later.")
class SubscriptionEditSubForm(SubscriptionSubForm):
template = viewpagetemplatefile.ViewPageTemplateFile('subform.pt')
removed = False
handlers = form.EditForm.handlers
@property
def description(self):
return self.context.channel.description
@property
def prefix(self):
return '%s.%s.' % (self.context.channel.name,
self.context.metadata['format'])
@property
def label(self):
subscription = self.context
value = subscription.channel.title
if len(subscription.channel.composers) > 1:
format = subscription.metadata['format']
value = u"%s (%s)" % (value,
subscription.channel.composers[format].title)
return value
@property
def channel_selector(self):
return '%s-%s' % (self.context.channel.name,
self.context.metadata['format'])
@property
def fields(self):
select_field = field.Field(
schema.Bool(__name__=self.channel_selector,
title=self.label,
default=True,
required=False))
select_field.widgetFactory[z3c.form.interfaces.INPUT_MODE] = (
singlecheckboxwidget_factory)
fields = field.Fields(select_field, prefix='selector.')
if self.context.channel.collector is not None:
fields += field.Fields(self.context.channel.collector.schema,
prefix='collector.')
return fields
def update(self):
def handleApply(self, action):
data, errors = self.extractData()
if not data.get(self.channel_selector):
self.unsubscribe()
return
if errors:
self.status = self.formErrorsMessage
return
content = self.getContent()
del data[self.channel_selector]
changes = form.applyChanges(self, content, data)
if changes:
zope.event.notify(
zope.lifecycleevent.ObjectModifiedEvent(content))
self.status = self.successMessage
else:
self.status = self.noChangesMessage
self.handlers = button.Handlers()
self.handlers.addHandler(self.parentForm.buttons['apply'], handleApply)
super(SubscriptionEditSubForm, self).update()
def unsubscribe(self):
secret = self.secret
format = self.context.metadata['format']
subs = self.context.channel.subscriptions
for subscription in subs.query(secret=secret, format=format):
subs.remove_subscription(subscription)
self.removed = self.context
self.status = self.status_unsubscribed
