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)})
