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.")