Web2py - Moduli e validatori

web2py è dotato di potenti funzioni per la generazione di moduli. Quattro modi distinti per creare moduli in web2py sono i seguenti:

  • FORM- In termini di helper HTML, è considerata un'implementazione di basso livello. Un oggetto FORM è a conoscenza del contenuto del suo campo.

  • SQLFORM - Fornisce le funzionalità di Crea, Aggiorna ed Elimina al database esistente.

  • SQLFORM.factory- È considerato come livello di astrazione nella parte superiore di SQLFORM, che genera un modulo simile a SQLFORM. Qui non è necessario creare un nuovo database.

  • CRUD Methods - Come suggerisce il nome, fornisce funzionalità di creazione, recupero, aggiornamento ed eliminazione con funzionalità simili basate su SQLFORM.

MODULO

Considera un'applicazione, che accetta un input da parte dell'utente e ha un pulsante "invia" per inviare la risposta.

Controller

Il controller "default.py" includerà la seguente funzione associata

def display_form():
   return dict()

Visualizza

La vista associata "default / display_form.html" renderà la visualizzazione del modulo in HTML come -

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

L'esempio sopra è il normale modulo HTML, che richiede l'input dell'utente. Lo stesso modulo può essere generato con gli helper come l'oggetto FORM.

Controller

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

La funzione di cui sopra nel controller "default.py" include l'oggetto FORM (helper HTML) che aiuta nella creazione del modulo.

Visualizza

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

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

{{= BEAUTIFY(request.vars)}}

La forma generata dall'affermazione {{= form}}serializza l'oggetto FORM. Quando un utente compila il modulo e fa clic sul pulsante di invio, il modulo si invia automaticamente e la variabilerequest.vars.value insieme al suo valore di input viene visualizzato in basso.

SQLFORM

Aiuta nella creazione di un modulo per il database esistente. I passaggi per la sua implementazione sono discussi di seguito.

Stabilendo la connessione con il database utilizzando DAL, questo viene creato utilizzando l'oggetto DAL che è anche chiamato costruttore DAL. Dopo aver stabilito la connessione, l'utente può creare la rispettiva tabella.

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

Pertanto, abbiamo creato una tabella denominata "dipendente". Il controller crea il modulo e il pulsante con le seguenti istruzioni:

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

Pertanto, per la tabella dei dipendenti creata, la modifica nel controller sarebbe:

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

Non ci sono modifiche in View. Nel nuovo controller, è necessario creare un FORM, poiché il costruttore SQLFORM ne ha creato uno dalla tabella db.employee è definito nel modello. Il nuovo modulo, una volta serializzato, appare come segue:

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

Tutti i tag nel modulo hanno nomi derivati ​​dalla tabella e dal nome del campo.

Un SQLFORML'oggetto si occupa anche dei campi "upload" salvando i file caricati nella cartella "uploads". Questo viene fatto automaticamente. SQLFORM visualizza i valori "booleani" sotto forma di caselle di controllo e valori di testo con l'aiuto di“textareas”.

SQLFORM utilizza anche il metodo del processo, necessario se l'utente desidera mantenere i valori con un SQLFORM associato.

Se form.process(keepvalues = True) quindi è accettato.

Esempio

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 volte, l'utente deve generare un modulo in modo che esista una tabella di database esistente senza l'implementazione del database. L'utente vuole semplicemente trarre vantaggio dalla capacità SQLFORM.

Questo viene fatto tramite form.factory e viene mantenuto in una sessione.

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)

Il modulo apparirà come SQLFORM con nome e immagine come campi, ma non esiste una tabella esistente nel database.

La visualizzazione "default / form_from_factory.html" rappresenterà come -

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

Metodi CRUD

CRUDè un'API utilizzata sopra SQLFORM. Come suggerisce il nome, viene utilizzato per la creazione, il recupero, l'aggiornamento e la cancellazione del modulo appropriato.

CRUD, rispetto ad altre API in web2py, non è esposto; pertanto, è necessario che venga importato.

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

L'oggetto CRUD definito sopra fornisce la seguente API:

Suor n API e funzionalità
1

crud.tables()

Restituisce un elenco di tabelle definite nel database.
2

crud.create(db.tablename)

Restituisce un modulo di creazione per il table tablename.
3

crud.read(db.tablename, id)

Restituisce un modulo di sola lettura per tablename e record id.
4

crud.delete(db.tablename, id)

cancella il record
5

crud.select(db.tablename, query)

Restituisce un elenco di record selezionati dalla tabella.
6

crud.search(db.tablename)

Restituisce una tupla (form, record) dove form è un form di ricerca.
7

crud()

Restituisce uno dei precedenti in base a request.args ().

Creazione della forma

Creiamo un modulo. Segui i codici riportati di seguito.

Modello

Viene creato un nuovo modello con modelscartella dell'applicazione. Il nome del file sarebbe“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

Controller

Il file associato vale a dire “dynamic_search.py” nella sezione controller includerà il seguente codice:

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

Visualizza

Possiamo renderizzarlo con la seguente vista.

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

Ecco come appare -