def set_password(context, request, success_msg=u"You've reset your password successfully."): form = Form(SetPasswordSchema(), buttons=('submit',)) rendered_form = None if 'submit' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: request.session.flash(u"There was an error.", 'error') rendered_form = e.render() else: token = appstruct['token'] email = appstruct['email'] user = _find_user(email) if (user is not None and validate_token(user, token) and token == user.confirm_token): password = appstruct['password'] user.password = get_principals().hash_password(password) user.confirm_token = None headers = remember(request, user.name) location = (appstruct['continue_to'] or resource_url(context, request)) request.session.flash(success_msg, 'success') return HTTPFound(location=location, headers=headers) else: request.session.flash( u"Your password reset token may have expired.", 'error')
def view_edit_unposting(request): row = query_id(request).first() if not row: return id_not_found(request) if not row.posted: request.session.flash('Data tidak dapat di Unposting, karena belum diposting.', 'error') return route_list(request) if row.disabled: request.session.flash('Data jurnal Tagihan sudah diposting.', 'error') return route_list(request) form = Form(colander.Schema(), buttons=('unposting','cancel')) if request.POST: if 'unposting' in request.POST: #Update status posted pada UTANG row.posted=0 save_request3(request, row) r = DBSession.query(AkJurnal.id).filter(AkJurnal.source_no==row.kode).first() #Menghapus Item Jurnal DBSession.query(AkJurnalItem).filter(AkJurnalItem.ak_jurnal_id==r).delete() DBSession.flush() #Menghapus UTANG yang sudah menjadi jurnal DBSession.query(AkJurnal).filter(AkJurnal.source_no==row.kode).delete() DBSession.flush() return route_list(request) return dict(row=row, form=form.render())
def view_delete(request): q = query_id(request) row = q.first() if not row: return id_not_found(request) if row.posted: request.session.flash('Data sudah diposting SKPD', 'error') return route_list(request) if row.posted1: request.session.flash('Data sudah diposting PPKD', 'error') return route_list(request) if row.nominal: request.session.flash('Data tidak bisa dihapus, karena memiliki data items', 'error') return route_list(request) form = Form(colander.Schema(), buttons=('hapus','cancel')) values= {} if request.POST: if 'hapus' in request.POST: msg = '%s dengan kode %s telah berhasil.' % (request.title, row.kode) DBSession.query(Sts).filter(Sts.id==request.matchdict['id']).delete() DBSession.flush() request.session.flash(msg) return route_list(request) return dict(row=row, form=form.render())
def my_view(request): request.response.headers.update({ 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'POST,GET,DELETE,PUT,OPTIONS', 'Access-Control-Allow-Headers': 'Origin, Content-Type, Accept, Authorization', 'Access-Control-Allow-Credentials': 'true', 'Access-Control-Max-Age': '1728000', }) ct = request.dbsession.query(Carrier).filter(Carrier.trackedOnly == True) cr = request.dbsession.query(Carrier).filter(Carrier.trackedOnly == False) print(ct.count()) print(cr.count()) schema = Search() searchform = Form(schema, action='/search/system', buttons=('submit', ), method='POST') rendered_form = searchform.render() return { 'searchform': rendered_form, 'deform': True, 'tracked_carriers': ct.count(), 'registered_carriers': cr.count() }
def password_form(self): # if admin is changing password for another user no verification of current password is needed if self.context != self.api.user_profile and self.api.context_has_permission(MANAGE_SERVER, self.api.root): schema = createSchema('ChangePasswordAdminSchema') else: schema = createSchema('ChangePasswordSchema') add_csrf_token(self.context, self.request, schema) schema = schema.bind(context=self.context, request=self.request, api = self.api) form = Form(schema, buttons=(button_update, button_cancel)) self.api.register_form_resources(form) post = self.request.POST if 'update' 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 self.context.set_password(appstruct['password']) msg = _(u"Password changed") self.api.flash_messages.add(msg) url = resource_url(self.context, self.request) return HTTPFound(location=url)
def view_delete(request): q = query_id(request) row = q.first() if not row: return id_not_found(request) if row.posted: request.session.flash('Data sudah diposting', 'error') return route_list(request) if row.status_spp: request.session.flash('Data sudah masuk di SPP', 'error') return route_list(request) if row.status_pay: request.session.flash('Data sudah masuk di Pembayaran Tagihan', 'error') return route_list(request) if row.amount: request.session.flash('Data tidak bisa dihapus, karena memiliki data items', 'error') return route_list(request) form = Form(colander.Schema(), buttons=('hapus','cancel')) values= {} if request.POST: if 'hapus' in request.POST: msg = '%s dengan kode %s telah berhasil.' % (request.title, row.kode) DBSession.query(APInvoice).filter(APInvoice.id==request.matchdict['id']).delete() DBSession.flush() request.session.flash(msg) return route_list(request) return dict(row=row, form=form.render())
def init_deform(root_package): Form.set_zpt_renderer(default_search_paths, translator=translator) node_modules_root = '{}:node_modules'.format(root_package) registry = widget.default_resource_registry registry.set_js_resources( 'openlayers', '3.0.0', '{}/openlayers/dist/ol.js'.format(node_modules_root)) registry.set_css_resources( 'openlayers', '3.0.0', '{}/openlayers/dist/ol.css'.format(node_modules_root)) registry.set_js_resources( 'c2cgeoform.deform_map', None, 'c2cgeoform:static/deform_map/controls.js') registry.set_css_resources( 'c2cgeoform.deform_map', None, 'c2cgeoform:static/deform_map/style.css') registry.set_js_resources( 'typeahead', '0.10.5', '{}/typeahead.js/dist/typeahead.bundle.min.js'. format(node_modules_root)) registry.set_css_resources( 'typeahead', '0.10.5', 'c2cgeoform:static/js/typeaheadjs.css') registry.set_js_resources( 'c2cgeoform.deform_search', None, 'c2cgeoform:static/deform_search/search.js') widget.MappingWidget.fields_template = 'mapping_fields' widget.FormWidget.fields_template = 'mapping_fields'
def view_delete(self): q = self.query_id() row = q.first() request=self.request if not row: return id_not_found(request) if row.posted: request.session.flash('Data sudah diposting', 'error') return self.route_list() if row.status_giro: request.session.flash('Data masih terdapat pada Giro', 'error') return self.route_list() form = Form(colander.Schema(), buttons=('hapus','cancel')) values= {} if request.POST: if 'hapus' in request.POST: #Untuk menghapus SP2D msg = '%s dengan kode %s telah berhasil.' % (request.title, row.kode) DBSession.query(Sp2d).filter(Sp2d.id==request.matchdict['id']).delete() DBSession.flush() request.session.flash(msg) #Untuk update status posted dan disabled pada SPM row = DBSession.query(Spm).filter(Spm.id==row.ap_spm_id).first() row.posted=0 row.disabled=0 self.save_request3(row) return self.route_list() return dict(row=row,form=form.render())
def add_form(self): post = self.request.POST if 'cancel' in post: self.api.flash_messages.add(_(u"Canceled")) url = resource_url(self.context, self.request) return HTTPFound(location=url) schema = createSchema('AddUserSchema') add_csrf_token(self.context, self.request, schema) schema = schema.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 '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 #Userid and name should be consistent name = appstruct['userid'] del appstruct['userid'] #creators takes care of setting the role owner as well as adding it to creators attr. obj = createContent('User', creators=[name], **appstruct) self.context[name] = obj self.api.flash_messages.add(_(u"Successfully added")) url = resource_url(self.context, self.request) return HTTPFound(location=url)
def edit(self): contest = self.context.contest e = {} e['name'] = contest.disp_name e['url'] = {} e['url']['manage'] = self.request.route_url('defcne.c', traverse=(contest.dc, contest.id, 'manage')) e['url']['edit'] = self.request.route_url('defcne.c', traverse=(contest.dc, contest.id, 'edit')) e['url']['extrainfo'] = self.request.route_url('defcne.c', traverse=(contest.dc, contest.id, 'extrainfo')) astruct = contest.to_appstruct() astruct['name'] = astruct['disp_name'] (schema, f) = ContestForm.create_form(request=self.request, action=self.request.current_route_url(), type='contest', origname=contest.name) if contest.logo: schema['logo'].description = "A logo has already been uploaded. Uploading a new logo will overwrite the previous logo!" del astruct['logo'] del schema['ticket'] f = Form(schema, action=self.request.current_route_url(), buttons=('submit',)) return { 'page_title': 'Edit Contest: {}'.format(contest.disp_name), 'cve': e, 'form': f.render(astruct), 'type': 'contest', }
def login(request): schema = UserLoginSchema(validator=user_login_validator) form = Form(schema, buttons=("submit",)) userid = authenticated_userid(request) if userid: return HTTPFound(location="/") if "submit" in request.POST: controls = request.POST.items() try: values = form.validate(controls) try: user = User.objects.get(email=values["email"]) except DoesNotExist: return HTTPNotFound() headers = remember(request, str(user.id)) return HTTPFound(location="/", headers=headers) except ValidationFailure: form_render = form.render() else: form_render = form.render() params = {"form": Markup(form_render)} return render_to_response("user/login.html", params)
def view_delete(request): q = query_id(request) row = q.first() x = row.approval_level a = row.product_plan_id if not row: return id_not_found(request) if x == 2: request.session.flash('Data tidak dapat dihapus, karena sudah disetujui.', 'error') return route_list(request) form = Form(colander.Schema(), buttons=('hapus','batal')) if request.POST: if 'hapus' in request.POST: msg = 'Approval rencana ID %d sudah dihapus.' % (row.id) q.delete() DBSession.flush() request.session.flash(msg) r = DBSession.query(ProductPlan).filter(ProductPlan.id==a).first() r.approval_level = 0 r.disabled = 0 save_request2(r) return route_list(request) return dict(row=row, form=form.render())
def register_view(context, request): form = Form(Signup(), buttons=('register',)) rendered_form = form.render(null) if 'register' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: rendered_form = e.render() else: pending = request.registry.queryAdapter(context, IRegistrations, name='pending') if pending is None: #pragma NO COVERAGE pending = PendingRegistrations(context) email = appstruct['email'] token = getRandomToken(request) pending.set(email, token=token) from_addr = request.registry.settings['cartouche.from_addr'] delivery = request.registry.queryUtility(IMailDelivery, default=localhost_mta) confirmation_url = view_url(context, request, 'confirmation_url', 'confirm_registration.html', email=email) body = REGISTRATION_EMAIL % {'token': token, 'confirmation_url': confirmation_url} message = Message() message['Subject'] = 'Site registration confirmation' message.set_payload(body) delivery.send(from_addr, [email], message) return HTTPFound(location=confirmation_url)
def calibration_report(self): """ Process form paramters, create a pdf calibration report form and generate a thumbnail view. """ form = Form(ReportSchema(), buttons=("submit",)) if "submit" in self.request.POST: #log.info("submit: %s", self.request.POST) controls = self.request.POST.items() try: appstruct = form.validate(controls) rendered_form = form.render(appstruct) report = self.populate_data(appstruct) self.makedir_write_files(appstruct) pdf = WasatchSinglePage(filename=report.filename, report=report) pdf.write_thumbnail() return {"form":rendered_form, "appstruct":appstruct} except ValidationFailure as exc: #log.exception(exc) log.info("Validation failure") return {'form':exc.render()} return {"form":form.render()}
def view_delete(request): q = query_id(request) row = q.first() uid = row.id if not row: return id_not_found(request) # Untuk mengecek apakah Rekening tersebut sedang dipakai oleh tabel lain. # a = DBSession.query(Reklame).filter(Reklame.rekening_id==uid).first() if a: request.session.flash('Data tidak bisa dihapus, karena sudah masuk di Objek Pajak.', 'error') return route_list(request) b = DBSession.query(Jenis).filter(Jenis.rekening_id==uid).first() if b: request.session.flash('Data tidak bisa dihapus, karena sudah masuk di Jenis Reklame.', 'error') return route_list(request) #--------------------------------------------------------------------------------------------------------# form = Form(colander.Schema(), buttons=('hapus','batal')) if request.POST: if 'hapus' in request.POST: msg = 'Rekening ID %d %s sudah dihapus.' % (row.id, row.nama) q.delete() DBSession.flush() request.session.flash(msg) return route_list(request) return dict(row=row, form=form.render())
def update_user(self): template_vars = {'menu_active': 'update_user'} form = Form(Registration().bind(request=self.request), buttons=('submit',), action=self.request.route_url('update_user')) if 'submit' in self.request.POST: # detect that the submit button was clicked controls = self.request.POST.items() # get the form controls try: form_data = form.validate(controls) # call validate except ValidationFailure as e: # catch the exception template_vars['form'] = form.render() # re-render the form with an exception return template_vars # if user is logged, we update his profile. Else we create a new user. userid = authenticated_userid(self.request) if userid: user = User.by_id(userid) # WARNING: only update authorized values else: del(form_data['csrf']) user = User(**form_data) DBSession.add(user) url = self.request.route_url('home') return HTTPFound(location=url) template_vars['form'] = form.render() return template_vars
def view_ar_payment_item_delete(self): request = self.request q = self.query_id() row = q.first() if not row: return self.id_not_found(request) if row.posted: request.session.flash('Data sudah diposting', 'error') return self.route_list() if row.posted1: request.session.flash('Data sudah diposting rekap', 'error') return self.route_list() form = Form(colander.Schema(), buttons=('hapus','batal')) if request.POST: if 'hapus' in request.POST: msg = 'TBP ID %d %s sudah dihapus.' % (row.id, row.ref_nama) try: q.delete() DBSession.flush() except: msg = 'TBP ID %d %s tidak dapat dihapus.' % (row.id, row.ref_nama) request.session.flash(msg) return self.route_list() return dict(row=row, form=form.render())
def admin_user_edit(request): def default_values(schema, user): for field in schema.children: if field.name in user and field.name != 'password': field.default = user[field.name] user = User.objects.with_id(request.matchdict['user']) schema = UserFormSchema(validator=user_form_validator(user)) default_values(schema, user) form = Form(schema, buttons=('submit',)) form_render = None if 'submit' in request.POST: controls = request.POST.items() try: values = form.validate(controls) user.update(values) user.save() default_values(schema, user) except ValidationFailure, e: form_render = e.render()
def generate_thumbnails(self): """ Display the form on get, on submission, save the uploaded pdf to the "serial" directory, and return the form populated along with the generated thumbnails. """ form = Form(PDFUploadSchema(), buttons=("submit",)) if "submit" in self.request.POST: log.info("submit: %s", self.request.POST) controls = self.request.POST.items() try: appstruct = form.validate(controls) rendered_form = form.render(appstruct) self.write_upload_files(appstruct) self.write_thumbnails(appstruct) return {"form":rendered_form, "appstruct":appstruct} except ValidationFailure as exc: log.info("Validation failure") return {'form':exc.render()} return {"form":form.render()}
def view_delete(request): q = query_id(request) row = q.first() if not row: return id_not_found(request) if row.posted: request.session.flash('Data sudah diposting', 'error') return route_list(request) if row.status_spp: request.session.flash('Data sudah di SPP', 'error') return route_list(request) """ if row.amount: request.session.flash('Data tidak bisa dihapus, karena memiliki data items', 'error') return route_list(request) """ form = Form(colander.Schema(), buttons=('hapus','cancel')) values= {} if request.POST: if 'hapus' in request.POST: msg = '%s dengan kode %s telah berhasil.' % (request.title, row.kode) DBSession.query(APPayment).filter(APPayment.id==request.matchdict['id']).delete() DBSession.flush() request.session.flash(msg) #Untuk update status posted dan status_pay pada APInvoice inv_id = row.invoice_id row = DBSession.query(APInvoice).filter(APInvoice.id==inv_id).first() row.status_pay = 0 save_request2(row) return route_list(request) return dict(row=row, form=form.render())
def request_password(self): schema = createSchema('RequestNewPasswordSchema').bind(context=self.context, request=self.request) form = Form(schema, buttons=(button_request, button_cancel)) self.api.register_form_resources(form) #Handle submitted information if 'request' in self.request.POST: controls = self.request.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 userid_or_email = appstruct['userid_or_email'] #userid here can be either an email address or a login name if '@' in userid_or_email: #assume email user = self.context['users'].get_user_by_email(userid_or_email) else: user = self.context['users'].get(userid_or_email) if IUser.providedBy(user): user.new_request_password_token(self.request) self.api.flash_messages.add(_('Email sent.')) url = resource_url(self.api.root, self.request) return HTTPFound(location = url) self.api.flash_messages.add(_('Username or email not found.'), type='error')
def view_login(request): if authenticated_userid(request): return HTTPFound(location=request.route_url('forbidden')) login_url = request.resource_url(request.context,'login') referrer = request.url if referrer == login_url: referrer = '/' came_from = request.params.get('came_from', referrer) schema = Login(validator=login_validator) form = Form(schema, buttons=('login',)) if 'login' in request.POST: controls = request.POST.items() identity = request.POST.get('username') user = schema.user = User.get_by_identity(identity) try: c = form.validate(controls) except ValidationFailure, e: request.session['login failed'] = e.render() return HTTPFound(location=came_from) #location.request.route_url('login') headers = get_login_headers(request, user) return HTTPFound(location=came_from, # request.route_url(came_from), headers=headers)
def view_delete(request): q = query_id(request) row = q.first() a = row.id if not row: return id_not_found(request) # Seleksi untuk mengecek komentar i = DBSession.query(DisposisiComment).filter(DisposisiComment.disposisi_id==a).first() if i: request.session.flash('Hapus dahulu komentar pada surat masuk.', 'error') return route_list(request) # Seleksi untuk mengecek penerima b = DBSession.query(PenerimaDisposisi).filter(PenerimaDisposisi.disposisi_id==a).first() if b: request.session.flash('Hapus dahulu penerima.', 'error') return route_list(request) form = Form(colander.Schema(), buttons=('hapus','batal')) if request.POST: if 'hapus' in request.POST: msg = 'Surat masuk 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 login_view(request): """ Login view """ log.debug("# Login page") form = Form(authSchema, buttons=(Button(name="submit", title="Valider", type='submit'),)) nextpage = request.params.get('nextpage') or request.route_url('index') app_struct = {'nextpage':nextpage} myform = form.render(app_struct) fail_message = None if 'submit' in request.params: log.debug(" + Validating authentication") controls = request.params.items() try: datas = form.validate(controls) except ValidationFailure, err: log.debug("Erreur d'authentification") myform = err.render() request.session.flash(_(request, u"Authentication error"), "error") return {'title':"Login page", 'form':myform,} log.debug(" + Validation ok, redirecting") log.debug(" -> {0}".format(nextpage)) login = datas['login'] # Storing the datas in the session remember(request, login) return HTTPFound(location=nextpage)
def view_delete(request): q = query_id(request) row = q.first() uid = row.id if not row: return id_not_found(request) a = DBSession.query(Kelurahan).filter(Kelurahan.kecamatan_id==uid).first() if a: request.session.flash('Data tidak bisa dihapus, karena sudah masuk di Tabel Kelurahan.', 'error') return route_list(request) b = DBSession.query(Reklame).filter(Reklame.kecamatan_id==uid).first() if b: request.session.flash('Data tidak bisa dihapus, karena sudah masuk di Tabel Objek Pajak.', 'error') return route_list(request) form = Form(colander.Schema(), buttons=('hapus','batal')) if request.POST: if 'hapus' in request.POST: msg = 'Kecamatan ID %d %s sudah dihapus.' % (row.id, row.nama) q.delete() DBSession.flush() request.session.flash(msg) return route_list(request) return dict(row=row,form=form.render())
def register(request): schema = RegisterForm() myform = Form(schema, buttons=('submit',)) userid = authenticated_userid(request) username = False if userid: user = User.by_id(userid) if user: username = user.name fields = { "layout": site_layout(), "page_title": "Register", "message": "", "url": request.application_url + '/register', "logged_in": username, } if username: fields['form'] = "You are already logged in. Please log out and try again." return fields if 'submit' in request.POST: controls = request.POST.items() try: myform.validate(controls) except ValidationFailure, e: fields['form'] = e.render() return fields #passed validation user = User() user.name = request.POST['username'] user.email = request.POST['email'] user.setpass(request.POST['password']) DBSession.add(user) fields['form'] = request.POST['username'] return fields
def variant(self): question_name = self.request.GET.get('question_name', None) globalquestions = self.root['questions'] if question_name not in globalquestions: self.add_flash_message(_(u"Invalid question name.")) url = self.request.resource_url(self.context) return HTTPFound(location=url) question = globalquestions[question_name] schema = createSchema(question.schemas['translate']) schema.title = _(u"Edit question variant for this organisation") schema = schema.bind(context = question, request = self.request) # add default locale description = question.get_original_title() descriptions = question.get_question_text() self.trans_util.add_translation_schema(schema['question_text'], self.trans_util.default_locale_name, description=description) self.trans_util.add_translations_schema(schema['question_text'], self.context, descriptions=descriptions, only_with_description=True) form = Form(schema, action = self.request.url, buttons=(self.buttons['save'], self.buttons['cancel'])) self.response['form_resources'] = form.get_widget_resources() if 'save' in self.request.POST: controls = self.request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response for (lang, value) in appstruct['question_text'].items(): self.context.set_variant(question_name, lang, value) url = self.request.resource_url(self.context, 'variants') return HTTPFound(location = url)
def login(request): schema = UserLoginSchema(validator=user_login_validator) form = Form(schema, buttons=('submit',)) userid = authenticated_userid(request) if userid: return HTTPFound(location='/') if 'submit' in request.POST: controls = request.POST.items() try: values = form.validate(controls) try: user = User.objects.get(email=values['email']) user.tzoffset = values['tzoffset'] user.save() except DoesNotExist: return HTTPNotFound() headers = remember(request, str(user.id), max_age=10000000000) return HTTPFound(location='/', headers=headers) except ValidationFailure: form_render = form.render() else: form_render = form.render() params = { 'form': Markup(form_render) } return render_to_response('user/login.html', params)
def post(self): controls = self.request.POST.items() form = Form(SignupForm()) data = form.validate(controls) name = data.get("name") mail = data.get("email") if DBSession.query(User).get(name): raise DuplicateUserName() if DBSession.query(User).filter_by(mail=mail).count() > 0: raise DuplicateEmail() user = User(name=name) password = user.generate_password() user.mail = mail DBSession.add(user) msg = WelcomeMessage() msg.send(self.request, user, password) self.flash("info", "Your account has been created and your " "initial password was sent to %s" % (mail)) return self.redirect("login")
def user_edit_submit(self): user = self.context.user controls = self.request.POST.items() schema = MagicUserEdit().bind(request=self.request) f = Form(schema, action=self.request.current_route_url(), button=('submit',)) try: appstruct = f.validate(controls) current_groups = set([x.id for x in user.groups]) selected_groups = set([x['group_id'] for x in appstruct['groups']]) new_groups = selected_groups - current_groups rem_groups = current_groups - selected_groups for g in new_groups: group = m.Group.find_group_by_id(g) user.groups.append(group) if len(rem_groups): for g in user.groups: if g.id in rem_groups: user.groups.remove(g) user.validated = appstruct['validated'] self.request.session.flash('User {} has been modified.'.format(user.disp_uname), queue='magic') return HTTPSeeOther(location = self.request.route_url('defcne.magic', traverse=('u'))) except ValidationFailure, e: return { 'form': e.render(), 'page_title': 'Editing user: {}'.format(user.disp_uname), }
def preferences(request): schema = UserPreferencesSchema() button1 = Button('submit', _('Save changes')) button1.css_class = 'btn-primary' form = Form(schema, buttons=(button1, )) user = request.user if 'submit' in request.POST: controls = request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure as e: return {'form': e.render()} user.update_preferences(appstruct) Session.add(user) request.session.flash( _('The changes were saved successfully'), 'success', ) return HTTPFound(location=request.route_path('user_preferences')) return { 'form': form.render({ 'allow_google_analytics': user.allow_google_analytics, 'send_passwords_periodically': user.send_passwords_periodically, }) }
def view_login(self): authed_user = None # TODO deferred validator doesn't work! # @colander.deferred # @staticmethod def validate_auth(form, values): nonlocal authed_user login = values.get('login') password = values.get('password') """:type : User""" user = User.by_any(login) # TODO check # -cdunklau- : d9k_ so i'm thinking you just need to do # form['login'].error = colander.Invalid(form['login'], 'Unknown login') # and then raise deform.ValidationFailure(form, form.cstruct, None) or something if not user: raise exception_for_schema_field(form, 'login', 'Пользователь не найден') if not user.active: raise exception_for_schema_field(form, 'login', 'Аккаунт пользователя заблокирован') if user.password_hash is None: if user.email is None: raise exception_for_schema_field(form, 'password', 'Вход по паролю отключен. Почта не была привязана к аккаунту') raise exception_for_schema_field(form, 'password', 'Вход по паролю отключен') if not user.check_password(password): raise exception_for_schema_field(form, 'password', 'Неверный пароль') if not user.email_checked: raise exception_for_schema_field(form, 'login', 'Email пользователя не подтверждён. Проверьте почтовый ящик') # TODO показывать email "в звёздочках" authed_user = user login_form = Form( LoginSchema(validator=validate_auth).bind(), buttons=[Button(name='login_form_submit', title='Вход')], # css_class='no-red-stars' ) login_form.css_class += ' no-red-stars' if 'login_form_submit' in self.request.params: controls = self.request.POST.items() try: login_form.validate(controls) except deform.ValidationFailure as e: return dict(rendered_login_form=e.render()) if authed_user is not None: self.request.session.invalidate() headers = security.remember(self.request, authed_user.id) index = self.request.route_url('admin_index' if authed_user.is_admin() else 'index') return HTTPFound(location=index, headers=headers) return dict(rendered_login_form=login_form.render())
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 login_form_show(self): """Just show login form @todo add request_from hidden value @todo add csrf hidden value""" schema = AuthSchema() form = Form(schema, buttons=('submit', )) return {'form': form.render()}
def get_project_form(request): """ Returns the project add/edit form """ schema = get_project_schema().bind(request=request) form = Form(schema, buttons=(submit_btn, )) form.widget = GridFormWidget(named_grid=FORM_GRID) return form
def __init__(self, request): super(Home, self).__init__(request) schema = PlanSchema().bind(request=self.request) self.plan_form = Form( schema, buttons=(Button(title=u'登録'), ), method='post', action=self.request.route_path('plan'), )
def get_customer_form(request): """ Returns the customer add/edit form """ schema = get_customer_schema(request) schema = schema.bind(request=request) form = Form(schema, buttons=(submit_btn, )) form.widget = GridFormWidget(grid=FORM_GRID) return form
def init(): from deform import Form from deform_jinja2 import jinja2_renderer_factory from deform_jinja2.translator import PyramidTranslator renderer = jinja2_renderer_factory(search_paths=SEARCH_PATHS, translator=PyramidTranslator()) Form.set_default_renderer(renderer)
def site_view(self): def refresh_cache(): # we simply remove all cached files cache_directory = real_path(CACHE_SUBDIRECTORY) if os.path.exists(cache_directory): for fn in os.listdir(cache_directory): shutil.rmtree(os.path.join(cache_directory, fn)) schema = Configuration() settings = get_current_registry().settings def get_some_scan(request): result = request.solr_scan.search(q='*:*', rows=1) if not result.documents: return None doc = result.documents[0] url = request.route_url('service_scan_images_item', number=str(doc['number']), number_of_image=doc['default_image_id']) image_url = os.path.join( url, 'file_%s' % str(hash(doc['dateLastModified']))) return image_url example_image = '' default_values = [(node.name, unicode(settings.get(node.name, 'xxx'))) for node in schema.children] form = Form(schema, buttons=('submit', )) if self.request.POST: controls = self.request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure, e: return {'form': e.render(), 'example_image': example_image} # Process the valid form data, do some work # if the file does not exist, we raise a validation error if appstruct['watermark_file'] and not os.path.exists( appstruct['watermark_file']): raise HTTPBadRequest( 'This file {watermark_file} cannot be found'.format( **appstruct)) # if anything has changed, we reset the cache for key in appstruct: if settings.get(key) != appstruct[key]: refresh_cache() continue for key in appstruct: # save the new settings in the database self.set_setting(self.request, key, appstruct[key]) # update the global settings object with our new values settings.update(appstruct) example_image = get_some_scan(self.request) return {"form": form.render(), 'example_image': example_image}
def edit_account_view(context, request): confirmed = request.registry.queryAdapter(context, IRegistrations, name='confirmed') if confirmed is None: #pragma NO COVERAGE confirmed = ConfirmedRegistrations(context) identity = request.environ.get('repoze.who.identity') if identity is None: return HTTPUnauthorized() userid = identity['repoze.who.userid'] account_info = confirmed.get(userid) if account_info is None: return HTTPForbidden() appstruct = { 'login_name': account_info.login, 'email': account_info.email, 'security': { 'question': account_info.security_question or '', 'answer': account_info.security_answer or '', }, } schema = EditAccount().bind(current_login_name=account_info.login, confirmed=confirmed, old_password=account_info.password) form = Form(schema, buttons=('update', )) rendered_form = form.render(appstruct) if 'update' in request.POST: try: appstruct = form.validate(request.POST.items()) except ValidationFailure, e: rendered_form = e.render() else: login = appstruct['login_name'] email = appstruct['email'] pwd_mgr = SSHAPasswordManager() password = pwd_mgr.encodePassword(appstruct['password']) security_question = appstruct['security']['question'] security_answer = appstruct['security']['answer'] confirmed.set( userid, email=email, login=login, password=password, security_question=security_question, security_answer=security_answer, ) return HTTPFound(location=view_url( context, request, 'after_edit_url', request.view_name, ))
def poll_form(self): """ Return rendered poll form or process a vote. """ poll_plugin = self.query_poll_plugin(self.context) if not poll_plugin: return HTTPForbidden() schema = poll_plugin.get_vote_schema(self.request, self.api) add_csrf_token(self.context, self.request, schema) schema = schema.bind(context=self.context, request=self.request, api=self.api) form = Form(schema, action=self.request.resource_url(self.context, '_poll_form'), buttons=(button_vote, ), formid="vote_form") can_vote = has_permission(security.ADD_VOTE, self.context, self.request) userid = self.api.userid post = self.request.POST if 'vote' in post: if not can_vote: raise HTTPForbidden(u"You're not allowed to vote") controls = post.items() try: appstruct = form.validate(controls) except ValidationFailure, e: self.response['form'] = e.render() return self.response Vote = poll_plugin.get_vote_class() if not IVote.implementedBy(Vote): raise TypeError( "Poll plugins method get_vote_class returned something that didn't implement IVote." ) #Remove crsf_token from appstruct after validation appstruct.pop('csrf_token', None) if userid in self.context: vote = self.context[userid] assert IVote.providedBy(vote) vote.set_vote_data(appstruct) else: vote = Vote(creators=[userid]) #We don't need to send events here, since object added will take care of that vote.set_vote_data(appstruct, notify=False) #To fire events after set_vote_data is done self.context[userid] = vote success_msg = _(u"Your vote has been registered!") if self.request.is_xhr: self.response['success_msg'] = success_msg return Response( render("templates/snippets/vote_success.pt", self.response, request=self.request)) self.api.flash_messages.add(success_msg) url = self.request.resource_url(self.context.__parent__, anchor=self.context.uid) return HTTPFound(location=url)
def destroy(request): schema = AccountDestroySchema() button1 = Button('submit', _('Yes, I am sure. Destroy my account')) button1.css_class = 'btn-danger' button2 = Button('cancel', _('Cancel')) button2.css_class = 'btn-default' form = Form(schema, buttons=(button1, button2)) user = request.user can_destroy = len(user.applications) == 0 context = { 'passwords': len(user.passwords), 'can_destroy': can_destroy, } if 'submit' in request.POST: if not can_destroy: request.session.flash( _('You must remove your applications before destroying your account' ), 'error', ) return HTTPFound( location=request.route_path('oauth2_developer_applications')) controls = request.POST.items() try: appstruct = form.validate(controls) except ValidationFailure as e: context['form'] = e.render() return context reason = appstruct['reason'] notify_admins_of_account_removal(request, user, reason) Session.delete(user) request.session.flash( _('Your account has been removed. Have a nice day!'), 'success', ) return logout(request) elif 'cancel' in request.POST: request.session.flash( _('Thanks for reconsidering removing your account!'), 'info', ) return HTTPFound(location=request.route_path('user_information')) context['form'] = form.render() return context
def view_register(self): # def validate_register(form, values): # pass register_form = Form( RegisterSchema( # validator=validate_register ).bind(), buttons=[Button(name='register_form_submit', title='Зарегистрировать')] ) if 'register_form_submit' in self.request.params: controls = self.request.POST.items() try: data = register_form.validate(controls) except deform.ValidationFailure as e: r = e.render() return dict(rendered_register_form=r) # TODO create new user # new_user = User(login='******', name='Дмитрий Комаров', email='*****@*****.**') new_user = User() dictalchemy.utils.fromdict(new_user, data) self.request.session.invalidate() # TODO check user.beforeSave() is called before save # if not new_user.name: # new_user.name = new_user.login password = data.get('password') if not password: password = User.generate_password() self.request.session['new_password'] = password new_user.set_password(password) try: with transaction.manager: DBSession.add(new_user) except DBAPIError: return Response(conn_err_msg, content_type='text/plain', status_int=500) helpers.send_html_mail(new_user.email, 'registered', {'user_name': new_user.name, 'password': password}) new_user.initiate_email_check() try: with transaction.manager: DBSession.add(new_user) except DBAPIError: return Response(conn_err_msg, content_type='text/plain', status_int=500) self.request.session['new_user_id'] = new_user.id success_location = self.request.route_url('register_success') return HTTPFound(location=success_location) return dict(rendered_register_form=register_form.render())
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 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 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 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 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 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 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 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 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 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 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_admin(request): id_ = request.matchdict['id'] geo_form_schema = _get_schema(request) renderer = _get_renderer(geo_form_schema.templates_admin) form = Form(geo_form_schema.schema_admin, buttons=('submit',), renderer=renderer) obj = DBSession.query(geo_form_schema.model).get(id_) rendered = form.render(geo_form_schema.schema_admin.dictify(obj), readonly=True, request=request) return { 'form': rendered, 'schema': geo_form_schema, 'deform_dependencies': form.get_widget_resources()}
def get_form(self, schema): """ Return the search form that should be used for this view :param obj schema: The form's colander.Schema :returns: The form object :rtype: obj """ # counter is used to avoid field name conflicts form = Form(schema, counter=itertools.count(15000), method='GET') form = self.set_form_widget(form) form.buttons = (self.get_filter_button(), ) return form
def get_form(self, schema): # counter is used to avoid field name conflicts form = Form(schema, counter=itertools.count(15000), method='GET') if self.grid is not None: form.formid = 'grid_search_form' form.widget = deform_extensions.GridFormWidget( named_grid=self.grid) form.buttons = (deform.Button(title='Filtrer', name='submit', type='submit', css_class='btn btn-primary'), ) else: form.widget.template = "autonomie:deform_templates/searchform.pt" return form
def view_delete(request): q = query_id(request) row = q.first() if not row: return id_not_found(request) form = Form(colander.Schema(), buttons=('delete', 'cancel')) if request.POST: if 'delete' in request.POST: msg = 'Rekon E-PAP ID %d berhasil dihapus.' % (row.id) q.delete() DBSession.flush() request.session.flash(msg) return route_list(request) return dict(row=row, form=form.render())
def client_edit(client_id): if 'cancel' in request.form: return redirect(url_for('.client_list')) client = Session.query(Client).filter(Client.id == client_id, Client.deleted == False).first() if not client: current_app.logger.warning( u'Client with id {0} not found'.format(client_id)) flash(u'Klijent nije pronađen', 'danger') return redirect(url_for('.client_list')) client_new_schema = ClientNewValidator() client_new_form = Form(client_new_schema, action=url_for('.client_edit', client_id=client.id), appstruct=client.get_appstruct(), buttons=get_form_buttons()) if 'submit' in request.form: print request.form try: controls = request.form.items(multi=True) appstruct = client_new_form.validate(controls) except ValidationFailure as e: current_app.logger.warning(e.error) template_context = {'client_new_form': client_new_form} return render_template(CLIENT_NEW_TEMPLATE, **template_context) edited = False for key in appstruct: if hasattr(client, key): if appstruct[key] != colander.null: if getattr(client, key) != appstruct[key]: setattr(client, key, appstruct[key]) edited = True else: if getattr(client, key) is not None: setattr(client, key, None) edited = True if edited: Session.flush() flash(u'Uspješno ste uredili klijenta', 'success') return redirect(url_for('.client_list')) template_context = { 'page_title': u'Uredi klijenta', 'client_new_form': client_new_form } return render_template(CLIENT_NEW_TEMPLATE, **template_context)