Forumlários

TRABALHO EM PROGRESSO

Só sei que `` py4web.utils.form.Form`` é um praticamente equivalente a `` SQLFORM`` do web2py.

O `` construtor Form`` aceita os seguintes argumentos:

Form(self,
     table,
     record=None,
     readonly=False,
     deletable=True,
     formstyle=FormStyleDefault,
     dbio=True,
     keep_values=False,
     form_name=False,
     hidden=None,
     before_validate=None):

Onde:

  • `` Table``: uma mesa DAL ou uma lista de campos (equivalente a SQLFORM.factory idade)

  • `` Record``: um registro DAL ou ID de registro

  • `` Readonly``: Defina como true para fazer um formulário readonly

  • `` Deletable``: definida para Falso ao apagamento disallow de registro

  • `` Formstyle``: uma função que processa a forma usando ajudantes (FormStyleDefault)

  • `` Dbio``: definida para Falso para evitar quaisquer gravações DB

  • `` Keep_values``: se definido como verdadeiro, ele lembra os valores do formulário previamente submetidas

  • `` Form_name``: o nome opcional desta forma

  • `` Hidden``: um dicionário de campos ocultos que é adicionado à forma

  • `` Before_validate``: um validador opcional.

Exemplo

Aqui está um exemplo simples de um formulário personalizado não utilizar acesso de banco de dados. Declaramos um ponto final `` / form_example``, que será utilizado tanto para o GET e para o POST da forma:

from py4web import Session, redirect, URL
from py4web.utils.dbstore import DBStore
from py4web.utils.form import Form, FormStyleBulma

db = DAL('sqlite:memory')
session =  Session(storage=DBStore(db))

@action('form_example', method=['GET', 'POST'])
@action.uses('form_example.html', session)
def form_example():
    form = Form([
        Field('product_name'),
        Field('product_quantity', 'integer')],
        formstyle=FormStyleBulma)
    if form.accepted:
        # Do something with form.vars['product_name'] and form.vars['product_quantity']
        redirect(URL('index'))
    return dict(form=form)

A forma pode ser exibida no modelo simplesmente usando `` [[= formar]] ``.

Validação de formulário

A validação da entrada de formulário pode ser feito de duas maneiras. Pode-se definir atributos `` `` requires`` de Field``, ou pode-se definir explicitamente uma função de validação. Para fazer o último, passamos para `` validate`` uma função que toma a forma e retorna um dicionário, os nomes de campo mapeamento para erros. Se o dicionário não é vazio, os erros serão exibidos para o usuário, e nenhum banco de dados I / O ocorrerá.

Aqui está um exemplo:

from py4web import Field
from py4web.utils.form import Form, FormStyleBulma
from pydal.validators import IS_INT_IN_RANGE

def check_nonnegative_quantity(form):
    if not form.errors and form.vars['product_quantity'] % 2:
        form.errors['product_quantity'] = T('The product quantity must be even')

@action('form_example', method=['GET', 'POST'])
@action.uses('form_example.html', session)
def form_example():
    form = Form([
        Field('product_name'),
        Field('product_quantity', 'integer', requires=IS_INT_IN_RANGE(0,100))],
        validation=check_nonnegative_quantity,
        formstyle=FormStyleBulma)
    if form.accepted:
        # Do something with form.vars['product_name'] and form.vars['product_quantity']
        redirect(URL('index'))
    return dict(form=form)

Form Structure Manipulation

Like in web2py, in py4web a form is rendered by helpers. Unlike web2py, it uses yatl helpers. This means the tree structure of a form can be manilupated before the form is serialized in HTML. For example:

db.define_table('paint', Field('color'))
form = Form(db.paint)
form.structure.find('[name=color]')[0]['_class'] = 'my-class'

Notice that a form does not make an HTML tree until form structure is accessed. Once accessed you can use .find(…) to find matching elements. The argument of find is a string following the filter syntax of jQuery. In the above case there is a single match [0] and we modify the _class attribute of that element. Attribute names of HTML elements must be preceded by an underscore.