def validateAction(self, data):
# TODO: check data ...
# ...
datasets = data.get('projection', {})
if not tuple(chain.from_iterable(x for x in datasets.values())):
raise WidgetActionExecutionError(
'projection', Invalid('No projection dataset selected.'))
# check if threshold values are in range
for dataset in (x for x in datasets.values()):
if not dataset:
raise WidgetActionExecutionError(
'projection',
Invalid(
'Please select at least one dataset within experiment')
)
# key: {label, value}
dsuuid = dataset.keys()[0]
ds = uuidToObject(dsuuid)
value = dataset[dsuuid]['value']
md = IBCCVLMetadata(ds)
# ds should be a projection output which has only one layer
# FIXME: error message is not clear enough and
# use widget.errors instead of exception
# also it will only verify if dateset has min/max values in
# metadata
layermd = md['layers'].values()[0]
if 'min' in layermd and 'max' in layermd:
# FIXME: at least layermd['min'] may be a string '0', when
# comparing to decimal from threshold selector, this comparison
# fails and raises the widget validation error
if value <= float(layermd['min']) or value >= float(
layermd['max']):
raise WidgetActionExecutionError(
'projection',
Invalid('Selected threshold is out of range'))
def handle_error(self, error, data):
# Current api v3 documentation only lists errors in the 400 and 500
# range. The 400 code can mean a lot of things...
if error.code == 400:
error_msg = _(
u"mailchimp_error_msg_already_subscribed",
default=u"Could not subscribe to newsletter. "
u"Either the email '${email}' is already subscribed "
u"or something else is wrong. Try again later.",
mapping={u"email": data['email']},
)
translated_error_msg = self.context.translate(error_msg)
raise WidgetActionExecutionError('email',
Invalid(translated_error_msg))
elif error.code == 220:
error_msg = _(
u"mailchimp_error_msg_banned",
default=u"Could not subscribe to newsletter. "
u"The email '${email}' has been banned.",
mapping={u"email": data['email']},
)
translated_error_msg = self.context.translate(error_msg)
raise WidgetActionExecutionError('email',
Invalid(translated_error_msg))
else:
error_msg = _(
u"mailchimp_error_msg",
default=u"Could not subscribe to newsletter. "
u"Please contact the site administrator: "
u"'${error}'",
mapping={u"error": error},
)
translated_error_msg = self.context.translate(error_msg)
raise ActionExecutionError(Invalid(translated_error_msg))
def handleApply(self, action):
data, errors = self.extractData()
if 'email' in data:
# Fetch MailChimp settings
registry = getUtility(IRegistry)
mailchimp_settings = registry.forInterface(IMailchimpSettings)
if len(mailchimp_settings.api_key) == 0:
return
mailchimp = PostMonkey(mailchimp_settings.api_key)
# Fetch MailChimp lists
# XXX, Todo: For now we just fetch the first list.
try:
lists = mailchimp.lists()['data']
list_id = lists[0]['id']
except MailChimpException, error:
raise WidgetActionExecutionError(
Invalid(
_(u"Could not fetch list from mailchimp.com: %s" %
error)))
# Subscribe to MailChimp list
try:
mailchimp.listSubscribe(id=list_id,
email_address=data['email'])
except MailChimpException, error:
raise WidgetActionExecutionError(
'email',
Invalid(_(u"Could not subscribe to newsletter: %s" %
error)))
def handleSave(self, action):
flash = IStatusMessage(self.request).addStatusMessage
(data, errors) = self.extractData()
if errors:
for error in errors:
flash(error.message, "notice")
return
user = get_current_account()
if not data["new_password"]:
flash(_("There were no changes to be saved."), "notice")
return
login_view = api.content.get_view(
name="login",
context=self.context,
request=self.request,
)
error = login_view.check_password_policy(data["new_password"])
if error:
raise WidgetActionExecutionError("new_password", Invalid(error))
if not user.verify_password(data["old_password"]):
raise WidgetActionExecutionError("old_password",
Invalid(_("Invalid password")))
user.password = data["new_password"]
flash(_("Your password was successfully changed."), "success")
def action_addfield(self, action):
data, errors = self.extractData()
self.submitted = True
if not errors:
field_class = getattr(registry_field, data['field_type'], None)
if field_class is None:
notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError('field_type',
Invalid('Invalid Field'))))
return
if data['name'] in self.context:
notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError(
'name', Invalid('Field name already in use'))))
return
new_field = field_class(title=data['title'],
required=data['required'])
new_record = Record(new_field)
self.context.records[data['name']] = new_record
messages = IStatusMessage(self.request)
messages.add(u"Successfully added field %s" % data['name'],
type=u"info")
return self.request.response.redirect('{url}/edit/{field}'.format(
url=self.context.absolute_url(), field=data['name']))
def handle_error(self, error, data):
if error.code == 400:
error_msg = _(u"mailinglijst_error_msg_already_subscribed",
default=u"Could not subscribe to newsletter. "
u"Either the email '${email}' is already subscribed "
u"or something else is wrong. Try again later.",
mapping={u"email": data['email']})
translated_error_msg = self.context.translate(error_msg)
raise WidgetActionExecutionError('email',
Invalid(translated_error_msg))
elif error.code == 220:
error_msg = _(u"mailinglijst_error_msg_banned",
default=u"Could not subscribe to newsletter. "
u"The email '${email}' has been banned.",
mapping={u"email": data['email']})
translated_error_msg = self.context.translate(error_msg)
raise WidgetActionExecutionError('email',
Invalid(translated_error_msg))
else:
error_msg = _(u"mailinglijst_error_msg",
default=u"Could not subscribe to newsletter. "
u"Please contact the site administrator: "
u"'${error}'",
mapping={u"error": error})
translated_error_msg = self.context.translate(error_msg)
raise ActionExecutionError(Invalid(translated_error_msg))
def action_book(self, action):
'''
Book this resource
'''
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
if not data.get('booking_date'):
raise WidgetActionExecutionError(
'booking_date',
Invalid(_(u"Please provide a booking date"))
)
conflict_manager = self.prenotazioni.conflict_manager
if conflict_manager.conflicts(data):
msg = _(u'Sorry, this slot is not available anymore.')
raise WidgetActionExecutionError(
'booking_date',
Invalid(msg)
)
if self.exceedes_date_limit(data):
msg = _(u'Sorry, you can not book this slot for now.')
raise WidgetActionExecutionError(
'booking_date',
Invalid(msg)
)
captcha = getMultiAdapter(
(aq_inner(self.context), self.request),
name='recaptcha'
)
if 'captcha' in data and not captcha.verify():
msg=_(u"Please check the captcha")
raise ActionExecutionError(Invalid(msg))
obj = self.do_book(data)
if not obj:
msg = _(u'Sorry, this slot is not available anymore.')
api.portal.show_message(
message=msg,
type='warning',
request=self.request)
target = self.back_to_booking_url
return self.request.response.redirect(target)
msg = _('booking_created')
api.portal.show_message(message=msg, type='info', request=self.request)
booking_date = data['booking_date'].strftime('%d/%m/%Y')
params = {'data': booking_date,
'uid': obj.UID()}
target = urlify(self.context.absolute_url(),
paths=["@@prenotazione_print"],
params=params)
return self.request.response.redirect(target)
def validate_position_types(data):
"""Can not remove a position_type used by a held_position."""
directory = data.__context__
stored_position_types_token = [
stored['token'] for stored in directory.position_types
]
position_types = [value['token'] for value in data.position_types]
removed_position_types = set(stored_position_types_token).difference(
position_types)
if removed_position_types:
catalog = api.portal.get_tool('portal_catalog')
# check if used by a held_position
hp_brains = catalog.unrestrictedSearchResults(
portal_type='held_position')
for hp_brain in hp_brains:
hp = hp_brain.getObject()
if hp.position_type in removed_position_types:
msg = translate('removed_position_type_in_use_error',
mapping={
'removed_position_type':
hp.position_type,
'hp_url': hp.absolute_url()
},
domain='PloneMeeting',
context=directory.REQUEST)
raise WidgetActionExecutionError('position_types',
Invalid(msg))
# check if used as a redefined position_type
# for an attendee on an item, this information is stored on the meeting
meeting_brains = catalog.unrestrictedSearchResults(
object_provides=IMeeting.__identifier__)
for meeting_brain in meeting_brains:
meeting = meeting_brain.getObject()
redefined_positions = meeting._get_item_redefined_positions()
for item_uid, infos in redefined_positions.items():
for hp_uid, pos_infos in infos.items():
if pos_infos[
'position_type'] in removed_position_types:
item = uuidToObject(item_uid, unrestricted=True)
msg = translate(
'removed_redefined_position_type_in_use_error',
mapping={
'removed_position_type':
pos_infos['position_type'],
'item_url':
item.absolute_url()
},
domain='PloneMeeting',
context=directory.REQUEST)
raise WidgetActionExecutionError(
'position_types', Invalid(msg))
def handle_subscribe(self, action):
if self.data.use_captcha:
captcha = getMultiAdapter((aq_inner(self.data), self.request),
name="recaptcha")
if not captcha.verify():
raise WidgetActionExecutionError(
"captcha",
Invalid(
_("Please check the captcha to prove you're a human")),
)
data, errors = self.extractData()
if errors:
return
email = data.get("email")
account_id, list_id = self.data.newsletter_list.split("|")
sendinblue = getUtility(ISendinblueAPI)
success = sendinblue.subscribe(account_id, list_id, email)
if success:
api.portal.show_message(
_("You are successfully subscribed to the newsletter !"),
request=self.request,
type="info",
)
else:
api.portal.show_message(
_("An error occured while triyng to subscribe to the newsletter"
),
request=self.request,
type="error",
)
url = self.request.ACTUAL_URL
self.request.response.redirect(url)
def handleUpload(self, action):
(data, errors) = self.extractData()
input = data["file"].data
importer = self.importer_factory(self.context)
try:
survey = importer(
input,
data["surveygroup_title"],
data["survey_title"],
data["is_etranslate_compatible"],
)
except lxml.etree.XMLSyntaxError:
raise WidgetActionExecutionError(
"file",
Invalid(
_("error_invalid_xml",
default="Please upload a valid XML file")),
)
IStatusMessage(self.request).addStatusMessage(
_("upload_success", default="Succesfully imported the OiRA Tool"),
type="success",
)
state = getMultiAdapter((survey, self.request),
name="plone_context_state")
self.request.response.redirect(state.view_url())
def handle_send(self, action):
data, errors = self.extractData()
registry = getUtility(IRegistry)
has_captcha = registry.get('castle.recaptcha_private_key') is not None
if has_captcha:
if not verify_recaptcha(self.request):
notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError('captcha', Invalid('Invalid Recaptcha'))))
return
if errors:
IStatusMessage(self.request).add(
self.formErrorsMessage,
type=u'error'
)
return
self.send_message(data)
self.send_feedback()
self.success = True
def notifyWidgetActionExecutionError(action, widget, err_str):
zope.event.notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError(widget, Invalid(err_str))
)
)
def add(self, field):
context = self.context
schema = IEditableSchema(context.schema)
# move it after the last field that is not in a fieldset
# or at top if there is no field yet in "default" fieldset
ordered_fields = [name for (name, f) in sortedFields(context.schema)]
default_fields = non_fieldset_fields(context.schema)
if len(default_fields) > 0:
position = ordered_fields.index(default_fields[-1]) + 1
else:
position = 0
try:
schema.addField(field)
except ValueError:
raise WidgetActionExecutionError('__name__',
Invalid(
u'Please select a field name that is not already used.'
))
schema.moveField(field.__name__, position)
notify(ObjectAddedEvent(field, context.schema))
notify(FieldAddedEvent(context, field))
IStatusMessage(self.request).addStatusMessage(
_(u"Field added successfully."), type='info')
def handle_merge(self, action):
data, errors = self.extractData()
if not errors:
allcategories = api.portal.get_registry_record(reg_key)
categories = set()
newname = u''
if 'form.widgets.rename_merge_categories' in self.request.form:
if data['rename_merge_categories'] not in (None, ''):
categories = set(data['rename_merge_categories'])
if 'form.widgets.new_category_name' in self.request.form:
newname = data['new_category_name'].split(';')[0]
if len(categories) > 0 and len(newname) > 0:
if newname in allcategories and newname not in categories:
raise WidgetActionExecutionError(
'new_category_name',
Invalid(u"That category name is already in use"))
return
for category in categories:
allcategories.remove(category)
allcategories.append(newname)
api.portal.set_registry_record(reg_key, allcategories)
for subscriber in subscribe.all():
if ('categories' in subscriber
and len(subscriber['categories']) > 0):
if len(
categories.intersection(
subscriber['categories'])) > 0:
subcat = subscriber['categories']
for category in categories:
if category in subcat:
subcat.remove(category)
subcat.append(newname)
subscriber['categories'] = subcat
self.widgets['new_category_name'].value = u''
self.widgets['rename_merge_categories'].value = u''
def action_subscribe(self, action):
data, errors = self.extractData()
subscriber = subscribe.get_subscriber(data['email'])
if errors:
return
if subscriber.get('phone_number') != data['phone_number']:
subscriber['phone_number'] = data['phone_number']
if not self.send_text_message(subscriber):
api.portal.show_message('Error sending code', request=self.request, type='error')
else:
api.portal.show_message('Phone number changed, code re-sent',
request=self.request, type='info')
if not data.get('phone_number_code'):
ActionErrorOccurred(
action,
WidgetActionExecutionError('phone_number_code', Invalid('No code specified')))
if not errors:
try:
alsoProvides(self.request, IDisableCSRFProtection)
subscribe.confirm_phone_number(data['email'], data['phone_number_code'])
self.confirmed = True
api.portal.show_message(
'Phone number successfully confirmed', request=self.request, type='info')
except subscribe.InvalidEmailException:
api.portal.show_message('Invalid Email', request=self.request, type='error')
except subscribe.InvalidCodeException:
api.portal.show_message('Invalid Code', request=self.request, type='error')
def handle_addcat(self, action):
data, errors = self.extractData()
if not errors:
allcategories = api.portal.get_registry_record(reg_key)
categories = set()
if 'add_categories' in data:
if data['add_categories'] not in (None, ''):
categories = set(data['add_categories'].split(';'))
if len(categories) > 0:
badcategories = []
for category in categories:
category = category.strip()
if len(category) > 0 and category not in allcategories:
allcategories.append(category)
else:
badcategories.append(category)
api.portal.set_registry_record(reg_key, allcategories)
self.widgets['add_categories'].value = ';'.join(badcategories)
if len(badcategories) > 0:
raise WidgetActionExecutionError(
'add_categories',
Invalid(
u"That category name is already in use"
)
)
def available_lists(self):
mailchimp = getUtility(IMailchimpLocator)
try:
return mailchimp.lists()
except MailChimpException, error:
raise WidgetActionExecutionError(
Invalid(u"Could not fetch available lists from MailChimp. " +
u"Please check your MailChimp API key: %s" % error))
def ensureValidPassword(obj):
if obj.password != obj.password_confirm:
raise WidgetActionExecutionError(
'password',
Invalid(
_(u'error_password_and_confirm_not_match',
default=u'Password '
u'and Confirm password do not match.')))
def ensureUsernameUnique(obj):
site = api.portal.get()
registration = getToolByName(site, 'portal_registration')
if not registration.isMemberIdAllowed(obj.username):
raise WidgetActionExecutionError(
'username',
Invalid(
_(u'error_username_alread_taken_or_invalid',
default=u'Your '
u'username is already in use or invalid.')))
def mailchimp_account(self):
mailchimp = getUtility(IMailchimpLocator)
try:
return mailchimp.account()
except PostRequestError:
return []
except MailChimpException, error:
raise WidgetActionExecutionError(
Invalid(u"Could not fetch account details from MailChimp. " +
u"Please check your MailChimp API key: %s" % error))
def available_lists(self):
registry = getUtility(IRegistry)
mailchimp_settings = registry.forInterface(IMailchimpSettings)
mailchimp = PostMonkey(mailchimp_settings.api_key)
try:
return mailchimp.lists()
except MailChimpException, error:
raise WidgetActionExecutionError(
Invalid(u"Could not fetch available lists from MailChimp. " +
"Please check your MailChimp API key: %s" % error))
def available_lists(self):
if IDisableCSRFProtection is not None:
alsoProvides(self.request, IDisableCSRFProtection)
mailchimp = getUtility(IMailchimpLocator)
try:
return mailchimp.lists()
except MailChimpException, error:
raise WidgetActionExecutionError(
Invalid(u"Could not fetch available lists from MailChimp. " +
u"Please check your MailChimp API key: %s" % error))
def handleSave(self, action):
flash = IStatusMessage(self.request).addStatusMessage
(data, errors) = self.extractData()
if errors:
return
url = self.context.absolute_url()
user = get_current_account()
if not user.verify_password(data["password"]):
raise WidgetActionExecutionError("password",
Invalid(_("Invalid password")))
settings_url = "%s/account-settings" % url
if not data["loginname"] or data["loginname"].strip(
) == user.loginname:
self.request.response.redirect(settings_url)
flash(_("There were no changes to be saved."), "notice")
return
login = data["loginname"].strip().lower()
existing = Session.query(Account.id).filter(Account.loginname == login)
if existing.count():
raise WidgetActionExecutionError(
"loginname",
Invalid(_("This email address is not available.")))
self.initiateRequest(user, login)
flash(
_(
"email_change_pending",
default=(
"Please confirm your new email address by clicking on "
"the link in the email that will be sent in a few "
'minutes to "${email}". Please note that the new '
"email address is also your new login name."),
mapping={"email": data["loginname"]},
),
"warning",
)
self.request.response.redirect("%s/" % url)
def mailchimp_account(self):
registry = getUtility(IRegistry)
mailchimp_settings = registry.forInterface(IMailchimpSettings)
if len(mailchimp_settings.api_key) == 0:
return []
mailchimp = PostMonkey(mailchimp_settings.api_key)
try:
return mailchimp.getAccountDetails()
except MailChimpException, error:
raise WidgetActionExecutionError(
Invalid(u"Could not fetch account details from MailChimp. " +
"Please check your MailChimp API key: %s" % error))
def handle_subscribe(self, action):
data, errors = self.extractData()
if not data.get('legal_conditions'):
raise WidgetActionExecutionError(
'legal_conditions',
Invalid(
_(u'You need to accept our legal terms and conditions.')))
return super(GDPRPortletSubscribeForm, self).handle_subscribe(
self,
action,
)
def validate_registration(self, action, data):
super(RegistrationForm, self).validate_registration(action, data)
if 'email' in data and data['email'].lower(
) != self.get_confirmed_email().lower():
err_str = u'Email address you have entered does not match email used in verification'
notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError('email', Invalid(err_str))))
del data['confirmed_email']
del data['confirmed_code']
def mailchimp_account(self):
if IDisableCSRFProtection is not None:
alsoProvides(self.request, IDisableCSRFProtection)
mailchimp = getUtility(IMailchimpLocator)
try:
return mailchimp.account()
except PostRequestError:
return []
except MailChimpException, error:
raise WidgetActionExecutionError(
Invalid(u"Could not fetch account details from MailChimp. " +
u"Please check your MailChimp API key: %s" % error))
def handleDelete(self, action):
(data, errors) = self.extractData()
if errors:
return
user = get_current_account()
if not user.verify_password(data["password"]):
raise WidgetActionExecutionError("password",
Invalid(_("Invalid password")))
Session.delete(user)
self.logout()
self.request.response.redirect(self.request.client.absolute_url())
def action_subscribe(self, action):
data, errors = self.extractData()
if self.has_captcha and self.isAnon:
if not verify_recaptcha(self.request):
notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError('captcha', Invalid('Invalid Recaptcha'))))
return
subsciber = subscribe.get_subscriber(data.get('email'))
if subsciber:
notify(
ActionErrorOccurred(
action,
WidgetActionExecutionError('email', Invalid('User already subscribed'))))
return
if not errors:
item = subscribe.register(data['email'], data)
self.send_mail(data['email'], item)
self.sent = True
api.portal.show_message(
'Verification email has been sent to your email', request=self.request, type='info')
if self.has_texting and data.get('phone_number'):
if not self.send_text_message(item):
api.portal.show_message('Error sending code', request=self.request,
type='error')
else:
api.portal.show_message('Code texted to your number to verify',
request=self.request, type='info')
self.request.response.redirect('%s/@@subscribe-phone?%s' % (
self.context.absolute_url(),
urlencode({
'form.widgets.email': item['email'],
'form.widgets.phone_number': item.get('phone_number', '')
})
))
def add(self, new_fieldset):
schema = self.context.schema
fieldsets = schema.getTaggedValue(FIELDSETS_KEY)
for fieldset in fieldsets:
if fieldset.__name__ == new_fieldset.__name__:
raise WidgetActionExecutionError('__name__',
Invalid(_(u'Please select a fieldset name that is not already used.')))
fieldsets.append(new_fieldset)
schema.setTaggedValue(FIELDSETS_KEY, fieldsets)
notifyContainerModified(schema)
notify(SchemaModifiedEvent(self.context))
self.status = _(u"Fieldset added successfully.")
