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