def __init__(self, context, request):
# xxx usually a super is the way to go here? why not?
Tile.__init__(self, context, request)
WidgetsView.__init__(self, context, request)
try:
self.field = self.data['field'].split('-', 1)[-1]
except KeyError:
self.field = None
return
# Omit all the fields except rendered field to save time, because
# autoform update will only add fields not in self.fields.
if self.field in self.schema:
self.fields = Fields(self.schema).omit(self.field)
else:
self.fields = Fields(self.schema).omit(self.schema.names())
for schema in self.additionalSchemata:
if self.field in schema:
self.field = '%s.%s' % (schema.__name__, self.field)
self.fields += Fields(
schema,
prefix=schema.__name__
).omit(self.field)
self._additionalSchemata = (schema,)
return
def update(self): # pragma: no cover
super(TreatingGroupBatchActionForm, self).update()
#voc = getAvailableTreatingGroupVoc(brains_from_uids(self.request.form['form.widgets.uids']))
im_fields = Fields(IImioDmsIncomingMail)
self.fields += im_fields.select('treating_groups')
task_fields = Fields(ITask)
self.fields += task_fields.select('assigned_user')
fld = self.fields['treating_groups'].field
fld.slave_fields[0]['name'] = 'assigned_user'
fld.slave_fields[0]['slaveID'] = '#form-widgets-assigned_user'
super(DashboardBatchActionForm, self).update()
def get_fields(self):
if getattr(self, '_fields', None) is not None:
return self._fields
fields = Fields(*self.schemas)
fields['responsible'].widgetFactory[INPUT_MODE] = ParameterizedWidget(
KeywordWidget,
async=True
)
fields['checked_out'].widgetFactory[INPUT_MODE] = ParameterizedWidget(
KeywordWidget,
async=True
)
fields['issuer'].widgetFactory[INPUT_MODE] = ParameterizedWidget(
KeywordWidget,
async=True
)
fields['object_provides'].widgetFactory[INPUT_MODE] \
= radio.RadioFieldWidget
fields['dossier_review_state'].widgetFactory[INPUT_MODE] \
= checkbox.CheckBoxFieldWidget
fields['task_review_state'].widgetFactory[INPUT_MODE] \
= checkbox.CheckBoxFieldWidget
date_fields = [
'start_1',
'start_2',
'end_1',
'end_2',
'deadline_1',
'deadline_2',
'receipt_date_1',
'receipt_date_2',
'delivery_date_1',
'delivery_date_2',
'document_date_1',
'document_date_2',
]
for field in date_fields:
fields.get(
field).widgetFactory[INPUT_MODE] = DatePickerFieldWidget
self._fields = fields
self.move_fields()
return self._fields
class A11MonitoringProgrammeForm(EmbeddedForm):
record_title = 'Article 11 (Monitoring Programmes)'
title = "2014 Monitoring strategies (programmes)"
# mru_class = A11MProgMarineUnitIdForm
mru_class = A11MonProgDisplay
session_name = '2012'
fields = Fields(interfaces.IRegionSubregions)
fields['region_subregions'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
return A11MProgMemberStateForm(self, self.request)
def get_monitoring_programme_ids(self):
regions = self.data.get('region_subregions', [])
countries = self.subform.data.get('member_states', [])
marine_unit_id = self.subform.subform.data.get('marine_unit_ids', [])
# mp_type_ids = self.context.get_mp_type_ids()
mon_ids = db.get_unique_from_mapper(
sql.MSFD11MON, 'ID',
and_(
sql.MSFD11MON.MemberState.in_(countries),
sql.MSFD11MON.Region.in_(regions),
sql.MSFD11MON.Import.in_(
self.context.get_latest_import_ids())))
mon_prog_ids_from_MP = db.get_unique_from_mapper(
sql.MSFD11MP,
'MonitoringProgramme',
and_(
sql.MSFD11MP.MON.in_(mon_ids),
# sql.MSFD11MP.MPType.in_(mp_type_ids),
sql.MSFD11MP.MonitoringProgramme.isnot(None)))
mon_prog_ids_from_MP = [int(elem) for elem in mon_prog_ids_from_MP]
count, mon_prog_ids = db.get_all_records_outerjoin(
sql.MSFD11MonitoringProgrammeMarineUnitID, sql.MSFD11MarineUnitID,
sql.MSFD11MarineUnitID.MarineUnitID.in_(marine_unit_id))
mon_prog_ids = [row.MonitoringProgramme for row in mon_prog_ids]
# result = tuple(set(mon_prog_ids_from_MP) & set(mon_prog_ids))
result = tuple(set(mon_prog_ids_from_MP))
if not result:
# result = tuple(mon_prog_ids_from_MP + mon_prog_ids)
result = tuple(mon_prog_ids_from_MP)
return result
def get_mp_type_ids(self):
# used by vocabularies, easier to pass from context
return self.context.get_mp_type_ids()
class StartArticle102012Form(EmbeddedForm):
title = "2012 reporting exercise"
permission = "zope2.View"
session_name = "2012"
fields = Fields(interfaces.IReportTypeArt10)
def get_subform(self):
klass = self.get_form_data_by_key(self, 'report_type')
return klass(self, self.request)
class ChooseDossierStepForm(AcceptWizardFormMixin, Form):
fields = Fields(IChooseDossierSchema)
step_name = 'accept_choose_dossier'
steps = (
('accept_choose_method', _(u'step_1', default=u'Step 1')),
('accept_choose_dossier', _(u'step_2', default=u'Step 2')),
)
@buttonAndHandler(_(u'button_save', default=u'Save'), name='save')
def handle_continue(self, action):
data, errors = self.extractData()
if not errors:
oguid = self.request.get('oguid')
key = 'accept:%s' % oguid
dm = getUtility(IWizardDataStorage)
text = dm.get(key, 'text')
# forwarding
if dm.get(key, 'is_forwarding'):
if dm.get(key, 'is_only_assign'):
task = assign_forwarding_to_dossier(
self.context, oguid, data['dossier'], text)
IStatusMessage(self.request).addStatusMessage(
_(u'The forwarding is now assigned to the dossier'),
'info')
self.request.RESPONSE.redirect('%s/edit' %
task.absolute_url())
else:
task = accept_forwarding_with_successor(
self.context, oguid, text, dossier=data['dossier'])
IStatusMessage(self.request).addStatusMessage(
_(u'The forwarding has been stored in the local inbox '
u'and the succesor task has been created'), 'info')
self.request.RESPONSE.redirect('%s/edit' %
task.absolute_url())
# task
else:
task = accept_task_with_successor(data['dossier'], oguid, text)
IStatusMessage(self.request).addStatusMessage(
_(u'The task has been copied to the selected dossier and '
u'accepted.'), 'info')
self.request.RESPONSE.redirect(task.absolute_url())
@buttonAndHandler(_(u'button_cancel', default=u'Cancel'), name='cancel')
def handle_cancel(self, action):
portal_url = getToolByName(self.context, 'portal_url')
url = '%s/resolve_oguid?oguid=%s' % (portal_url(),
self.request.get('oguid'))
return self.request.RESPONSE.redirect(url)
class MultiItemDisplayForm(ItemDisplayForm):
template = ViewPageTemplateFile('pt/multi-item-display.pt')
fields = Fields(interfaces.IRecordSelect)
def get_sections(self):
klasses = get_registered_form_sections(self)
views = [k(self, self.request) for k in klasses]
return views
class StartArticle14Form(MainForm):
record_title = title = 'Article 14 - Exceptions'
report_type = "Exceptions"
session_name = '2012'
name = 'msfd-a14'
fields = Fields(interfaces.IArticles1314Region)
fields['region_subregions'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
return MemberStatesForm(self, self.request)
def update(self):
self.paths = self.request.form.get('paths') or self.request.form.get(
'form.widgets.paths')
if self.paths is None:
message = _(u'select_items_to_archive',
default=u'Select the content items to be archived.')
IStatusMessage(self.request).addStatusMessage(message, type='info')
url = '{}/folder_contents'.format(self.context.absolute_url())
return self.request.response.redirect(url)
self.fields += Fields(paths_field)
return super(ConvertForm, self).update()
def updateFields(self):
super(SecurityControlPanelForm, self).updateFields()
self.fields['restrict_logins_to_countries'].widgetFactory = SelectFieldWidget
timeout = api.portal.get().acl_users.session.timeout
timeout_field = Int(__name__='session_timeout',
title=u'Session Timeout',
description=u'Duration of user session timeout '
u'(seconds)',
required=False,
default=timeout)
self.fields += Fields(timeout_field)
class A9Form(EmbeddedForm):
""" Select the MarineUnitID for the Article 9 form
"""
fields = Fields(IA2012GesComponentsArt9)
fields['ges_components'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
# return A9MRUForm(self, self.request)
return AreaTypesFormArt9(self, self.request)
class EditArchivalFileForm(DefaultEditForm):
schema = None
fields = Fields(IDocumentMetadata).select('archival_file')
label = _(u'label_change_archival_file', default=u'Change archival file')
def update(self):
user = api.user.get_current()
if not can_access_archival_file_form(user, self.context):
raise Unauthorized('You cannot access this resource.')
super(EditArchivalFileForm, self).update()
def _update(self):
self.voc = self.get_available_assigneduser_voc()
self.do_apply = is_permitted(self.brains)
self.fields += Fields(
schema.Choice(
__name__='assigned_user',
title=_(u'Assigned user'),
vocabulary=self.do_apply and self.voc or SimpleVocabulary([]),
description=((len(self.voc) <= 1 and self.err_msg)
or (not self.do_apply and cannot_modify_field_msg)
or u''),
required=self.do_apply))
def _update(self):
self.voc = self.available_folders_voc()
self.do_apply = len(self.voc) > 0
self.fields += Fields(schema.List(
__name__='folders',
title=_(u'Folders'),
value_type=schema.Choice(vocabulary=self.voc),
description=(self.do_apply and
_(u'Select multiple values (CTRL+click)') or
_(u'No folder available where you can add templates.')),
required=self.do_apply))
self.fields["folders"].widgetFactory = SelectFieldWidget
class WebactionForm(Form):
ignoreContext = True
fields = Fields(IWebActionSchema)
def update(self):
self.request.set('disable_border', True)
super(WebactionForm, self).update()
@property
def main_url(self):
return self.context.absolute_url() + '/@@manage-webactions'
def setupFields(self):
# copied from z3c.form 3.2.10
rv = Fields(self.__parent__.field.schema)
# own code:
if hasattr(self.parentForm, 'datagridInitialise'):
self.parentForm.datagridInitialise(self,
self.__parent__.__parent__)
elif hasattr(self.parentForm.__parent__, 'datagridInitialise'):
self.parentForm.__parent__.datagridInitialise(
self, self.__parent__.__parent__)
return rv
def _update(self):
self.do_apply = is_permitted(self.brains)
self.fields += Fields(
schema.Choice(
__name__='assigned_group',
title=_(u"Assigned group"),
description=(not self.do_apply and cannot_modify_field_msg
or u''),
required=(self.do_apply),
vocabulary=self.do_apply and u'collective.task.AssignedGroups'
or SimpleVocabulary([]),
))
class IssueKeyForm(BaseForm):
label = _(u'Issue Service Key')
description = _(u'Issue a key to be used for authentication '
u'by a service application')
fields = Fields(IKeyMetadataSchema).select('title', 'ip_range')
download_key_template = ViewPageTemplateFile('download_key.pt')
@button.buttonAndHandler(_(u'Issue key'), name='save')
def handleApply(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
user_id = api.user.get_current().id
private_key, service_key = self.get_plugin().issue_keypair(
user_id, data['title'], data['ip_range'])
self._key_issued = True
self._generated_private_key = private_key
self._generated_service_key = service_key
msg = _('Key created: ${key_id}',
mapping={'key_id': service_key['key_id']})
api.portal.show_message(msg, getRequest())
@button.buttonAndHandler(_(u'Cancel'), name='cancel')
def handleCancel(self, action):
api.portal.show_message(_(u'Key creation cancelled.'), getRequest())
return self.request.RESPONSE.redirect(self.main_url)
def render(self):
if getattr(self, '_key_issued', False) is True:
# We carry over the newly issued key in these attributes on the
# view to offer the private key for download exactly once.
private_key = self._generated_private_key
service_key = self._generated_service_key
del self._generated_private_key
json_keyfile = create_json_keyfile(private_key, service_key)
template_vars = {
'key_id': service_key['key_id'],
'title': service_key['title'],
'json_keyfile': json_keyfile,
}
return self.download_key_template(**template_vars)
return super(IssueKeyForm, self).render()
class CopyRelatedDocumentsForm(Form):
fields = Fields(ICopyRelatedDocumentsSchema)
label = _(u'title_copy_releated_documents',
default=u'Copy related documents')
ignoreContext = True
@buttonAndHandler(_(u'button_copy', default=u'Copy'))
def handle_copy(self, action):
data, errors = self.extractData()
if not self.available():
IStatusMessage(self.request).addStatusMessage(
_(u'error_copying_related_documents_not_possible',
default=u"It's not possible to copy related documents."))
if not errors and data['copy_documents']:
self.copy_documents(data['target_client'])
info = getUtility(IContactInformation)
client = info.get_client_by_id(data['target_client'])
IStatusMessage(self.request).addStatusMessage(_(
u'info_copied_related_documents',
default=u'All related documents were copied to the inbox of '
'the client ${client}.',
mapping=dict(client=client.title)),
type='info')
if not errors:
return self.request.RESPONSE.redirect(self.context.absolute_url())
def copy_documents(self, client_id):
transporter = getUtility(ITransporter)
for doc in self.get_documents():
transporter.transport_to(doc, client_id, 'eingangskorb')
def get_documents(self):
# find documents within the task
brains = self.context.getFolderContents(
full_objects=False,
contentFilter={'portal_type': 'opengever.document.document'})
for doc in brains:
yield doc.getObject()
# find referenced documents
relatedItems = getattr(self.context, 'relatedItems', None)
if relatedItems:
for rel in self.context.relatedItems:
yield rel.to_object
def available(self):
voc = getUtility(IVocabularyFactory,
'opengever.task.TargetClientsWithInboxVocabulary')
if not len(voc(self.context)):
return False
elif self.context.task_type_category != 'uni_val':
return False
else:
return True
class SpeciesOccurrenceAddForm(BCCVLUploadForm):
title = u"Upload Species Occurrence Data"
description = (
u"<p>Upload occurrences data for single species</p>"
u"<p>An occurrence dataset is expected to be in CSV format."
u" BCCVL will only try to interpret columns with labels"
u" 'lon' and 'lat'.</p>")
fields = Fields(IBlobDataset, IDublinCore, ISpeciesDataset).select(
'file', 'title', 'description', 'scientificName', 'taxonID',
'vernacularName', 'rightsstatement')
datagenre = 'DataGenreSpeciesOccurrence'
class CommentExtender(extensible.FormExtender):
fields = Fields(ICommentExtenderFields)
def __init__(self, context, request, form):
self.context = context
self.request = request
self.form = form
def update(self):
self.add(ICommentExtenderFields, prefix="")
self.move("attachment", after="text", prefix="")
def get_fields(self):
if getattr(self, '_fields', None) is not None:
return self._fields
fields = Fields(*self.schemas)
fields['responsible'].widgetFactory[INPUT_MODE] = ParameterizedWidget(
KeywordWidget, async=True)
fields['checked_out'].widgetFactory[INPUT_MODE] = ParameterizedWidget(
KeywordWidget, async=True)
fields['issuer'].widgetFactory[INPUT_MODE] = ParameterizedWidget(
KeywordWidget, async=True)
fields['object_provides'].widgetFactory[INPUT_MODE] \
= radio.RadioFieldWidget
fields['dossier_review_state'].widgetFactory[INPUT_MODE] \
= checkbox.CheckBoxFieldWidget
fields['task_review_state'].widgetFactory[INPUT_MODE] \
= checkbox.CheckBoxFieldWidget
date_fields = [
'start_1',
'start_2',
'end_1',
'end_2',
'deadline_1',
'deadline_2',
'receipt_date_1',
'receipt_date_2',
'delivery_date_1',
'delivery_date_2',
'document_date_1',
'document_date_2',
]
for field in date_fields:
fields.get(field).widgetFactory[INPUT_MODE] = DatePickerFieldWidget
self._fields = fields
self.move_fields()
return self._fields
def _update(self):
assert self.attribute
assert self.field_value_type is not None
self.do_apply = is_permitted(self.brains)
self.fields += Fields(
schema.Choice(
__name__='action_choice',
title=_(u'Batch action choice'),
description=(not self.do_apply and cannot_modify_field_msg
or u''),
vocabulary=SimpleVocabulary([
SimpleTerm(value=u'add', title=_(u'Add items')),
SimpleTerm(value=u'remove', title=_(u'Remove items')),
SimpleTerm(value=u'replace',
title=_(u'Replace some items by others')),
SimpleTerm(value=u'overwrite', title=_(u'Overwrite'))
]),
required=self.do_apply,
default=u'add'))
if self.do_apply:
self.fields += Fields(
ContactList(
__name__='removed_values',
title=_(u"Removed values"),
description=_(
u"Search and select the values to remove, if necessary."
),
required=False,
addlink=False,
value_type=self.field_value_type,
))
self.fields += Fields(
ContactList(
__name__='added_values',
title=_(u"Added values"),
description=_(u"Search and select the values to add."),
required=False,
addlink=False,
value_type=self.field_value_type,
))
class ChooseDossierStepForm(CloseTaskWizardStepFormMixin, Form):
fields = Fields(IChooseDossierSchema)
step_name = 'close-task-wizard_choose-dossier'
@buttonAndHandler(_(u'button_save', default=u'Save'), name='save')
def handle_save(self, action):
data, errors = self.extractData()
if not errors:
query = getUtility(ITaskQuery)
info = getUtility(IContactInformation)
dm = getUtility(IWizardDataStorage)
oguid = self.request.get('oguid')
dmkey = 'close:%s' % oguid
task = query.get_task_by_oguid(oguid)
client = info.get_client_by_id(task.client_id)
self.copy_documents(task, data['dossier'],
dm.get(dmkey, 'documents'))
redirect_data = {
'oguid': oguid,
'redirect_url':
'%s#documents' % (data['dossier'].absolute_url())
}
url = '/'.join((client.public_url, '@@close-task-wizard_close?%s' %
urllib.urlencode(redirect_data)))
return self.request.RESPONSE.redirect(url)
@buttonAndHandler(_(u'button_cancel', default=u'Cancel'), name='cancel')
def handle_cancel(self, action):
portal_url = getToolByName(self.context, 'portal_url')
url = '%s/resolve_oguid?oguid=%s' % (portal_url(),
self.request.get('oguid'))
return self.request.RESPONSE.redirect(url)
def copy_documents(self, task, dossier, documents):
doc_transporter = getUtility(ITaskDocumentsTransporter)
with CustomInitialVersionMessage(
_(u'version_message_closed_task',
default=u'Document copied from task (task closed)'),
dossier.REQUEST):
intids_mapping = doc_transporter.copy_documents_from_remote_task(
task, dossier, documents=documents)
IStatusMessage(self.request).addStatusMessage(
_(u'${num} documents were copied.',
mapping={'num': len(intids_mapping)}), 'info')
class CommentExtender(extensible.FormExtender):
adapts(Interface, IDefaultBrowserLayer, CommentForm)
fields = Fields(ICommentExtenderFields)
def __init__(self, context, request, form):
self.context = context
self.request = request
self.form = form
def update(self):
self.add(ICommentExtenderFields, prefix="")
self.move('attachment', after='text', prefix="")
class StartArticle18Form(EmbeddedForm):
""" Start form for Article 18 - 2019 reporting year
"""
record_title = title = 'Article 18 - Progress on the implementation of PoM'
session_name = '2018'
fields = Fields(interfaces.IStartArticle18)
def get_subform(self):
klass = self.data.get('data_type')
return klass(self, self.request)
class Article192012(EmbeddedForm):
""" Article 19 reporting year 2012
"""
title = '2012 reporting exercise'
session_name = '2012'
fields = Fields(interfaces.IRegionSubregionsArt19)
fields['region_subregions'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
return Article19MemberStates(self, self.request)
class ChooseDossierStepForm(CloseTaskWizardStepFormMixin, Form):
fields = Fields(IChooseDossierSchema)
step_name = 'close-task-wizard_choose-dossier'
@buttonAndHandler(_(u'button_save', default=u'Save'), name='save')
def handle_save(self, action):
data, errors = self.extractData()
if not errors:
oguid = self.request.get('oguid')
dm = getUtility(IWizardDataStorage)
dmkey = 'close:%s' % oguid
task = Task.query.by_oguid(oguid)
self.copy_documents(task, data['dossier'],
dm.get(dmkey, 'documents'))
self.close_task(task, dm.get(dmkey, 'text'))
return self.request.RESPONSE.redirect('{}#documents'.format(
data['dossier'].absolute_url()))
@buttonAndHandler(_(u'button_cancel', default=u'Cancel'), name='cancel')
def handle_cancel(self, action):
portal_url = getToolByName(self.context, 'portal_url')
url = '%s/resolve_oguid?oguid=%s' % (portal_url(),
self.request.get('oguid'))
return self.request.RESPONSE.redirect(url)
def close_task(self, task, text):
response = dispatch_request(
task.admin_unit_id,
u'@@close-task-wizard-remote_close',
path=task.physical_path,
data={'text': text.encode('utf-8') if text else u''})
response_data = response.read().strip()
if response_data != 'OK':
raise Exception('Could not close task on remote site %s (%s)' %
(task.admin_unit_id, task.physical_path))
def copy_documents(self, task, dossier, documents):
doc_transporter = getUtility(ITaskDocumentsTransporter)
comment = _(u'version_message_closed_task',
default=u'Document copied from task (task closed)')
intids_mapping = doc_transporter.copy_documents_from_remote_task(
task, dossier, documents=documents, comment=comment)
IStatusMessage(self.request).addStatusMessage(
_(u'${num} documents were copied.',
mapping={'num': len(intids_mapping)}), 'info')
def update(self):
if interfaces.IFormAware.providedBy(self) \
and not hasattr(self.form, self.name):
#FIXME None for add form, widget.context.? for editform
#FIXME: use a factory to create the subform, to be able
# to derive it from things like AddFormLayoutSupport
subform = EditSubForm(None, self.request, self.form)
subform.fields = Fields(self.field.schema)
setattr(self.form, self.field.__name__, subform)
zope.interface.alsoProvides(self, interfaces.ISubformAware)
self.subform = subform
if interfaces.ISubformAware.providedBy(self):
self.subform.update()
super(ObjectWidget, self).update()
class A11MonitoringProgrammeForm2020(EmbeddedForm):
record_title = 'Article 11 (Monitoring Programmes) - 2020'
title = "2020 Monitoring programmes"
session_name = '2018'
fields = Fields(interfaces.IRegionSubregionsArt112020)
fields['region_subregions'].widgetFactory = CheckBoxFieldWidget
@property
def display_class(self):
return A11MProgrammeDisplay2020
def get_subform(self):
return A11MProgrammeMemberStateForm2020(self, self.request)
class CloseCurrentPeriodStep(BaseWizardStepForm, ModelEditForm):
"""Form to close the current period.
First part of a two-step wizard. Stores its data in IIWizardStorage when
submitted.
"""
step_name = 'close-period'
label = _('Close period')
step_title = _('Close currently active period')
steps = CLOSE_PERIOD_STEPS
fields = Fields(IPeriodModel)
fields['date_from'].widgetFactory = DatePickerFieldWidget
fields['date_to'].widgetFactory = DatePickerFieldWidget
def __init__(self, context, request):
self.committee = context.load_model()
model = Period.query.get_current(self.committee)
super(CloseCurrentPeriodStep, self).__init__(context, request, model)
def get_edit_values(self, keys):
return self.model.get_edit_values(keys)
def partition_data(self, data):
obj_data, model_data = {}, data
return obj_data, model_data
def update_model(self, model_data):
self.model.update_model(model_data)
@buttonAndHandler(_(u'button_close_period', default=u'Close period'),
name='save')
def handle_continue(self, action):
data, errors = self.extractData()
if errors:
return
dm = getUtility(IWizardDataStorage)
dm.update(get_dm_key(self.committee), data)
return self.request.RESPONSE.redirect('{}/add-period'.format(
self.context.absolute_url()))
@buttonAndHandler(_(u'button_cancel', default=u'Cancel'))
def handle_cancel(self, action):
return self.request.RESPONSE.redirect(self.context.absolute_url())
def nextURL(self):
return self._created_object.get_url()
class ContactFormExtender(extensible.FormExtender):
fields = Fields(IContactFormExtenderFields)
ignoreContext = True
def __init__(self, context, request, form):
self.context = context
self.request = request
self.form = form
def update(self):
self.add(IContactFormExtenderFields, prefix='')
self.move('captcha', after='message', prefix='')
self.form.fields['captcha'].widgetFactory = ReCaptchaFieldWidget
class SelectTaskTemplateFolderWizardStep(BaseWizardStepForm, Form):
step_name = 'select-tasktemplatefolder'
label = _('label_select_tasktemplatefolder',
default=u'Select tasktemplatefolder')
steps = TRIGGER_TASKTEMPLATE_STEPS
fields = Fields(ISelectTaskTemplateFolder)
def update(self):
# ignore unauthorized checks (they're called by the contenttree widget)
if api.user.get_current() == nobody:
pass
elif not self.has_active_tasktemplates():
api.portal.show_message(_(
u'msg_no_active_tasktemplatefolders',
default=u'Currently there are no active task template '
'folders registered.'),
self.request,
type='error')
return self.request.RESPONSE.redirect(self.context.absolute_url())
self.fields['tasktemplatefolder'].widgetFactory[
INPUT_MODE] = radio.RadioFieldWidget
return super(SelectTaskTemplateFolderWizardStep, self).update()
@buttonAndHandler(_(u'button_continue', default=u'Continue'), name='save')
def handle_continue(self, action):
data, errors = self.extractData()
if errors:
return
dm = getUtility(IWizardDataStorage)
dm.update(get_datamanger_key(self.context), data)
return self.request.RESPONSE.redirect('{}/select-tasktemplates'.format(
self.context.absolute_url()))
@buttonAndHandler(_(u'button_cancel', default=u'Cancel'))
def handle_cancel(self, action):
dm = getUtility(IWizardDataStorage)
dm.drop_data(get_datamanger_key(self.context))
return self.request.RESPONSE.redirect(self.context.absolute_url())
def has_active_tasktemplates(self):
return bool(
api.content.find(
portal_type='opengever.tasktemplates.tasktemplatefolder',
review_state='tasktemplatefolder-state-activ'))
def updateWidgets(self, prefix=None):
if self.field is not None:
if self.field in self.fields:
self.fields = self.fields.select(self.field)
else:
self.fields = Fields()
for group in (self.groups or []):
if self.field in group.fields:
group.fields = group.fields.select(self.field)
else:
group.fields = Fields()
super(DexterityFieldTile, self).updateWidgets(prefix)
class DexterityFieldTile(WidgetsView, Tile):
"""Field tile for Dexterity content."""
_additionalSchemata = None
@property
def schema(self):
fti = getUtility(IDexterityFTI, name=self.context.portal_type)
return fti.lookupSchema()
@property
def additionalSchemata(self):
if self._additionalSchemata is not None:
return iter(self._additionalSchemata)
else:
return getAdditionalSchemata(context=self.context)
def __init__(self, context, request):
# xxx usually a super is the way to go here? why not?
Tile.__init__(self, context, request)
WidgetsView.__init__(self, context, request)
try:
self.field = self.data['field'].split('-', 1)[-1]
except KeyError:
self.field = None
return
# Omit all the fields except rendered field to save time, because
# autoform update will only add fields not in self.fields.
if self.field in self.schema:
self.fields = Fields(self.schema).omit(self.field)
else:
self.fields = Fields(self.schema).omit(self.schema.names())
for schema in self.additionalSchemata:
if self.field in schema:
self.field = '%s.%s' % (schema.__name__, self.field)
self.fields += Fields(
schema,
prefix=schema.__name__
).omit(self.field)
self._additionalSchemata = (schema,)
return
@property
def isVisible(self):
"""Checks wheter the user has read permission of the field: if this is
not the case, then the field is not displayed
"""
try:
schema = next(self.additionalSchemata)
except StopIteration:
schema = self.schema
return PermissionChecker(
mergedTaggedValueDict(schema, READ_PERMISSIONS_KEY),
self.context,
).allowed(self.field)
def _wrap_widget(self, render):
return ''.join([u'<html><body>', render, '</body></html>'])
def updateWidgets(self, prefix=None):
if self.field is not None:
if self.field in self.fields:
self.fields = self.fields.select(self.field)
else:
self.fields = Fields()
for group in (self.groups or []):
if self.field in group.fields:
group.fields = group.fields.select(self.field)
else:
group.fields = Fields()
super(DexterityFieldTile, self).updateWidgets(prefix)
def __call__(self):
if self.field and self.isVisible:
self.update()
widget = self.widgets.get(self.field)
if widget is not None:
return self._wrap_widget(widget.render())
for group in self.groups:
widget = group.widgets.get(self.field)
if widget is not None:
return self._wrap_widget(widget.render())
return u'<html></html>'
