Web2py - Formularios y validadores

web2py viene con potentes funciones para la generación de formularios. Cuatro formas distintas de crear formularios en web2py son las siguientes:

FORM- En términos de ayudantes HTML, se considera una implementación de bajo nivel. Un objeto FORM conoce el contenido de su campo.
SQLFORM - Proporciona las funcionalidades de Crear, Actualizar y Eliminar a la base de datos existente.
SQLFORM.factory- Se considera una capa de abstracción en la parte superior de SQLFORM, que genera un formulario similar a SQLFORM. Aquí, no es necesario crear una nueva base de datos.
CRUD Methods - Como su nombre indica, proporciona funciones de Crear, Recuperar, Actualizar y Eliminar con funcionalidades similares basadas en SQLFORM.

FORMAR

Considere una aplicación, que acepta una entrada del usuario y tiene un botón "enviar" para enviar la respuesta.

Controlador

El controlador "default.py" incluirá la siguiente función asociada

def display_form():
   return dict()

Ver

La vista asociada "default / display_form.html" mostrará la visualización del formulario en HTML como:

{{extend 'layout.html'}}
<h2>Basic Form</h2>

<form enctype = "multipart/form-data" action = "{{= URL()}}" method = "post">
   Your name:
   <input name = "name" />
   <input type = "submit" />
</form>

<h2>Submitted variables</h2>
{{= BEAUTIFY(request.vars)}}

El ejemplo anterior es el formulario HTML normal, que solicita la entrada del usuario. El mismo formulario se puede generar con los ayudantes como el objeto FORM.

Controlador

def display_form():
   form = FORM('Value:', INPUT(_value = 'name'), INPUT(_type = 'submit'))
   return dict(form = form)

La función anterior en el controlador "default.py" incluye el objeto FORM (ayuda HTML) que ayuda en la creación del formulario.

Ver

{{extend 'layout.html'}}
<h2>Basic form</h2>

{{= form}}
<h2>Submitted variables</h2>

{{= BEAUTIFY(request.vars)}}

La forma que genera el enunciado {{= form}}serializa el objeto FORM. Cuando un usuario llena el formulario y hace clic en el botón enviar, el formulario se autoenvía y la variablerequest.vars.value junto con su valor de entrada se muestra en la parte inferior.

SQLFORM

Ayuda en la creación de un formulario para la base de datos existente. Los pasos para su implementación se analizan a continuación.

Estableciendo conexión con la base de datos usando DAL, esto se crea usando el objeto DAL que también se llama constructor DAL. Después de establecer la conexión, el usuario puede crear la tabla respectiva.

db = DAL('sqlite://storage.sqlite')
db.define_table('employee', Field('name', requires = IS_NOT_EMPTY()))

Por lo tanto, hemos creado una tabla llamada "empleado". El controlador crea el formulario y el botón con las siguientes declaraciones:

form = SQLFORM(
   db.mytable,
   record = mytable_index,
   deletable = True,
   submit_button = T('Update')
)

Por lo tanto, para la tabla de empleados creada, la modificación en el controlador sería:

def display_form():
   form = SQLFORM(db.person)

No hay modificación en View. En el nuevo controlador, es necesario construir un FORM, ya que el constructor SQLFORM construido a partir de la tabla db.employee está definido en el modelo. El nuevo formulario, cuando se serializa, aparece de la siguiente manera:

<form enctype = "multipart/form-data" action = "" method = "post">
   
   <table>
      <tr id = "employee_name__row">
         <td>
            <label id = "person_name__label" for = "person_name">Your name: </label>
         </td>
         
         <td>
            <input type = "text" class = "string" name = "name" value = "" id = "employee_name" />
         </td>
         
         <td></td>
      </tr>

      <tr id = "submit_record__row">
         <td></td>
         <td><input value = "Submit" type = "submit" /></td>
         <td></td>
      </tr>
		
   </table>

   <input value = "9038845529" type = "hidden" name = "_formkey" />
   <input value = "employee" type = "hidden" name = "_formname" />
	
</form>

Todas las etiquetas del formulario tienen nombres derivados de la tabla y el nombre del campo.

Un SQLFORMEl objeto también se ocupa de los campos "cargar" guardando los archivos cargados en la carpeta "uploads". Esto se hace automáticamente. SQLFORM muestra valores "booleanos" en forma de casillas de verificación y valores de texto con la ayuda de“textareas”.

