def fields(self):
"""Dynamically generate a responsible field with the Keywordwidget
for each selected template.
"""
# When using the keywordwidget autocomplete search, the widget is
# traversing anonymously. Therefore we're not able to get the selected
# templates and generate all fields correctly.
# Therefore we handle all responsible widget traversals "manually".
responsible_field_match = re.match(
r'^{}(.*?)\.responsible$'.format(re.escape('++widget++form.widgets.')),
self.request._steps[-1])
if IDeferSecurityCheck.providedBy(self.request) and responsible_field_match:
field = Field(ITaskTemplate['responsible'],
prefix=responsible_field_match.group(1),)
field.widgetFactory[INPUT_MODE] = ParameterizedWidget(
KeywordWidget, async=True)
return Fields(field)
self.fallback_field = ITaskTemplate['responsible']
fields = []
for template in self.get_selected_tasktemplates():
schema_field = copy.copy(ITaskTemplate['responsible'])
field = Field(schema_field, prefix=template.id)
field.field.required = True
field.widgetFactory[INPUT_MODE] = ParameterizedWidget(
KeywordWidget, async=True)
fields.append(field)
return Fields(*fields)
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):
labels_voc, self.p_labels, self.g_labels = self.get_labels_vocabulary()
self.do_apply = len(labels_voc._terms) and has_interface(
self.brains, ILabelSupport)
self.fields += Fields(
MasterSelectField(
__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'))
]),
slave_fields=(
{
'name': 'removed_values',
'slaveID': '#form-widgets-removed_values',
'action': 'hide',
'hide_values': (u'add', u'overwrite'),
'siblings': True,
},
{
'name': 'added_values',
'slaveID': '#form-widgets-added_values',
'action': 'hide',
'hide_values': (u'remove'),
'siblings': True,
},
),
required=self.do_apply,
default=u'add'))
if self.do_apply:
self.fields += Fields(
schema.List(
__name__='removed_values',
title=_(u"Removed values"),
description=
_(u"Select the values to remove. A personal label is represented by (*)."
),
required=False,
value_type=schema.Choice(vocabulary=labels_voc),
))
self.fields += Fields(
schema.List(
__name__='added_values',
title=_(u"Added values"),
description=
_(u"Select the values to add. A personal label is represented by (*)."
),
required=False,
value_type=schema.Choice(vocabulary=labels_voc),
))
self.fields["removed_values"].widgetFactory = CheckBoxFieldWidget
self.fields["added_values"].widgetFactory = CheckBoxFieldWidget
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 test_form_create(self):
# Context and request
context = Container(u"container")
request = TestRequest()
# FTI - returns dummy factory name
fti_mock = DexterityFTI(u"testtype")
fti_mock.factory = u'testfactory'
self.mock_utility(fti_mock, IDexterityFTI, name=u"testtype")
# The form we're testing
form = DefaultAddForm(context, request)
form.portal_type = u"testtype"
class ISchema(Interface):
foo = schema.TextLine()
form.fields = Fields(ISchema)
# createObject and applyChanges
obj_dummy = Item(id="dummy")
alsoProvides(obj_dummy, ISchema)
data_dummy = {u"foo": u"bar"}
from zope.component import createObject
self.patch_global(createObject, return_value=obj_dummy)
provideAdapter(AttributeField)
self.assertEqual(obj_dummy, form.create(data_dummy))
self.assertEqual("testtype", obj_dummy.portal_type)
class CaptchaRegistrationFormExtender(extensible.FormExtender):
"""Registrationform extender to extend it with the captcha schema.
"""
adapts(Interface, IBrowserLayer, CaptchaRegistrationForm)
fields = Fields(ICaptcha)
def __init__(self, context, request, form):
self.context = context
self.request = request
self.form = form
registry = queryUtility(IRegistry)
settings = registry.forInterface(IDiscussionSettings, check=False)
self.captcha = settings.captcha
portal_membership = getToolByName(self.context, 'portal_membership')
self.isAnon = portal_membership.isAnonymousUser()
def update(self):
if self.captcha != 'disabled' and self.isAnon:
# Add a captcha field if captcha is enabled in the registry
self.add(ICaptcha, prefix="")
if self.captcha == 'captcha':
from plone.formwidget.captcha import CaptchaFieldWidget
self.form.fields['captcha'].widgetFactory = CaptchaFieldWidget
elif self.captcha == 'recaptcha':
from plone.formwidget.recaptcha import ReCaptchaFieldWidget
self.form.fields['captcha'].widgetFactory = \
ReCaptchaFieldWidget
elif self.captcha == 'norobots':
from collective.z3cform.norobots import NorobotsFieldWidget
self.form.fields['captcha'].widgetFactory = NorobotsFieldWidget
else:
self.form.fields['captcha'].mode = interfaces.HIDDEN_MODE
class CaptchaExtender(extensible.FormExtender):
"""Extends the comment form with a Captcha. This Captcha extender is only
registered when a plugin is installed that provides the
"plone.app.discussion-captcha" feature.
"""
fields = Fields(ICaptcha)
def __init__(self, context, request, form):
self.context = context
self.request = request
self.form = form
registry = queryUtility(IRegistry)
settings = registry.forInterface(IDiscussionSettings, check=False)
self.captcha = settings.captcha
portal_membership = getToolByName(self.context, 'portal_membership')
self.isAnon = portal_membership.isAnonymousUser()
def update(self):
if self.captcha != 'disabled' and self.isAnon:
# Add a captcha field if captcha is enabled in the registry
self.add(ICaptcha, prefix='')
if self.captcha == 'captcha':
from plone.formwidget.captcha import CaptchaFieldWidget
self.form.fields['captcha'].widgetFactory = CaptchaFieldWidget
elif self.captcha == 'recaptcha':
from plone.formwidget.recaptcha import ReCaptchaFieldWidget
self.form.fields['captcha'].widgetFactory = \
ReCaptchaFieldWidget
elif self.captcha == 'norobots':
from collective.z3cform.norobots import NorobotsFieldWidget
self.form.fields['captcha'].widgetFactory = NorobotsFieldWidget
else:
self.form.fields['captcha'].mode = interfaces.HIDDEN_MODE
class ManualJournalEntryAddForm(AddForm):
"""Provide a z3c.form to enter a manual journal entry."""
label = _(u'label_add_journal_entry', default=u'Add journal entry')
fields = Fields(IManualJournalEntry)
fields['contacts'].widgetFactory = ParameterizedWidget(KeywordWidget,
async=True)
def createAndAdd(self, data):
contacts, users = self.split_contacts_and_users(data.get('contacts'))
entry = ManualJournalEntry(self.context, data.get('category'),
data.get('comment'), contacts, users,
data.get('related_documents'))
entry.save()
return entry
def split_contacts_and_users(self, items):
"""Spliting up the contact list, in to a list of contact objects
and a list of adapted users.
"""
contacts = []
users = []
for item in items:
if item.is_adapted_user:
users.append(item)
else:
contacts.append(item)
return contacts, users
def nextURL(self):
return '{}#journal'.format(self.context.absolute_url())
class AddInternalAttachmentForm(AddComponentForm):
"""Add Internal Attachment form"""
label = _(u'Add Internal Attachment')
factory = InternalAttachment
attrInterface = IInternalAttachment
addInterface = IAddInternalAttachment
omitFields = InternalAttachmentDetails.omit_addfields
allFields = Fields(IInternalAttachment['data'])
addFields = allFields
allFields['data'].widgetFactory = FileFieldWidget
_session_key = 'org.ict_ok.components.int_attachment'
def create2(self, data):
""" will create the object """
obj = self.factory(**data)
self.newdata = data
IBrwsOverview(obj).setTitle(data['ikName'])
obj.__post_init__()
return obj
def create(self, data):
""" will create the object """
filename = unicode(self.widgets['data'].value.filename)
data['ikName'] = filename
data['filename'] = filename
data['contentType'] = unicode(
self.widgets['data'].value.headers['content-type'])
obj = self.factory(**data)
self.newdata = data
IBrwsOverview(obj).setTitle(data['ikName'])
obj.__post_init__()
return obj
class AreaTypesFormArt9(EmbeddedForm):
record_title = 'Article 9 (GES determination)'
fields = Fields(IAreaTypes)
fields['area_types'].widgetFactory = CheckBoxFieldWidget
session_name = '2012'
mapper_class = sql.MSFD9Descriptor
def get_subform(self):
return A9MRUForm(self, self.request)
def download_results(self):
# muids = self.get_marine_unit_ids()
_, muids = self.subform.get_available_marine_unit_ids()
ges_comps = self.get_form_data_by_key(self, 'ges_components')
count, data = get_all_records(
self.mapper_class, self.mapper_class.MarineUnitID.in_(muids),
self.mapper_class.ReportingFeature.in_(ges_comps))
descriptor_ids = [row.MSFD9_Descriptor_ID for row in data]
t_features = sql.t_MSFD9_Features
count, data_f = get_all_records(
t_features, t_features.c.MSFD9_Descriptor.in_(descriptor_ids))
xlsdata = [
('MSFD9Descriptor', data),
('MSFD9_Features', data_f),
]
return xlsdata
class ForwardingCloseForm(Form):
"""Form for assigning task.
"""
fields = Fields(IForwardingCloseForm)
ignoreContext = True
label = _(u'title_close_forwarding', u'Close orwarding')
@button.buttonAndHandler(_(u'close', default='Close'), name='save')
def handle_close(self, action):
data, errors = self.extractData()
if not errors:
# close and store the forwarding in yearfolder
change_task_workflow_state(self.context,
'forwarding-transition-close',
text=data.get('text'))
IYearfolderStorer(self.context).store_in_yearfolder()
return self.request.RESPONSE.redirect('.')
@button.buttonAndHandler(task_mf(u'button_cancel', default=u'Cancel'))
def handle_cancel(self, action):
return self.request.RESPONSE.redirect('.')
class WidgetTestForm(Form):
ignoreContext = True
fields = Fields(IWidgetTestFormSchema)
def __init__(self, *args, **kwargs):
super(WidgetTestForm, self).__init__(*args, **kwargs)
self.result_data = None
@buttonAndHandler(u'Submit')
def handle_submit(self, action):
data, errors = self.extractData()
if len(errors) > 0:
return
self.result_data = {}
for key, value in data.items():
if not value:
continue
if isinstance(value, (datetime, date)):
value = value.isoformat()
if isinstance(value, TestObject):
value = (
value.id,
value.title,
)
self.result_data[key] = value
class ClimateFutureAddForm(BCCVLUploadForm):
title = u"Upload Future Climate Data"
description = (
u"<p>Upload future climate data</p>"
u"<p>BCCVL can only deal with raster data in GeoTIFF format."
u" Valid files are either single GeoTiff files or a number of"
u" GeoTiff packaged within a zip file.</p>"
u"<p>It is easy to convert your csv files to GeoTIFF format,"
u"follow the instructions here <a href=\"https://github.com/NICTA/nationalmap/wiki/csv-geo-au\" target=\"_blank\">https://github.com/NICTA/nationalmap/wiki/csv-geo-au</a>."
u"Ideally the map projection information is embedded as metadata within the GeoTiff itself. In case of missing map projection BCCVL assumes WGS-84 (EPSG:4326).,</p>"
)
fields = Fields(IBlobDataset, IDublinCore, ILayerDataset).select(
'domain',
'file',
'title',
'description',
'emsc',
'gcm',
'resolution', # 'resolutiono',
'rights')
datagenre = 'DataGenreFC'
categories = ['climate']
timeperiod = ['Future datasets']
# datatype, gcm, emissionscenario
subpath = [defaults.DATASETS_CLIMATE_FOLDER_ID, 'user']
class RegionalCoopForm(EmbeddedForm):
fields = Fields(interfaces.IMemberStatesArt6)
fields['member_states'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
return RegionalCoopItemDisplay(self, self.request)
def download_results(self):
mci = sql.MSFD4Import
mcr = sql.MSFD4RegionalCooperation
c_codes = self.data.get('member_states')
import_ids = db.get_unique_from_mapper(
sql.MSFD4Import, 'MSFD4_Import_ID',
sql.MSFD4Import.MSFD4_Import_ReportingCountry.in_(c_codes))
cols = [mci.MSFD4_Import_ReportingCountry] + self.get_obj_fields(mcr)
count, data = get_all_records_join(
cols, mcr, mcr.MSFD4_RegionalCooperation_Import.in_(import_ids))
xlsdata = [
('RegionalCooperation', data),
]
return data_to_xls(xlsdata)
def add(form, *args, **kwargs):
"""Add one or more fields. Keyword argument 'index' can be used to
specify an index to insert at. Keyword argument 'group' can be used
to specify the label of a group, which will be found and used or
created if it doesn't exist.
"""
index = kwargs.pop('index', None)
group = kwargs.pop('group', None)
new_fields = Fields(*args, **kwargs)
if not group or isinstance(group, basestring):
source = find_source(form, group=group)
else:
source = group
if source is None and group:
source = GroupFactory(group, new_fields)
form.groups.append(source)
else:
if index is None or index >= len(source.fields):
source.fields += new_fields
else:
field_names = source.fields.keys()
source.fields = source.fields.select(*field_names[:index]) + \
new_fields + \
source.fields.select(*field_names[index:])
class ModifyDeadlineForm(Form):
"""Form wich allows to modify the deadline of a task."""
fields = Fields(IModifyDeadlineSchema)
ignoreContext = True
label = _(u'title_modify_deadline', u'Modify deadline')
@buttonAndHandler(_(u'button_save', default=u'Save'))
def handle_save(self, action):
data, errors = self.extractData()
if not errors:
if data.get('new_deadline') == self.context.deadline:
raise WidgetActionExecutionError(
'new_deadline',
Invalid(
_('same_deadline_error',
default=u'The given deadline, is the current one.')))
IDeadlineModifier(self.context).modify_deadline(
data.get('new_deadline'), data.get('text'))
msg = _(u'msg_deadline_change_successfull',
default=u'Deadline successfully changed.')
IStatusMessage(self.request).addStatusMessage(msg, type='info')
return self.request.RESPONSE.redirect(self.context.absolute_url())
class A18CategoryForm(EmbeddedForm):
""""""
record_title = "Article 18 (Category1bNotWFDMeasure)"
title = "Category1bNotWFDMeasure"
display_klass = A18CategoryDisplay
mapper_class = sql2018.ART18Category1bNotWFD
fields = Fields(interfaces.ICountryCode)
fields['member_states'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
return A18DescriptorForm(self, self.request)
@db.use_db_session('2018')
def get_ges_components(self):
mc_countries = sql2018.ReportedInformation
conditions = []
countries = self.get_form_data_by_key(self, 'member_states')
if countries:
conditions.append(mc_countries.CountryCode.in_(countries))
count, category_ids = db.get_all_records_outerjoin(
self.mapper_class, mc_countries, *conditions)
ges_components = set([x.Descriptor for x in category_ids])
return ges_components
class CommentFormExtender(FormExtender):
''' Extend the comment form with additional extra fields
'''
fields = Fields(ICommentFormExtender)
def update(self):
self.add(self.fields)
class EnvironmentalFutureAddForm(BCCVLUploadForm):
title = u"Upload Future Environmental Data"
description = (
u"<p>Upload future environmental data</p>"
u"<p>BCCVL can only deal with raster data in GeoTIFF format."
u" Valid files are either single GeoTiff files or a number of"
u" GeoTiff packaged within a zip file.</p>"
u"Ideally the map projection information is embedded as metadata within the GeoTiff itself. In case of missing map projection BCCVL assumes WGS-84 (EPSG:4326).,</p>"
)
fields = Fields(IBlobDataset, IDublinCore, ILayerDataset).select(
'domain',
'file',
'title',
'description',
'emsc',
'gcm',
'resolution', # 'resolutiono',
'rights')
datagenre = 'DataGenreE'
categories = ['environmental']
timeperiod = ['Future datasets']
# datatype, gcm, emissionscenario
subpath = [defaults.DATASETS_ENVIRONMENTAL_FOLDER_ID, 'user']
class ParticipationAddForm(Form):
fields = Fields(IParticipation)
label = _(u'label_participation', default=u'Participation')
ignoreContext = True
fields['contact'].widgetFactory = ParameterizedWidget(
KeywordWidget,
async=True
)
fields['roles'].widgetFactory = CheckBoxFieldWidget
@button.buttonAndHandler(_(u'button_add', default=u'Add'))
def handle_add(self, action):
data, errors = self.extractData()
if not errors:
phandler = IParticipationAware(self.context)
part = phandler.create_participation(**data)
phandler.append_participiation(part)
status = IStatusMessage(self.request)
msg = _(u'info_participation_create',
u'Participation created.')
status.addStatusMessage(msg, type='info')
return self._redirect_to_participants_tab()
@button.buttonAndHandler(_(u'button_cancel', default=u'Cancel'))
def handle_cancel(self, action):
return self._redirect_to_participants_tab()
def _redirect_to_participants_tab(self):
url = self.context.absolute_url() + '/#participants'
return self.request.RESPONSE.redirect(url)
class RejectProposalForm(Form):
fields = Fields(IRejectProposalSchema)
ignoreContext = True
label = _(u'heading_reject_proposal_form', u'Reject proposal')
@button.buttonAndHandler(_(u'reject', default=u'Reject'))
def reject_handler(self, action):
data, errors = self.extractData()
if len(errors) > 0:
return
self.reject_proposal(data['text'])
committee = aq_parent(aq_inner(self.context))
api.portal.show_message(
_(u"The proposal has been rejected successfully"),
request=self.request)
self.redirect(committee)
def reject_proposal(self, text):
self.context.reject(text)
@button.buttonAndHandler(_(u'button_cancel', default=u'Cancel'))
def cancel(self, action):
return self.redirect(self.context)
def redirect(self, content):
return self.request.RESPONSE.redirect(content.absolute_url())
class AreaTypesForm(EmbeddedForm):
fields = Fields(interfaces.IAreaTypes)
fields['area_types'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
main_form = self.get_main_form().name
if main_form == 'msfd-mru':
return A4Form(self, self.request)
# if main_form == 'msfd-a9':
# return A9Form(self, self.request)
if main_form == 'msfd-a10':
return A10Form(self, self.request)
if main_form == 'msfd-a8':
# For Art 8.1a and 8.1b we return the theme class
klass = self.get_flattened_data(self).get('theme')
if klass:
return super(AreaTypesForm, self).get_subform(klass)
article = self.get_form_data_by_key(self, 'article')
klass = get_form(article)
return super(AreaTypesForm, self).get_subform(klass)
def get_available_marine_unit_ids(self):
return self.subform.get_available_marine_unit_ids()
class SelectDocumentsStepForm(CloseTaskWizardStepFormMixin, Form):
fields = Fields(ISelectDocumentsSchema)
fields['documents'].widgetFactory = CheckBoxFieldWidget
step_name = 'close-task-wizard_select-documents'
@buttonAndHandler(_(u'button_continue', default=u'Continue'), name='save')
def handle_continue(self, action):
data, errors = self.extractData()
if not errors:
oguid = ISuccessorTaskController(self.context).get_oguid()
dm = getUtility(IWizardDataStorage)
dmkey = 'close:%s' % oguid
dm.update(dmkey, data)
if len(data['documents']) == 0:
url = '/'.join((self.context.absolute_url(),
'@@close-task-wizard_close?oguid=%s' % oguid))
return self.request.RESPONSE.redirect(url)
else:
info = getUtility(IContactInformation)
client = info.get_client_by_id(self.context.responsible_client)
dm.push_to_remote_client(dmkey, client.client_id)
url = '/'.join(
(client.public_url,
'@@close-task-wizard_choose-dossier?oguid=%s' % (oguid)))
return self.request.RESPONSE.redirect(url)
@buttonAndHandler(_(u'button_cancel', default=u'Cancel'), name='cancel')
def handle_cancel(self, action):
return self.request.RESPONSE.redirect(self.context.absolute_url())
class MarineUnitIDsForm(EmbeddedForm):
""" Select the MarineUnitID based on MemberState, Region and Area
"""
fields = Fields(IMarineUnitIDsSelect)
fields['marine_unit_ids'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
data = self.get_main_form().data
klass = get_form(data['article'])
return super(MarineUnitIDsForm, self).get_subform(klass)
def get_available_marine_unit_ids(self):
marine_unit_ids = self.data.get('marine_unit_ids')
if marine_unit_ids:
data = self.data
else:
data = {}
parent = self.context
# lookup values in the inheritance tree
for crit in ['area_types', 'member_states', 'region_subregions']:
data[crit] = getattr(parent, 'get_selected_' + crit)()
parent = parent.context
return db.get_marine_unit_ids(**data)
class SelectRecipientsForm(DelegateWizardFormMixin, Form):
fields = Fields(ISelectRecipientsSchema)
fields['responsibles'].widgetFactory = ParameterizedWidget(KeywordWidget,
async=True)
fields['documents'].widgetFactory = CheckBoxFieldWidget
step_name = 'delegate_recipients'
@buttonAndHandler(_(u'button_continue', default=u'Continue'), name='save')
def handle_continue(self, action):
data, errors = self.extractData()
if not errors:
passed_data = data.copy()
if passed_data['documents'] is None:
del passed_data['documents']
url = '%s/@@delegate_metadata?%s' % (self.context.absolute_url(),
encode_data(passed_data))
return self.request.RESPONSE.redirect(url)
@buttonAndHandler(_(u'button_cancel', default=u'Cancel'), name='cancel')
def handle_cancel(self, action):
url = self.context.absolute_url()
return self.request.RESPONSE.redirect(url)
def updateWidgets(self):
super(SelectRecipientsForm, self).updateWidgets()
documents_source = self.fields['documents'].field.value_type.source
if len(documents_source(self.context)) == 0:
self.widgets['documents'].mode = HIDDEN_MODE
class SelectDossierTypeStepForm(AcceptWizardNewDossierFormMixin, Form):
fields = Fields(ISelectDossierTypeSchema)
step_name = 'accept_select_dossier_type'
@buttonAndHandler(_(u'button_continue', default=u'Continue'),
name='save')
def handle_continue(self, action):
data, errors = self.extractData()
if not errors:
oguid = self.request.get('oguid')
dmkey = 'accept:%s' % oguid
dm = getUtility(IWizardDataStorage)
dm.update(dmkey, data)
url = '%s/@@accept_dossier_add_form?oguid=%s&%s' % (
self.context.absolute_url(),
oguid,
urllib.urlencode(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)
class EditAssessorsForm(Form, BaseComplianceView):
""" Assessment settings form, used to edit the assessors list
/compliance-module/national-descriptors-assessments/edit-assessors
"""
ignoreContext = True
name = 'edit-assessors'
section = 'compliance-admin'
title = u'Edit assessed by'
fields = Fields(IEditAssessorsForm)
template = ViewPageTemplateFile('pt/edit-assessors.pt')
@buttonAndHandler(u'Save', name='Save')
def hande_save(self, action):
data, errors = self.extractData()
if not errors:
value = data.get('assessed_by', '')
value = ', '.join(value.split('\r\n'))
set_assessors(value)
def updateWidgets(self):
super(EditAssessorsForm, self).updateWidgets()
assessed_by_field = self.fields['assessed_by'].field
default = assessed_by_field.default
annot_assessors = get_assessors()
annot_assessors = '\r\n'.join(annot_assessors.split(', '))
if annot_assessors and default != annot_assessors:
assessed_by_field.default = annot_assessors
self.update()
class A11MSubMemberStateForm(EmbeddedForm):
fields = Fields(interfaces.IMemberStates)
fields['member_states'].widgetFactory = CheckBoxFieldWidget
def get_subform(self):
return Article11MonitoringProgrammeType(self, self.request)
klass = self.context.mru_class
return klass(self, self.request)
def get_available_marine_unit_ids(self, mp_type_ids=None):
# TODO: use available marine unit ids from t_MSFD4_GegraphicalAreasID
# mp_type_ids = self.context.get_mp_type_ids()
mptypes_subprog = self.context.get_mptypes_subprog()
member_states = self.get_selected_member_states()
submonprog_ids = []
# logger.info('mp_type_ids: %s', mp_type_ids)
for x in mp_type_ids:
submonprog_ids.extend(mptypes_subprog[int(x)])
subprogramme_ids = db.get_unique_from_mapper(
sql.MSFD11MONSub, 'SubProgramme',
and_(sql.MSFD11MONSub.SubProgramme.in_(submonprog_ids),
sql.MSFD11MONSub.MemberState.in_(member_states)))
subprogramme_ids = [int(x) for x in subprogramme_ids]
q4g_subprogids_1 = db.get_unique_from_mapper(
sql.MSFD11SubProgramme, 'Q4g_SubProgrammeID',
sql.MSFD11SubProgramme.ID.in_(subprogramme_ids))
q4g_subprogids_2 = db.get_unique_from_mapper(
sql.MSFD11SubProgrammeIDMatch, 'MP_ReferenceSubProgramme',
sql.MSFD11SubProgrammeIDMatch.Q4g_SubProgrammeID.in_(
q4g_subprogids_1))
mc_ref_sub = sql.MSFD11ReferenceSubProgramme
mp_from_ref_sub = db.get_unique_from_mapper(
sql.MSFD11ReferenceSubProgramme, 'MP',
or_(mc_ref_sub.SubMonitoringProgrammeID.in_(q4g_subprogids_1),
mc_ref_sub.SubMonitoringProgrammeID.in_(q4g_subprogids_2)))
mp_from_ref_sub = [int(x) for x in mp_from_ref_sub]
mon_prog_ids = db.get_unique_from_mapper(
sql.MSFD11MP, 'MonitoringProgramme',
sql.MSFD11MP.ID.in_(mp_from_ref_sub),
sql.MSFD11MP.MonitoringProgramme.isnot(None),
sql.MSFD11MP.MPType.in_(mp_type_ids))
mc_ = sql.MSFD11MonitoringProgrammeMarineUnitID
count, marine_units = db.get_all_records_outerjoin(
sql.MSFD11MarineUnitID, mc_,
mc_.MonitoringProgramme.in_(mon_prog_ids))
mrus = [x.MarineUnitID for x in marine_units]
return [count, mrus]
class UpdateMetadataForm(DelegateWizardFormMixin, Form):
fields = Fields(IUpdateMetadata)
fields['issuer'].widgetFactory = ParameterizedWidget(KeywordWidget,
async=True)
fields['deadline'].widgetFactory = DatePickerFieldWidget
step_name = 'delegate_metadata'
passed_data = ['responsibles', 'documents']
@buttonAndHandler(_(u'button_save', default=u'Save'), name='save')
def handle_save(self, action):
data, errors = self.extractData()
if not errors:
responsibles = self.request.get('responsibles')
documents = self.request.get('documents', None) or []
subtasks = create_subtasks(self.context, responsibles, documents,
data)
msg = _(u'${subtask_num} subtasks were create.',
mapping={u'subtask_num': len(subtasks)})
IStatusMessage(self.request).addStatusMessage(msg, 'info')
url = self.context.absolute_url()
return self.request.RESPONSE.redirect(url)
@buttonAndHandler(_(u'button_cancel', default=u'Cancel'), name='cancel')
def handle_cancel(self, action):
url = self.context.absolute_url()
return self.request.RESPONSE.redirect(url)
def updateWidgets(self):
super(UpdateMetadataForm, self).updateWidgets()
widget = self.widgets['issuer']
value = api.user.get_current().getId()
widget.value = IDataConverter(widget).toWidgetValue(value)
class SubscribeNewsletterForm(Form):
fields = Fields(ISubscribeNewsletterForm)
ignoreContext = True
label = _(u"")
def __init__(self, context, request, data=None):
"""
"""
super(Form, self).__init__(context, request)
self.data = data
def newslettertheme(self):
"""Returns brain of NewsletterTheme."""
path = self.data.newsletters
query = {
'object_provides': INewsletterTheme.__identifier__,
}
if path:
portal_state = getMultiAdapter((self.context, self.request),
name="plone_portal_state")
path = '{0}{1}'.format(portal_state.navigation_root_path(), path)
query.update({'path': {
'depth': 0,
'query': path,
}})
catalog = getToolByName(self.context, 'portal_catalog')
brains = catalog(query)
if brains:
return brains[0]
def updateWidgets(self):
super(self.__class__, self).updateWidgets()
self.widgets['email'].size = 20
newslettertheme = self.newslettertheme()
self.widgets['format'].field.default = newslettertheme.getObject(
).default_format
@property
def action(self):
""" Rewrite HTTP POST action.
If the form is rendered embedded on the others pages we
make sure the form is posted through the same view always,
instead of making HTTP POST to the page where the form was rendered.
"""
path = self.newslettertheme().getPath()
return '{0}/@@register-newsletter?path={1}'.format(
self.context.absolute_url(), path)
@button.buttonAndHandler(_('Subscribe'), name='subscribe')
def search(self, action):
""" Form button hander. """
data, errors = self.extractData()
if not errors:
pass
