def inline_add_form(api, content_type, bind_data): """ Expects the context for the add form to be the current requests context. This is only used within the agenda item view currently. """ tag = api.request.GET.get('tag', '') schema_name = api.get_schema_name(content_type, 'add') schema = createSchema(schema_name, bind = bind_data) query = {'content_type': content_type, 'tag': tag} url = api.request.resource_url(api.context, '_inline_form', query = query) return Form(schema, action = url, buttons = (button_add,), use_ajax = True)
def form_view(request): schema = Schema() form = Form(schema) if 'submit' in request.POST: controls = request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure as e: return {'form': form} return {'form': form}
def generate_labels_form(self, formid="deform_tags"): """This helper code generates the form that will be used to add and edit job tags/labels based on the schema of the form. """ update_button = Button(name='update_labels', title='Update', css_class='btn btn-success') return Form(schema=LabelsSchema(), buttons=(update_button, ), formid=formid)
def get_form(request, class_form): schema = class_form(validator=form_validator) schema = schema.bind( daftar_status=STATUS, daftar_wajibpajak=daftar_wajibpajak(), daftar_unit=daftar_unit(), daftar_objekpajak=daftar_objekpajak(), ) schema.request = request return Form(schema, buttons=('simpan', 'batal'))
def _get_field(name, renderer): from deform import Form from colanderalchemy import SQLAlchemySchemaNode form = Form(SQLAlchemySchemaNode(Person), renderer=renderer) for field in form.children: if field.name == name: return field raise RuntimeError('Field not found')
def generate_caption_form(self, formid="deform_caption"): """This helper code generates the form that will be used to add and edit job captions based on the schema of the form. """ update_button = Button(name='update_caption', title='Update', css_class='btn btn-success') return Form(schema=CaptionSchema(), buttons=(update_button, ), formid=formid)
def contact(self): """ Contact moderators of the meeting """ recipients = [] for userid in find_role_userids(self.context, ROLE_MODERATOR): user = self.api.get_user(userid) email = user.get_field_value('email') if email: recipients.append(email) if not recipients: for userid in find_authorized_userids(self.context, (MODERATE_MEETING, )): user = self.api.get_user(userid) email = user.get_field_value('email') if email: recipients.append(email) schema = createSchema('ContactSchema').bind(context=self.context, request=self.request, api=self.api) form = Form(schema, buttons=(button_send, )) self.api.register_form_resources(form) post = self.request.POST if self.request.method == 'POST': controls = post.items() try: appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response if appstruct.get('email', None): sender = appstruct['email'] if self.api.user_profile: sender += " <%s>" % self.api.user_profile.title else: sender = None response = { 'api': self.api, 'meeting': self.context, 'name': appstruct['name'], 'email': appstruct['email'], 'subject': appstruct['subject'], 'message': appstruct['message'], } body_html = render('templates/email/help_contact.pt', response, request=self.request) subject = "[%s] %s" % (self.context.title, appstruct['subject']) send_email(subject, recipients, body_html, sender=sender, request=self.request) self.api.flash_messages.add(_(u"Message sent to the moderators")) url = self.request.resource_url(self.context) return HTTPFound(location=url)
def view(self): # Get LDAP settings ldap_settings = self.request.db.ldap.find_one() if ldap_settings is None: ldap_settings = dict() # Generate form from phoenix.settings.schema import LdapSchema ldap_form = Form(schema=LdapSchema().bind(request=self.request), buttons=('submit',), formid='deform') if 'submit' in self.request.params: check_csrf_token(self.request) try: # Validate form appstruct = ldap_form.validate(list(self.request.params.items())) except ValidationFailure as e: LOGGER.exception('Validation failed!') return dict(title='LDAP Settings', form=e.render()) else: # Update LDAP settings ldap_settings['server'] = appstruct['server'] ldap_settings['use_tls'] = appstruct['use_tls'] ldap_settings['bind'] = appstruct['bind'] ldap_settings['passwd'] = appstruct['passwd'] ldap_settings['base_dn'] = appstruct['base_dn'] ldap_settings['filter_tmpl'] = appstruct['filter_tmpl'] ldap_settings['scope'] = appstruct['scope'] # Optional: ldap_settings['name'] = appstruct['name'] ldap_settings['email'] = appstruct['email'] self.request.db.ldap.save(ldap_settings) import ldap if ldap_settings['scope'] == 'ONELEVEL': ldap_scope = ldap.SCOPE_ONELEVEL else: ldap_scope = ldap.SCOPE_SUBTREE from pyramid.config import Configurator config = Configurator(registry=self.request.registry) config.ldap_setup( ldap_settings['server'], bind=ldap_settings['bind'], passwd=ldap_settings['passwd'], use_tls=ldap_settings['use_tls']) config.ldap_set_login_query( base_dn=ldap_settings['base_dn'], filter_tmpl=ldap_settings['filter_tmpl'], scope=ldap_scope) config.commit() self.session.flash('Successfully updated LDAP settings!', queue='success') # Display form return dict(title='LDAP Settings', form=ldap_form.render(ldap_settings))
def make_password_reset_form(request): schema = PasswordReset() if request: schema = PasswordReset().bind(request=request) password_reset_form = Form(schema, bootstrap_form_style='form-vertical', buttons=(Button('submit', title='Reset Password'), ), resource_registry=password_registry, renderer=renderer) return password_reset_form
def get_expense_id_form(counter): """ Return a form for expense export by id :param counter: the iterator used to insert various forms in the same page """ schema = ExpenseIdSchema(title=u"Exporter une notes de frais depuis \ un identifiant") return Form(schema=schema, buttons=(EXPORT_BTN, ), formid="expense_id_form", counter=counter)
def get_from_invoice_number_form(counter, request): """ Return the export criteria form used to export from a given invoice """ schema = FromInvoiceNumberSchema( title=u"Exporter les factures à partir d'un numéro") schema = schema.bind(request=request) return Form(schema=schema, buttons=(EXPORT_BTN, ), formid='from_invoice_number_form', counter=counter)
def make_password_change_form(request, admin_change=False): schema = PasswordChange() if admin_change: del schema['password'] password_reset_form = Form(schema=schema.bind(request=request), bootstrap_form_style='form-vertical', buttons=(Button('submit', title='Change Password'), ), resource_registry=password_registry, renderer=renderer) return password_reset_form
def get_year_form(self): """ Return the year selection form """ schema = self.year_form_schema.bind(request=self.request) form = Form(schema=schema, buttons=(), method='GET', formid='year_form') form.set_appstruct(self.submit_year()) return form
def get_all_form(counter, title=u"Exporter les factures non exportées"): """ Return a void form used to export all non-exported documents """ schema = AllSchema(title=title) return Form( schema=schema, buttons=(EXPORT_BTN, ), formid='all_form', counter=counter, )
def make_disable_user_form(request): schema = DisableUser() # This form will be on a page with multiple forms, # so we have to set the formid attribute for the ajax # stuff to work. disable_user_form = Form( schema=schema.bind(request=request), buttons=(Button('submit', title='Yes'), Button('cancel', title='No')), formid='disable-form', ) return disable_user_form
def get_invoice_pdf_export_form(request): """ Return the form used to search for invoices that will be exported """ schema = pdfexportSchema.bind(request=request) action = request.route_path( "invoices", _query=dict(action="export_pdf"), ) query_form = Form(schema, buttons=(submit_btn, ), action=action) return query_form
def get_expense_form(request): """ Return a form for expense export """ schema = ExpenseSchema(title=u"Exporter les notes de dépense") schema = schema.bind(request=request) return Form( schema=schema, buttons=(EXPORT_BTN, ), formid="expense_form", )
def get_period_form(title=u"Exporter les factures sur une période donnée"): """ Return the period search form """ schema = periodSchema schema.title = title return Form( schema=schema, buttons=(EXPORT_BTN, ), formid='period_form', )
def contact(request): button1 = Button('submit', _('Send message')) button1.css_class = 'btn-primary' button2 = Button('cancel', _('Cancel')) button2.css_class = 'btn-default' form = Form(ContactSchema(), buttons=(button1, button2)) if 'submit' in request.POST: controls = request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure as e: return {'form': e.render()} context = {'link': request.route_url('contact')} context.update(appstruct) subject = ("%s sent a message from Yith's contact form" % appstruct['name']) result = send_email_to_admins( request, 'yithlibraryserver:templates/email_contact', context, subject, extra_headers={'Reply-To': appstruct['email']}, ) if result is None: log.error( '%s <%s> tried to send a message from the contact form but no ' 'admin emails were configured. Message: %s' % ( appstruct['name'], appstruct['email'], appstruct['message'], )) request.session.flash( _('Thank you very much for sharing your opinion'), 'info', ) return HTTPFound(location=request.route_path('home')) elif 'cancel' in request.POST: return HTTPFound(location=request.route_path('home')) initial = {} if request.user is not None: initial['name'] = request.user.first_name if request.user.email_verified: initial['email'] = request.user.email return {'form': form.render(initial)}
def ajax_set_groups(self): schema = createSchema('PermissionsSchema') add_csrf_token(self.context, self.request, schema) schema = schema.bind(context=self.context, request=self.request, api=self.api) form = Form(schema, buttons=('save', 'cancel')) controls = self.request.POST.items() appstruct = form.validate(controls) #FIXME: Handle error some way, and return a proper response self.context.set_security(appstruct['userids_and_groups']) return Response() # i.e. 200 ok
def edit_slideshow(request): context = request.context form = Form(schema.Slideshow(), buttons=('submit', )) appstruct = { 'name': context.name, 'slides': [ dict(shard=slide.shard_id, duration=slide.duration) for slide in context.slides ] } return {'form': form.render(appstruct), 'title': u'Edit Slideshow'}
def get_form(config,mwf): from nipype.interfaces.traits_extension import isdefined if not isdefined(mwf.html_view): schema = colander.Schema() all_traits = config.trait_names() all_traits.remove('trait_added') all_traits.remove('trait_modified') for tr in all_traits: _type = type(config.trait(tr).trait_type) col_type = getNode(_type,tr,config) schema.add(col_type) form = Form(schema,buttons = ('submit',),action='') return form.render(appstruct=config.get()) else: form = Form(mwf.html_view(),buttons = ('submit',),action='') return form.render()
def get_invoice_number_form(counter, request, title=u"Exporter une facture"): """ Return the search form used to search invoices by number+year """ schema = InvoiceNumberSchema(title=title) schema = schema.bind(request=request) return Form( schema=schema, buttons=(EXPORT_BTN, ), formid='invoice_number_form', counter=counter, )
def view_delete(request): q = query_id(request) row = q.first() a = row.id x = row.approval_level if not row: return id_not_found(request) if x == 1: request.session.flash( 'Data tidak dapat dihapus, karena sudah masuk di Menu Approval.', 'error') return route_list(request) if x == 2: request.session.flash( 'Data tidak dapat dihapus, karena sudah disetujui.', 'error') return route_list(request) if row.disabled: request.session.flash( 'Data tidak dapat dihapus, karena sudah masuk di Menu Approval.', 'error') return route_list(request) if row.status_dlv: request.session.flash( 'Data tidak dapat dihapus, karena sudah masuk di Menu Pengiriman Gudang.', 'error') return route_list(request) # Seleksi untuk di menu Approval r = DBSession.query(ProductReqAppr).filter( ProductReqAppr.product_request_id == a).first() if r: request.session.flash( 'Hapus dahulu data rencana yang sudah pernah dibuat di Menu Approval.', 'error') return route_list(request) # Seleksi untuk mengecek item i = DBSession.query(ProductRequestItem).filter( ProductRequestItem.product_request_id == a).first() if i: request.session.flash('Hapus dahulu item produk / barang.', 'error') return route_list(request) form = Form(colander.Schema(), buttons=('hapus', 'batal')) if request.POST: if 'hapus' in request.POST: msg = 'Order ID %d sudah dihapus.' % (row.id) q.delete() DBSession.flush() request.session.flash(msg) return route_list(request) return dict(row=row, form=form.render())
def view_contactform(context, request): locale_name = get_locale_name(request) tmpstore = FileUploadTempStore(request) def file_size_limit(node, value): value['fp'].seek(0, 2) size = value['fp'].tell() value['fp'].seek(0) max_size = 10 if size > max_size * 1024 * 1024: msg = _('Maximum file size: ${size}MB', mapping={'size': max_size}) raise colander.Invalid(node, msg) def maybe_show_attachment(node, kw): if kw.get('maybe_show_attachment', True) is False: del node['attachment'] class SubmissionSchema(colander.MappingSchema): name = colander.SchemaNode(colander.String(), title=_("Full Name")) sender = colander.SchemaNode(colander.String(), validator=colander.Email(), title=_("E-Mail Address")) subject = colander.SchemaNode(colander.String(), title=_("Subject")) content = colander.SchemaNode(colander.String(), widget=TextAreaWidget(cols=40, rows=5), title=_("Your message")) attachment = colander.SchemaNode( FileData(), title=_('Attachment'), widget=FileUploadWidget(tmpstore), validator=file_size_limit, missing=None, ) _LOCALE_ = colander.SchemaNode(colander.String(), widget=HiddenWidget(), default=locale_name) schema = SubmissionSchema(after_bind=maybe_show_attachment) schema = schema.bind(maybe_show_attachment=context.show_attachment) form = Form(schema, buttons=[Button('submit', _('Submit'))]) appstruct = None rendered_form = None if 'submit' in request.POST: controls = request.POST.items() try: appstruct = form.validate(controls) mail_submission(context, request, appstruct) except ValidationFailure, e: appstruct = None rendered_form = e.render()
def item_new(): if 'cancel' in request.form: return redirect(url_for('.item_list')) item_new_schema = ItemNewSchema() item_new_form = Form( item_new_schema, action=url_for('.item_new'), buttons=get_form_buttons() ) if 'submit' in request.form: print request.form try: appstruct = item_new_form.validate(request.form.items()) except ValidationFailure as e: current_app.logger.warning(e.error) template_context = {'item_new_form': item_new_form} return render_template(ITEM_NEW_TEMPLATE, **template_context) new_item = Item() for key in appstruct: if hasattr(new_item, key): if appstruct[key] == colander.null: setattr(new_item, key, None) else: setattr(new_item, key, appstruct[key]) Session.add(new_item) Session.flush() clients = get_client_list() client_items_to_add = [] for client in clients: client_item = Session.query(ClientItem)\ .filter(ClientItem.client_id == client.id, ClientItem.item_id == new_item.id, ClientItem.deleted == False).first() if not client_item: client_item = ClientItem(client.id, new_item.id, new_item.price) client_items_to_add.append(client_item) if client_items_to_add: Session.add_all(client_items_to_add) Session.flush() flash(u'Uspješno ste dodali novi artikl', 'success') return redirect(url_for('.item_list')) template_context = { 'page_title': u'Novi artikl', 'item_new_form': item_new_form } return render_template(ITEM_NEW_TEMPLATE, **template_context)
def add_form(self): content_type = self.request.params.get('content_type') tag = self.request.GET.get('tag', None) #Permission check add_permission = self.api.content_types_add_perm(content_type) if not has_permission(add_permission, self.context, self.request): raise HTTPForbidden( "You're not allowed to add '%s' in this context." % content_type) factory = self.api.get_content_factory(content_type) schema_name = self.api.get_schema_name(content_type, 'add') schema = createSchema(schema_name).bind(context=self.context, request=self.request, api=self.api) form = Form(schema, buttons=(button_add, button_cancel)) self.api.register_form_resources(form) if content_type == 'AgendaItem': self.response['tabs'] = self.api.render_single_view_component( self.context, self.request, 'tabs', 'manage_agenda') post = self.request.POST if 'add' in post: controls = post.items() try: #appstruct is deforms convention. It will be the submitted data in a dict. appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response kwargs = {} kwargs.update(appstruct) if self.api.userid: kwargs['creators'] = [self.api.userid] obj = createContent(content_type, **kwargs) name = self.generate_slug(obj.title) self.context[name] = obj self.api.flash_messages.add(_(u"Successfully added")) #Success, redirect url = self.request.resource_url(obj) #Polls might have a special redirect action if the poll plugin has a settings schema: if content_type == 'Poll': if obj.get_poll_plugin().get_settings_schema() is not None: url += 'poll_config' else: url = self.request.resource_url(obj.__parent__, anchor=obj.uid) msg = _( u"private_poll_info", default= u"The poll is created in private state, to show it the participants you have to change the state to upcoming." ) self.api.flash_messages.add(msg) return HTTPFound(location=url)
def support(self): """ Support form - requires support email to be set! """ support_email = self.api.root.get_field_value('support_email', None) if not support_email: self.api.flash_messages.add( _(u"No support email set for this site. Form won't work!")) url = self.request.resource_url(self.context) return HTTPFound(location=url) schema = createSchema('SupportSchema').bind(context=self.context, request=self.request, api=self.api) form = Form(schema, action=self.request.resource_url(self.context, 'support'), buttons=(button_send, )) self.api.register_form_resources(form) post = self.request.POST if self.request.method == 'POST': controls = post.items() try: appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response sender = appstruct['email'] and appstruct[ 'email'] or "VoteIT <*****@*****.**>" response = { 'api': self.api, 'meeting': self.api.meeting, 'name': appstruct['name'], 'email': appstruct['email'], 'subject': appstruct['subject'], 'message': appstruct['message'], 'meeting_title': appstruct.get('meeting_title', ''), } body_html = render('templates/email/support.pt', response, request=self.request) title = "%s %s" % (self.api.root.get_field_value( 'site_title', u"VoteIT"), self.api.translate(_(u"Support"))) subject = "[%s] | %s" % (title, appstruct['subject']) msg = Message(subject=subject, sender=sender and sender or None, recipients=(support_email, ), html=body_html) mailer = get_mailer(self.request) mailer.send(msg) self.api.flash_messages.add(_(u"Support request sent!")) url = self.request.resource_url(self.context) return HTTPFound(location=url)
def account_view(self): """This is the settings form for the user. The first time a user logs in, they are taken here so we can get their first and last name. """ # Special case when the db was blown away if self.user_id is not None and self.user is None: return self.logout() section_name = 'account' schema = SettingsSchema() form = Form(schema, buttons=('submit', )) css_resources, js_resources = self.form_resources(form) if 'submit' in self.request.POST: controls = self.request.POST.items() try: form.validate(controls) except ValidationFailure as e: msg = 'There was an error saving your settings.' self.request.session.flash(msg, queue='error') return { 'form': e.render(), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, } values = parse(self.request.params.items()) # Update the user with transaction.manager: self.user.first_name = values.get('first_name', u'') self.user.last_name = values.get('last_name', u'') self.user.time_zone = values.get('time_zone', u'US/Eastern') DBSession.add(self.user) self.request.session.flash( 'Settings updated successfully', queue='success', ) return HTTPFound('/list') # Get existing values if self.user is not None: appstruct = dict( first_name=self.user.first_name, last_name=self.user.last_name, time_zone=self.user.time_zone, ) else: appstruct = {} return { 'form': form.render(appstruct), 'css_resources': css_resources, 'js_resources': js_resources, 'section': section_name, }
def view_delete(request): q = query_id(request) row = q.first() if not row: return id_not_found(request) if row.status_invoice: request.session.flash('Data sudah masuk di No Bayar', 'error') return route_list(request) if row.arsspds: form = Form(colander.Schema(), buttons=('cancel', )) else: form = Form(colander.Schema(), buttons=('delete', 'cancel')) if request.POST: if 'delete' in request.POST: msg = 'No Bayar ID %d %s sudah dihapus.' % (row.id, row.kode) q.delete() DBSession.flush() request.session.flash(msg) return route_list(request) return dict(row=row, form=form.render())