SQLFORM también utiliza el método de proceso, que es necesario si el usuario desea mantener los valores con un SQLFORM asociado.

Si form.process(keepvalues = True) entonces se acepta.

Ejemplo

def display_form():
   form = SQLFORM(db.employee)
if form.process().accepted:
   response.flash = 'form accepted'

elif form.errors:
   response.flash = 'form has errors'
else:
   response.flash = 'please fill out the form'

return dict(form = form)

SQLFORM.factory

A veces, el usuario necesita generar un formulario de manera que exista una tabla de base de datos existente sin la implementación de la base de datos. El usuario simplemente quiere aprovechar la capacidad de SQLFORM.

Esto se hace a través de form.factory y se mantiene en una sesión.

def form_from_factory():
   form = SQLFORM.factory(
      Field('your_name', requires = IS_NOT_EMPTY()),
      Field('your_image', 'upload'))

   if form.process().accepted:
      response.flash = 'form accepted'
      session.your_name = form.vars.your_name
      session.your_image = form.vars.your_image
   elif form.errors:
      response.flash = 'form has errors'

   return dict(form = form)

El formulario aparecerá como SQLFORM con el nombre y la imagen como sus campos, pero no existe tal tabla en la base de datos.

La vista "default / form_from_factory.html" se representará como -

{{extend 'layout.html'}}
{{= form}}

Métodos CRUD

CRUDes una API que se utiliza sobre SQLFORM. Como sugiere su nombre, se utiliza para la creación, recuperación, actualización y eliminación de forma apropiada.

CRUD, en comparación con otras API en web2py, no está expuesto; por lo tanto, es necesario que se importe.

from gluon.tools import Crud
crud = Crud(db)

El objeto CRUD definido anteriormente proporciona la siguiente API:

No Señor	API y funcionalidad
1	crud.tables() Devuelve una lista de tablas definidas en la base de datos.
2	crud.create(db.tablename) Devuelve un formulario de creación para el table tablename.
3	crud.read(db.tablename, id) Devuelve un formulario de solo lectura para tablename y registro de identificación.
4	crud.delete(db.tablename, id) elimina el registro
5	crud.select(db.tablename, query) Devuelve una lista de registros seleccionados de la tabla.
6	crud.search(db.tablename) Devuelve una tupla (formulario, registros) donde formulario es un formulario de búsqueda.
7	crud() Devuelve uno de los anteriores según request.args ().

Creación de forma

Creemos una forma. Siga los códigos que se indican a continuación.

Modelo

Se crea un nuevo modelo bajo el modelscarpeta de la aplicación. El nombre del archivo sería“dynamic_search.py”.

def build_query(field, op, value):
   if op == 'equals':
      return field == value
   
   elif op == 'not equal':
      return field != value
   
   elif op == 'greater than':
      return field > value
   
   elif op == 'less than':
      return field < value
   
   elif op == 'starts with':
      return field.startswith(value)
   
   elif op == 'ends with':
      return field.endswith(value)
   
   elif op == 'contains':
      return field.contains(value)

def dynamic_search(table):
   tbl = TABLE()
   selected = []
   ops = ['equals', 
      'not equal',
      'greater than',
      'less than',
      'starts with',
      'ends with',
      'contains']
		
query = table.id > 0

for field in table.fields:
   chkval = request.vars.get('chk'+field,None)
   txtval = request.vars.get('txt'+field,None)
   opval = request.vars.get('op'+field,None)
	
row = TR(TD(INPUT(_type = "checkbox",_name = "chk"+field,value = chkval == 'on')),
   TD(field),TD(SELECT(ops,_name = "op"+field,value = opval)),
   TD(INPUT(_type = "text",_name = "txt"+field,_value = txtval)))
	
tbl.append(row)

if chkval:
   if txtval:
      query &= build_query(table[field], opval,txtval)
      selected.append(table[field])
      form = FORM(tbl,INPUT(_type="submit"))
      results = db(query).select(*selected)
   return form, results

Controlador

El archivo asociado a saber “dynamic_search.py” en la sección de controladores incluirá el siguiente código:

def index():
   form,results = dynamic_search(db.things)
   return dict(form = form,results = results)

Ver

Podemos renderizar esto con la siguiente vista.

{{extend 'layout.html'}}
{{= form}}
{{= results}}

Así es como se ve:

↰ Previous page Next page ↱