def update(self):
fields = field.Fields(IEnhancedUserDataSchema)
fields['skills'].widgetFactory = CheckBoxFieldWidget
self.add(fields)
class DetailsHostForm(DisplayForm):
""" Display form for the object """
label = _(u'settings of net')
fields = field.Fields(IHostVMwareVm).omit(*HostDetails.omit_viewfields)
class EditHostForm(EditForm):
""" Edit form for host """
form.extends(form.EditForm)
label = _(u'VMware Virtual Machine Edit Form')
fields = field.Fields(IHostVMwareVm).omit(*HostDetails.omit_editfields)
class ViewAdmUtilSimple1Form(DisplayForm):
""" Display form for the object """
label = _(u'settings of simple scanner')
fields = field.Fields(IAdmUtilSimple1).omit(\
*AdmUtilSimple1Details.omit_viewfields)
class ViewAdmUtilEsxVimForm(DisplayForm):
""" Display form for the object """
label = _(u'settings of esx_vim')
fields = field.Fields(IAdmUtilEsxVim).omit(\
*AdmUtilEsxVimDetails.omit_viewfields)
class ActionAddForm(FieldAddForm):
fields = field.Fields(INewAction)
label = _('Add new action')
class CountableSchemata(CS):
""" Schemata countable
"""
fields = field.Fields(ISchema).select(
u'count'
)
def getBaseFields(self):
return field.Fields(IResource).omit('type', 'notes')
def getBaseFields(self):
fields = field.Fields(ILocation).select('title', 'description')
return fields
def getBaseFields(self):
return field.Fields(IEquipment)
def getBaseFields(self):
return field.Fields(IResource)
def getBaseFields(self):
return field.Fields(ILocation)
def getBaseFields(self):
return field.Fields(IResource).select('title', 'description')
def getDemoFields(self):
fields = field.Fields()
dfs = IResourceDemographicsFields(ISchoolToolApplication(None))
for field_desc in dfs.filter_key(self.resource_type):
fields += field_desc.makeField()
return fields
def update_schema(self):
fields = field.Fields(self.get_fields)
showFields = getattr(self.field, 'showFields', [])
if showFields:
fields = fields.select(*showFields)
return fields
def getBaseFields(self):
fields = field.Fields(IEquipment).select('title', 'description')
return fields
def view_schema(self):
ExtraData = self.field.ExtraData
if ExtraData:
return field.Fields(IExtraData).select(*ExtraData)
class DisplayForm(layout.FormLayoutSupport, form.DisplayForm):
"""Widgets in Display-Mode"""
form.extends(form.DisplayForm)
label = _(u'View Superclass')
fields = field.Fields(ISuperclass).omit(\
*SuperclassDetails.omit_viewfields)
class ArchiveForm(directives_form.Form):
grok.context(IDossierMarker)
grok.name('transition-archive')
grok.require('zope2.View')
label = _(u'heading_archive_form', u'Archive Dossier')
fields = field.Fields(IArchiveFormSchema)
ignoreContext = True
# define custom widgets.
fields['filing_action'].widgetFactory[INPUT_MODE] = radio.RadioFieldWidget
fields['dossier_enddate'].widgetFactory[INPUT_MODE] = DatePickerFieldWidget
@button.buttonAndHandler(_(u'button_archive', default=u'Archive'))
def archive(self, action):
"""Try to archive this dossier.
For that to happen, first all subdossiers need to have filing_no
and end_date set, and then be resolved. If resolving any of the
subdossier fails, we'll throw and error and return.
"""
data, errors = self.extractData()
# Abort if there were errors
if len(errors) > 0:
return
self.ptool = getToolByName(self.context, 'plone_utils')
self.wft = self.context.portal_workflow
action = data.get('filing_action')
filing_year = data.get('filing_year')
filing_no = None
filing_prefix = data.get('filing_prefix')
end_date = data.get('dossier_enddate')
if action == METHOD_FILING:
# allready resolved only give a filing number
IDossierArchiver(self.context).archive(filing_prefix, filing_year)
self.ptool.addPortalMessage(_("The filing number has been given."),
type="info")
return self.request.RESPONSE.redirect(self.context.absolute_url())
# archiving must passed to the resolving view
resolver = get_resolver(self.context)
if resolver.is_resolve_possible():
raise TypeError
if resolver.are_enddates_valid():
raise TypeError
if action == METHOD_RESOLVING_AND_FILING:
IDossierArchiver(self.context).archive(filing_prefix, filing_year)
if action == METHOD_RESOLVING_EXISTING_FILING:
# archive all with the existing filing number
filing_no = IFilingNumber(self.context).filing_no
filing_prefix = IDossier(self.context).filing_prefix
IDossierArchiver(self.context).archive(filing_prefix,
filing_year,
number=filing_no)
if action == METHOD_RESOLVING:
# only update the prefixes
if filing_prefix:
IDossierArchiver(self.context).update_prefix(filing_prefix)
# If everything went well, resolve the main dossier
resolver.resolve(end_date=end_date)
self.ptool.addPortalMessage(_("The Dossier has been resolved"),
type="info")
return self.request.RESPONSE.redirect(self.context.absolute_url())
@button.buttonAndHandler(_(u'button_cancel', default=u'Cancel'))
def cancel(self, action):
return self.request.RESPONSE.redirect(self.context.absolute_url())
class FieldAddForm(AutoExtensibleForm, form.AddForm):
fields = field.Fields(interfaces.INewField)
label = _("Add new field")
id = 'add-field-form'
# This is a trick: we want autoform to handle the additionalSchemata,
# but want to provide our own base schema below in updateFields.
schema = Interface
@lazy_property
def _schema(self):
return interfaces.INewField
@lazy_property
def additionalSchemata(self):
return [
v for k, v in getAdapters((
self.context, ), interfaces.IFieldEditorExtender)
]
def create(self, data):
extra = {}
factory = data.pop('factory')
all = data.keys()
# split regular attributes and extra ones
for key in all:
if key not in self._schema:
extra[key] = data[key]
data.pop(key)
# create the field with regular attributes
field_obj = factory(**data)
# set the extra attributes using the proper adapter
for schemata in self.additionalSchemata:
for key in extra:
(interface_name, property_name) = key.split('.')
if interface_name != schemata.__name__:
continue
setattr(schemata(field_obj), property_name, extra[key])
return field_obj
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 nextURL(self):
return "@@add-field"
class NewsletterSubscriberForm(extensible.ExtensibleForm, form.Form):
fields = field.Fields(INewsletterSubscribe)
ignoreContext = True
id = "newsletter-subscriber-form"
label = _(u"Subscribe to newsletter")
def updateActions(self):
super(NewsletterSubscriberForm, self).updateActions()
self.actions['subscribe'].addClass('context')
def updateFields(self):
super(NewsletterSubscriberForm, self).updateFields()
self.fields['interest_groups'].widgetFactory = \
CheckBoxFieldWidget
self.fields['email_type'].widgetFactory = \
RadioFieldWidget
def updateWidgets(self):
super(NewsletterSubscriberForm, self).updateWidgets()
# Show/hide mail format option widget
registry = getUtility(IRegistry)
mailchimp_settings = registry.forInterface(IMailchimpSettings)
if not mailchimp_settings.email_type_is_optional:
self.widgets['email_type'].mode = HIDDEN_MODE
# Retrieve the list id either from the request/form or fall back to
# the default_list setting.
if 'list_id' in self.context.REQUEST:
list_id = self.context.REQUEST['list_id']
elif 'form.widgets.list_id' in self.request.form:
list_id = self.request.form['form.widgets.list_id']
else:
list_id = mailchimp_settings.default_list
self.widgets['list_id'].mode = HIDDEN_MODE
self.widgets['list_id'].value = list_id
# Show/hide interest_groups widget
mailchimp = getUtility(IMailchimpLocator)
groups = mailchimp.groups(list_id=list_id)
if not groups:
self.widgets['interest_groups'].mode = HIDDEN_MODE
if 'preselect_group' in self.context.REQUEST:
for group_index in self.request['preselect_group']:
group_index = int(group_index)
self.widgets['interest_groups']\
.items[group_index]['checked'] = True
@button.buttonAndHandler(_(u"subscribe_to_newsletter_button",
default=u"Subscribe"),
name='subscribe')
def handleApply(self, action):
data, errors = self.extractData()
if 'email' not in data:
return
mailchimp = getUtility(IMailchimpLocator)
# Retrieve list_id either from a hidden field in the form or fetch
# the first list from mailchimp.
if 'list_id' in data and data['list_id'] is not None:
list_id = data['list_id']
else:
list_id = mailchimp.default_list_id()
# Groupings
interests = {}
if 'interest_groups' in data and data['interest_groups'] is not None:
interest_grouping = mailchimp.groups(list_id=list_id)
if interest_grouping and data['interest_groups']:
# Create dictionary with as keys the interest groups, and as
# values always True.
interests = dict.fromkeys(data['interest_groups'], True)
# Use email_type if one is provided by the form, if not choose the
# default email type from the control panel settings.
if 'email_type' in data:
email_type = data['email_type']
else:
email_type = 'HTML'
# Subscribe to MailChimp list
try:
mailchimp.subscribe(
list_id=list_id,
email_address=data['email'],
email_type=email_type,
interests=interests
)
except MailChimpException as error:
return self.handle_error(error, data)
registry = getUtility(IRegistry)
mailchimp_settings = registry.forInterface(IMailchimpSettings)
if mailchimp_settings.double_optin:
message = _(
u"We have to confirm your email address. In order to " +
u"finish the newsletter subscription, click on the link " +
u"inside the email we just send you.")
else:
message = _(
u"You have been subscribed to our newsletter succesfully.")
IStatusMessage(self.context.REQUEST).addStatusMessage(
message, type="info")
portal = getSite()
self.request.response.redirect(portal.absolute_url())
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)
)
class FlourishCategoryEditView(flourish.form.Form, form.EditForm):
legend = _('Category')
fields = field.Fields(ICategoryEditForm)
data = None
def nextURL(self):
return absoluteURL(self.context, self.request)
@button.buttonAndHandler(_('Submit'), name='submit')
def handleSubmit(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
changes = self.applyChanges(data)
category = self.data['category']
if (changes and category and category in self.context):
# XXX: stupid Zope.
del self.context[category]
self.context[category] = self.data['title']
self.status = self.successMessage
else:
self.status = self.noChangesMessage
self.request.response.redirect(self.nextURL())
@button.buttonAndHandler(_('Make Default'), name='make_default')
def handleMakeDefault(self, action):
data, errors = self.extractData()
category = data['category']
if (category and category in self.context):
self.context.default_key = category
self.request.response.redirect(self.nextURL())
@button.buttonAndHandler(_('Cancel'))
def handle_cancel_action(self, action):
self.request.response.redirect(self.nextURL())
def getContent(self):
return self.data
def update(self):
self.data = {}
self.data['category'] = self.request.get('category', '')
if self.data['category']:
self.data['title'] = removeSecurityProxy(
self.context.get(self.data['category']))
# XXX: ContainedProxy fails on unicode(title)
# when there are non-ascii characters
# so we get a real unicode object here
if self.data['title'] is not None:
title = self.data['title']
self.data['title'] = title.encode('utf-8').decode('utf-8')
if self.context.default_key == self.data['category']:
self.data['default'] = True
else:
self.data['title'] = None
super(FlourishCategoryEditView, self).update()
self.widgets['category'].mode = HIDDEN_MODE
def updateActions(self):
super(FlourishCategoryEditView, self).updateActions()
self.actions['submit'].addClass('button-ok')
self.actions['make_default'].addClass('button-ok')
self.actions['cancel'].addClass('button-cancel')
class EditAdmUtilSimple1Form(EditForm):
""" Edit for for net """
label = _(u'edit simple scanner')
fields = field.Fields(IAdmUtilSimple1).omit(\
*AdmUtilSimple1Details.omit_editfields)
class DefaultSchemata(DS):
""" Schemata default
"""
fields = field.Fields(IAlphabeticSchema).select(u'title', u'default',
u'index')
class EditAdmUtilEsxVimForm(EditForm):
""" Edit for for net """
label = _(u'edit esx_vim')
fields = field.Fields(IAdmUtilEsxVim).omit(\
*AdmUtilEsxVimDetails.omit_editfields)
class AuthorFeedbackForm(form.Form):
fields = field.Fields(IAuthorFeedbackForm)
ignoreContext = True
@button.buttonAndHandler(_(u'label_send', default='Send'),
name='send')
def handle_send(self, action):
self.portal_state = getMultiAdapter(
(self.context, self.request),
name=u'plone_portal_state'
)
self.portal = self.portal_state.portal()
self.membership_tool = getToolByName(
self.context, 'portal_membership'
)
self.feedback_template = self.context.restrictedTraverse(
'@@author-feedback-template'
)
data, errors = self.extractData()
if errors:
IStatusMessage(self.request).addStatusMessage(
self.formErrorsMessage,
type=u'error'
)
return
referer = data.get('referer', 'unknown referer')
subject = data.get('subject', '')
message = data.get('message', '')
# Author is None means portal administrator
author = data.get('author', None)
sender = self.portal_state.member()
registry = getUtility(IRegistry)
mail_settings = registry.forInterface(IMailSchema, prefix='plone')
envelope_from = mail_settings.email_from_address
if author is None:
send_to_address = mail_settings.email_from_address
else:
author_member = self.membership_tool.getMemberById(author)
send_to_address = author_member.getProperty('email')
send_from_address = sender.getProperty('email')
if send_from_address == '':
IStatusMessage(self.request).addStatusMessage(
_(u'Could not find a valid email address'),
type=u'error'
)
return
sender_id = "%s (%s), %s" % (
sender.getProperty('fullname'),
sender.getId(),
send_from_address
)
mail_host = getUtility(IMailHost)
registry = getUtility(IRegistry)
email_charset = registry.get('plone.email_charset', 'utf-8')
try:
message = self.feedback_template(
self, send_from_address=send_from_address,
sender_id=sender_id, url=referer, subject=subject,
message=message, encoding=email_charset,
email_from_name=mail_settings.email_from_name
)
message = message.encode(email_charset)
mail_host.send(
message, send_to_address, envelope_from,
subject=subject, charset=email_charset
)
except ConflictError:
raise
except Exception as e:
logger.info("Unable to send mail: " + str(e))
IStatusMessage(self.request).addStatusMessage(
_(u'Unable to send mail.'),
type=u'error'
)
return
IStatusMessage(self.request).addStatusMessage(
_(u'Mail sent.'),
type=u'info'
)
self.request.response.redirect('%s/author/%s' % (
self.portal.absolute_url(),
author or ''))
return
class AddHostForm(AddForm):
"""Add form."""
label = _(u'Add VMware Virtual Machine')
fields = field.Fields(IHostVMwareVm).omit(*HostDetails.omit_addfields)
factory = Host
class RedirectsControlPanelForm(form.EditForm):
fields = field.Fields(IAliasesSchema)
class LoginForm(form.EditForm):
""" Implementation of the login form """
fields = field.Fields(ILoginFormSchema)
id = 'LoginForm'
label = _('label_log_in', default=u'Log in')
ignoreContext = True
prefix = ''
def render(self):
registry = queryUtility(IRegistry)
ext_login_url = registry['plone.external_login_url']
if ext_login_url:
return self._handle_external_login(ext_login_url)
return self.index()
def _handle_external_login(self, url):
"""Handle login on this portal where login is external."""
next_ = self.request.get('next', None)
portal_url = getToolByName(self.context, 'portal_url')
if next_ is not None and not portal_url.isURLInPortal(next_):
next_ = None
if next_ is not None:
url = '{0}?next={1}'.format(url, next_)
came_from = self.request.get('came_from')
if came_from:
url = '{0}&came_from={1}'.format(url, came_from)
self.request.response.redirect(url)
def _get_auth(self):
try:
return self.context.acl_users.credentials_cookie_auth
except AttributeError:
try:
return self.context.cookie_authentication
except AttributeError:
pass
def updateWidgets(self):
auth = self._get_auth()
if auth:
fieldname_name = auth.get('name_cookie', '__ac_name')
fieldname_password = auth.get('pw_cookie', '__ac_password')
else:
fieldname_name = '__ac_name'
fieldname_password = '******'
self.fields['ac_name'].__name__ = fieldname_name
self.fields['ac_password'].__name__ = fieldname_password
super(LoginForm, self).updateWidgets(prefix='')
if self.use_email_as_login():
self.widgets[fieldname_name].label = _(u'label_email',
default=u'Email')
self.widgets['came_from'].mode = HIDDEN_MODE
self.widgets['came_from'].value = self.get_came_from()
def get_came_from(self):
came_from = self.request.get('came_from', None)
if not came_from:
came_from = self.request.get('HTTP_REFERER', None)
if not came_from:
return
url_tool = getToolByName(self.context, 'portal_url')
if not url_tool.isURLInPortal(came_from):
return
came_from_path = parse.urlparse(came_from)[2]
for login_template_id in LOGIN_TEMPLATE_IDS:
if login_template_id in came_from_path:
return
return came_from
def updateActions(self):
super(LoginForm, self).updateActions()
self.actions['login'].addClass('context')
def _post_login(self):
membership_tool = getToolByName(self.context, 'portal_membership')
member = membership_tool.getAuthenticatedMember()
must_change_password = member.getProperty('must_change_password', 0)
login_time = member.getProperty('login_time', '2000/01/01')
if not isinstance(login_time, DateTime):
login_time = DateTime(login_time)
is_initial_login = login_time == DateTime('2000/01/01')
membership_tool.loginUser(self.request)
if is_initial_login:
self.handle_initial_login()
if must_change_password:
self.force_password_change()
return is_initial_login
@button.buttonAndHandler(_('Log in'), name='login')
def handleLogin(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
membership_tool = getToolByName(self.context, 'portal_membership')
status_msg = IStatusMessage(self.request)
if membership_tool.isAnonymousUser():
self.request.response.expireCookie('__ac', path='/')
if self.use_email_as_login():
status_msg.addStatusMessage(
_(
u'Login failed. Both email address and password are '
u'case sensitive, check that caps lock is not enabled.'
),
'error',
)
else:
status_msg.addStatusMessage(
_(
u'Login failed. Both login name and password are case '
u'sensitive, check that caps lock is not enabled.'
),
'error',
)
return
is_initial_login = self._post_login()
status_msg.addStatusMessage(
_(
u'you_are_now_logged_in',
default=u'Welcome! You are now logged in.',
),
'info'
)
came_from = data.get('came_from', None)
self.redirect_after_login(came_from, is_initial_login)
def handle_initial_login(self):
handler = queryMultiAdapter(
(self.context, self.request),
IInitialLogin,
)
if handler:
handler()
def force_password_change(self):
handler = queryMultiAdapter(
(self.context, self.request),
IForcePasswordChange,
)
if handler:
handler()
def redirect_after_login(self, came_from=None, is_initial_login=False):
adapter = queryMultiAdapter(
(self.context, self.request),
IRedirectAfterLogin
)
if adapter:
came_from = adapter(came_from, is_initial_login)
if not came_from:
came_from = self.context.absolute_url()
self.request.response.redirect(came_from)
def self_registration_enabled(self):
registry = queryUtility(IRegistry)
security_settings = registry.forInterface(
ISecuritySchema,
prefix='plone'
)
return security_settings.enable_self_reg
def use_email_as_login(self):
registry = queryUtility(IRegistry)
security_settings = registry.forInterface(
ISecuritySchema,
prefix='plone'
)
return security_settings.use_email_as_login
class EasySliderSettingsForm(form.EditForm):
"""
The page that holds all the slider settings
"""
fields = field.Fields(ISliderSettings)
