def build_form_renderer(): """ Builds the form handler by creating and adding the forms. """ # build forms membership_listing_date_pdf_form = deform.Form( MembershipListingDate(), buttons=[deform.Button('submit', _(u'Generate PDF'))], formid='membership_listing_date_pdf') membership_listing_year_end_pdf_form = deform.Form( MembershipListingYearEnd(), buttons=[deform.Button('submit', _(u'Generate PDF'))], formid='membership_listing_year_end_pdf') # create form handler form_renderer = MultipleFormRenderer() # add forms form_renderer.add_form(membership_listing_date_pdf_form, membership_listing_date_pdf_callback) form_renderer.add_form(membership_listing_year_end_pdf_form, membership_listing_date_pdf_callback) return form_renderer
def mapa(request): """ Página dos orçamentos mapeados """ esquemaPesq = FormPesqMapa().bind(request=request) esquemaPesq.title = "Pesquisa" formPesq = deform.Form(esquemaPesq, buttons=('Pesquisar',)) esquema = FormMapa().bind(request=request) esquema.title = "Mapa" #legenda do botão - inserir ponto form = deform.Form(esquema, buttons=('Inserir',)) if 'Pesquisar' in request.POST: try: formPesq.validate(request.POST.items()) except deform.ValidationFailure as e: return {'form': e.render()} return HTTPFound(location=request.route_url('lista')) elif 'Inserir' in request.POST: return HTTPFound(location=request.route_url('inserir_ponto')) else: # values passed to template for rendering return { 'form':form.render(), 'formPesq':formPesq.render(), 'showmenu':True, }
def password_form(request) -> deform.Form: userid = request.identity.userid users = request.get_collection("morpfw.pas.user") user = users.get_by_userid(userid) if user["is_administrator"]: return deform.Form(AdminPasswordSchema(), buttons=("Change password", ), formid="password-form") return deform.Form(PasswordSchema(), buttons=("Change password", ), formid="password-form")
def denunciar(request): """ Formulário para enviar denúncia de mídia """ id = int(request.matchdict['id']) tipoMidia = request.matchdict['tmidia'] idMidia = int(request.matchdict['idM']) atividade = Atividade() atividade = request.db["atvTree"][id] if tipoMidia == 'foto': midia = atividade.midia_foto[idMidia] elif tipoMidia == 'video': midia = atividade.midia_video[idMidia] elif tipoMidia == 'comentario': midia = atividade.midia_coment[idMidia] esquema = FormDenuncia().bind(request=request) esquema.title = "Denunciar mídia" #midia = Midia("", "") #selecionar de algum jeito essa mídia vinda de um link form = deform.Form(esquema, buttons=('Enviar',)) if 'Enviar' in request.POST: # Validação do formulário try: esquema = FormDenuncia().bind(request=request) esquema.title = "Denunciar mídia" form = deform.Form(esquema, buttons=('Enviar',)) form.render() form.validate(request.POST.items()) except deform.ValidationFailure as e: return {'form': e.render()} denuncia = Denuncia(request.POST.get("motivo"), authenticated_userid(request)) midia.addDenuncia(denuncia) atividade.delMidiaDen() cidadao = request.db["usrTree"][authenticated_userid(request)] cidadao.addDenuncia(denuncia) transaction.commit() return HTTPFound(location=request.route_url('orcamentoId', id=id)) else: return {'form': form.render()}
def __init__(self, request): self.request = request email_schema = schemas.EmailChangeSchema().bind(request=request) password_schema = schemas.PasswordChangeSchema().bind(request=request) self.forms = { 'email': deform.Form(email_schema, buttons=(_('Change email address'),), formid='email'), 'password': deform.Form(password_schema, buttons=(_('Change password'),), formid='password'), }
def login(request): schema = LoginSchema().bind(request=request) login_btn = deform.form.Button(name='form.submitted', title="Login") form = deform.Form(schema, buttons=(login_btn, )) next_url = request.route_url('home') message = '' if 'form.submitted' in request.params: # Creating post request to recaptcha API API_KEY = request.registry.settings['pyramid_recaptcha.private_key'] RECAPTCHA_API_URL = 'https://www.google.com/recaptcha/api/siteverify' data = { 'secret': API_KEY, 'response': request.params['g-recaptcha-response'] } # Sending request r = requests.post(url=RECAPTCHA_API_URL, data=data) api_response = r.json() if api_response.get('success'): login = request.params['login'] password = request.params['password'] user = request.dbsession.query(User).filter_by(name=login).first() if user is not None and user.check_password(password): headers = remember(request, user.id) request.session.flash('You logged in') return HTTPFound(location=next_url, headers=headers) else: message = 'Failed login' else: message = 'Failed Captcha' return dict( form=form.render(), message=message, next_url=next_url, )
def view_user(self): id = int(self.request.matchdict['id']) user = self.users.get_user(id) allgroups = self.users.group_query().all() ugids = [g.id for g in user.groups] available = [g for g in allgroups if g.id not in ugids] choices = [(g.id, g.name) for g in available] schema = AddtoGroupSchema() schema['group'].widget = make_select_widget(choices) form = deform.Form(schema, buttons=('submit', )) self.layout.resources.deform_auto_need(form) if 'submit' in self.request.POST: controls = self.request.POST.items() try: data = form.validate(controls) except deform.ValidationFailure, e: self.layout.content = e.render() return {} gid = data['group'] self.users.add_user_to_group(gid, id) g = self.users.get_group(gid) msg = 'added user %s to group %s' % (user.username, g.name) self.layout.content = msg return {}
def get_form(cls, localizer): class Schema(colander.Schema): username = colander.SchemaNode( colander.String(), title=localizer.translate(_('Username')), description=localizer.translate(_('User name')), ) __LOCALE__ = colander.SchemaNode( colander.String(), widget=deform.widget.HiddenWidget(), default=localizer.locale_name, ) schema = Schema() btn_cancel = deform.form.Button(name='btn_cancel', title=localizer.translate(_('Cancel')), type='submit', value='cancel', disabled=False) btn_submit = deform.form.Button(name='btn_submit', title=localizer.translate(_('Submit')), type='submit', value='submit', disabled=False) return deform.Form(schema, buttons=(btn_cancel, btn_submit))
def __init__(self, request): self.request = request self.schema = schemas.ResetPasswordSchema().bind(request=self.request) self.form = deform.Form( schema=self.schema, action=self.request.route_path('reset_password'), buttons=(_('Save'), ))
def process_edit(context, request): formschema = dataclass_to_colander( context.model.schema, include_fields=context.edit_include_fields, exclude_fields=context.edit_exclude_fields) data = context.model.data.as_dict() controls = list(request.POST.items()) form = deform.Form(formschema(), buttons=('Submit', )) failed = False try: data = form.validate(controls) except deform.ValidationFailure as e: form = e failed = True if not failed: context.model.update(data) return morepath.redirect(request.link(context)) return { 'page_title': 'Edit %s' % html.escape(str(context.model.__class__.__name__)), 'form_title': 'Edit', 'form': form, 'form_data': data, }
def create(context, request): if not context.create_view_enabled: raise HTTPNotFound() default_value_fields = list(request.GET.keys()) formschema = dc2colander.convert( context.collection.schema, request=request, include_fields=context.create_include_fields, exclude_fields=context.create_exclude_fields, hidden_fields=default_value_fields, default_tzinfo=request.timezone(), ) fs = formschema() fs = fs.bind(context=context, request=request) form_data = {} for f in default_value_fields: form_data[f] = request.GET.get(f) return { "page_title": "Create %s" % html.escape( str(context.collection.__class__.__name__.replace( "Collection", ""))), "form_title": "Create", "form": deform.Form(fs, buttons=("Submit", )), "form_data": form_data, }
def show_edit(self): '''Displays the form editor, for new or existing forms.''' form_id = self.request.matchdict['id'] fields_config_json = json.dumps({ft[0]: ft[1](Field()).initJson() \ for ft in fields_dict.items()}) if form_id == 'new': form = Form() fields_json = json.dumps([]) else: form = self._get_form_if_belongs_to_user(form_id=form_id) fields_json = safe_json_dumps([f.to_dict() for f in form.fields]) # (indent=1 causes the serialization to be much prettier.) dform = d.Form(form_schema, formid='FirstPanel') \ .render(self.model_to_dict(form, ('name', 'description', 'rich', 'use_rich', 'submit_label'))) # TODO: Consider a caching alternative; this query might be # too expensive to stay in this view. # List of all system templates system_templates = sas.query(FormTemplate) \ .filter(FormTemplate.system_template_id != None) \ .order_by(FormTemplate.system_template_id).all() # Field types class names fieldtypes_json = json.dumps([typ.__class__.__name__ \ for typ in all_fieldtypes]) return dict(pagetitle=self._pagetitle, form=form, dform=dform, action=self.url('form', action='edit', id=form_id), system_templates=system_templates, fields_json=fields_json, all_fieldtypes=all_fieldtypes, fieldtypes_json=fieldtypes_json, fields_config_json=fields_config_json)
def create_deform(self, schema: colander.Schema, request: Request, context: object, mode: EditMode, buttons: List[deform.Button], model: type) -> deform.Form: """Create a Deform based on a given generated schema. This * Adds CSRF token to schema * Calles schema customizer * Binds schema to request and context or calls custom schema binder * Creates the form instance """ # Make sure we have CSRF token add_csrf(schema) # Customize schema customizer = self.schema_customizer or _noop_customizer customizer(schema=schema, request=request, context=context, mode=mode, model=model) # Bind schema binder = default_schema_binder or self.schema_binder schema = binder(schema=schema, request=request, context=context, mode=mode, model=model) form = deform.Form(schema, buttons=buttons, resource_registry=ResourceRegistry(request)) return form
def subscribe_newsletter(request: Request): schema = NewsletterSubscriptionSchema().bind(request=request) form = deform.Form(schema) # User submitted this form if request.method == "POST": if 'subscribe' in request.POST: try: appstruct = form.validate(request.POST.items()) email = appstruct["email"] subscribe_email(request, email) # Thank user and take him/her to the next page messages.add( request, kind="info", html=True, msg= "<strong>{}</strong> has been subscribed to the newsletter." .format(email)) return HTTPFound(request.route_url("home")) except deform.ValidationFailure as e: # Render a form version where errors are visible next to the fields, # and the submitted values are posted back messages.add(request, kind="error", msg="Email was not valid") return HTTPFound(request.route_url("home")) else: # We don't know which control caused form submission return HTTPBadRequest("Unknown form button pressed") return HTTPBadRequest("POST-only endpoint")
def process_create(context, request): formschema = dataclass_to_colander( context.collection.schema, include_fields=context.create_include_fields, exclude_fields=context.create_exclude_fields) controls = list(request.POST.items()) form = deform.Form(formschema(), buttons=('Submit', )) failed = False try: data = form.validate(controls) except deform.ValidationFailure as e: form = e failed = True if not failed: obj = context.collection.create(data) obj.save() return morepath.redirect(request.link(context.modelui_class(request, obj, context))) return { 'page_title': 'Create %s' % html.escape( str(context.collection.__class__.__name__.replace('Collection', ''))), 'form_title': 'Create', 'form': form, }
def get_form(self, formid): formschema = dc2colander.convert( self.schema, request=self.request, default_tzinfo=self.request.timezone() ) fs = formschema() fs = fs.bind(context=self.context, request=self.request) return deform.Form(fs, formid=formid)
async def home(request): favorite_twitch_streamer_name = request.session.get( 'favorite_twitch_streamer_name', '') form = deform.Form(StreamerSchema(), buttons=('submit', )) if 'submit' in request.params: controls = request.POST.items() try: appstruct = form.validate(controls) except deform.ValidationFailure as errors: # Form is NOT valid return {'form': errors.render()} request.session['favorite_twitch_streamer_name'] = appstruct[ 'favorite_twitch_streamer_name'] with open('/tmp/data.json') as f: f.write( json.dumps({ 'auth_token': request.session.get('access_token'), 'usr_id': appstruct['favorite_twitch_streamer_name'] })) return HTTPFound('/') return { 'form': form.render( {'favorite_twitch_streamer_name': favorite_twitch_streamer_name}) }
def edit_member_action(self, REQUEST): """ view """ agent = self._get_ldap_agent() org_id = REQUEST.form['org_id'] user_id = REQUEST.form['user_id'] user = REQUEST.AUTHENTICATED_USER if not self.can_edit_members(user, org_id, user_id): _set_session_message(REQUEST, 'error', "You are not allowed to edit user %s" % user_id) REQUEST.RESPONSE.redirect(self.absolute_url() + '/members_html?id=' + org_id) return None user_form = deform.Form(user_info_edit_schema) try: new_info = user_form.validate(REQUEST.form.items()) except deform.ValidationFailure, e: session = REQUEST.SESSION errors = {} for field_error in e.error.children: errors[field_error.node.name] = field_error.msg session[SESSION_FORM_ERRORS] = errors session[SESSION_FORM_DATA] = dict(REQUEST.form) msg = u"Please correct the errors below and try again." _set_session_message(REQUEST, 'error', msg)
def _dummy_field(self): class DummySchema(colander.Schema): this_field = colander.SchemaNode(colander.String(), widget=self._cut()) form = deform.Form(DummySchema()) return form['this_field']
def __init__(self, request): self.request = request self.schema = schemas.LoginSchema().bind(request=self.request) self.form = deform.Form(self.schema) self.login_redirect = self.request.route_url('stream') self.logout_redirect = self.request.route_url('index')
def get_form(cls, localizer, publishers): def validate_username(node, value): msg = _("Username must not contains non alphanumeric digits", ) if not value.isalnum(): raise colander.Invalid(node, msg) class Schema(colander.Schema): username = colander.SchemaNode( colander.String(), validator=colander.All(validate_username), title=localizer.translate(_('Username')), description=localizer.translate(_('User name')), ) password = colander.SchemaNode( colander.String(), validator=colander.Length(min=5), widget=deform.widget.CheckedPasswordWidget(size=20), description=localizer.translate( _('Type your password and confirm it')), ) email = colander.SchemaNode( colander.String(), validator=colander.Email(), missing=None, title=localizer.translate(_('E-mail')), description=localizer.translate(_('Contact e-mail')), ) group = colander.SchemaNode( colander.String(), widget=deform.widget.SelectWidget( values=[('editor', 'Editor'), ('admin', 'Administrator')]), title=localizer.translate(_('Group')), description=localizer.translate(_('Group name')), ) publisher = colander.SchemaNode( colander.String(), widget=deform.widget.SelectWidget(values=publishers), title=localizer.translate(_('Publisher')), description=localizer.translate(_('Publisher name')), ) __LOCALE__ = colander.SchemaNode( colander.String(), widget=deform.widget.HiddenWidget(), default=localizer.locale_name, ) schema = Schema() btn_cancel = deform.form.Button(name='btn_cancel', title=localizer.translate(_('Cancel')), type='submit', value='cancel', disabled=False) btn_submit = deform.form.Button(name='btn_submit', title=localizer.translate(_('Submit')), type='submit', value='submit', disabled=False) return deform.Form(schema, buttons=(btn_cancel, btn_submit))
def simple_registration_get(backend, request): """ /registration/simple view callable for GET method. Renders registration template. """ schema = SignupSchema() form = deform.Form(schema, buttons=('create',)) return {"form":form.render()}
def get_form(cls, localizer): class Schema(colander.Schema): new_password = colander.SchemaNode( colander.String(), validator=colander.Length(min=5), widget=deform.widget.CheckedPasswordWidget(size=20), description=localizer.translate( _('Type your password and confirm it')), ) recovery_key = colander.SchemaNode( colander.String(), widget=deform.widget.HiddenWidget(), ) __LOCALE__ = colander.SchemaNode( colander.String(), widget=deform.widget.HiddenWidget(), default=localizer.locale_name, ) schema = Schema() btn_cancel = deform.form.Button(name='btn_cancel', title=localizer.translate(_('Cancel')), type='submit', value='cancel', disabled=False) btn_submit = deform.form.Button(name='btn_submit', title=localizer.translate(_('Submit')), type='submit', value='submit', disabled=False) return deform.Form(schema, buttons=(btn_cancel, btn_submit))
def subscribe_newsletter(request: Request): """Newsletter Subscription view.""" schema = NewsletterSubscriptionSchema().bind(request=request) form = deform.Form(schema) # In case of validation error, we return the user to the form came_from = request.referer or request.route_url('home') if request.method != "POST": return HTTPBadRequest("POST-only endpoint") # User submitted this form if 'subscribe' in request.POST: try: appstruct = form.validate(request.POST.items()) email = appstruct["email"] came_from = appstruct["came_from"] subscribe_email(request, email) # Thank user and take them to the next page msg = "<strong>{email}</strong> has been subscribed to the newsletter.".format(email=email) msg_class = 'info' messages.add(request, kind=msg_class, msg=msg, html=True) except deform.ValidationFailure: # Render a form version where errors are visible next to the fields, # and the submitted values are posted back msg = "Email was not valid." msg_class = 'error' messages.add(request, kind=msg_class, msg=msg) return HTTPFound(came_from) else: # We don't know which control caused form submission return HTTPBadRequest("Unknown form button pressed")
def r_senha(request): """ Reconfiguração de senha do usuário Envia token para email do usuário """ esquema = FormRSenha().bind(request=request) esquema.title = "Reenviar senha" form = deform.Form(esquema, buttons=('Enviar',)) if 'Enviar' in request.POST: # Validação do formulário try: appstruct = form.validate(request.POST.items()) except deform.ValidationFailure as e: return {'form': e.render()} email = request.POST.get("email") if email in request.db["usrTree"]: #enviar email com token, armazenar esse token headers = remember(request, email) return HTTPFound(location=request.route_url('rcad_senha'), headers=headers) else: warnings.warn("Email ou senha inválidos", DeprecationWarning) return HTTPFound(location=request.route_url('rcad_senha')) else: return {'form': form.render()}
def create_deform(self, schema: colander.Schema, request: Request, context: Resource, mode: EditMode, buttons: t.List[deform.Button], model: type) -> deform.Form: """Create a Deform based on a given generated schema. This method does the following: * Adds CSRF token to schema * Calls schema customizer * Binds schema to request and context or calls custom schema binder * Creates the form instance :param schema: Schema to be used. :param request: Current HTTP request. :param context: Traversal context. :param mode: Form mode. :param buttons: List of buttons to be added. :param model: SQLAlchemy model class :return: Constructed form object """ # Make sure we have CSRF token add_csrf(schema) # Customize schema customizer = self.schema_customizer or _noop_customizer customizer(schema=schema, request=request, context=context, mode=mode, model=model) # Bind schema binder = self.schema_binder or default_schema_binder schema = binder(schema=schema, request=request, context=context, mode=mode, model=model) form = deform.Form(schema, buttons=buttons, resource_registry=ResourceRegistry(request)) return form
def integral(self): view = self.get_view() view['tikz'] = None view['e'] = None form = deform.Form(self.schema, buttons=('submit', )) if self.request.method == 'POST' and 'submit' in self.request.POST: try: appstruct = form.validate(self.request.POST.items()) form.set_appstruct(appstruct) view['tikz'] = draw_region_between_curves( a=appstruct['a'], b=appstruct['b'], f=appstruct['function1'], g=appstruct['function2'], min_x=appstruct['min_x'], max_x=appstruct['max_x'], min_y=appstruct['min_y'], max_y=appstruct['max_y'], draw_grid=appstruct['draw_grid'], draw_labels=appstruct['draw_labels']) except deform.exception.ValidationFailure as e: view['e'] = e view['form'] = form return view
def process_xattredit(context, request): xattrprovider = context.model.xattrprovider() if xattrprovider: xattrformschema = dataclass_to_colander(xattrprovider.schema) else: raise HTTPNotFound() data = xattrprovider.as_dict() controls = list(request.POST.items()) form = deform.Form(xattrformschema(), buttons=('Submit', )) failed = False try: data = form.validate(controls) except deform.ValidationFailure as e: form = e failed = True if not failed: # FIXME: model update should allow datetime object xattrprovider.update(data) return morepath.redirect(request.link(context)) return { 'page_title': 'Edit %s' % html.escape(str(context.model.__class__.__name__)), 'form_title': 'Edit', 'form': form, 'form_data': data, }
def create(context, request): default_value_fields = list(request.GET.keys()) formschema = dataclass_to_colander( context.collection.schema, request=request, include_fields=context.create_include_fields, exclude_fields=context.create_exclude_fields, hidden_fields=default_value_fields, ) fs = formschema() fs.bind(context=context, request=request) form_data = {} for f in default_value_fields: form_data[f] = request.GET.get(f) return { "page_title": "Create %s" % html.escape( str(context.collection.__class__.__name__.replace( "Collection", ""))), "form_title": "Create", "form": deform.Form(fs, buttons=("Submit", )), "form_data": form_data, }
def persona(self): request = self.request schema = schemas.PersonaSchema().bind(request=request) form = deform.Form( schema, formid='persona', use_ajax=True, ajax_options=self.ajax_options ) lm = request.layout_manager lm.layout.add_form(form) try: if request.POST.get('__formid__', '') == 'persona': persona = form.validate(request.POST.items()) if persona.get('id', None) == -1: controller = AuthController(request) return controller.logout() else: # TODO: multiple personas persona = None except deform.exception.ValidationFailure as e: return dict(persona={'form': e.render()}) else: persona = dict(id=0 if request.user else -1) return dict(persona={'form': form.render(persona)})