Web2py - Formulaires et validateurs

web2py est livré avec des fonctions puissantes pour la génération de formulaires. Voici quatre façons distinctes de créer des formulaires dans web2py:

FORM- En termes d'aide HTML, il est considéré comme une implémentation de bas niveau. Un objet FORM connaît le contenu de son champ.
SQLFORM - Il fournit les fonctionnalités de Créer, Mettre à jour et Supprimer à la base de données existante.
SQLFORM.factory- Il est considéré comme une couche d'abstraction en haut de SQLFORM, qui génère une forme similaire à SQLFORM. Ici, il n'est pas nécessaire de créer une nouvelle base de données.
CRUD Methods - Comme son nom l'indique, il fournit des fonctionnalités de création, de récupération, de mise à jour et de suppression avec les fonctionnalités similaires basées sur SQLFORM.

FORME

Prenons l'exemple d'une application qui accepte une entrée de l'utilisateur et dispose d'un bouton «Soumettre» pour soumettre la réponse.

Manette

Le contrôleur "default.py" inclura la fonction associée suivante

def display_form():
   return dict()

Vue

La vue associée "default / display_form.html" rendra l'affichage du formulaire en HTML comme -

{{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'exemple ci-dessus est le formulaire HTML normal, qui demande l'entrée de l'utilisateur. Le même formulaire peut être généré avec les helpers comme l'objet FORM.

Manette

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

La fonction ci-dessus dans le contrôleur "default.py" comprend un objet FORM (aide HTML) qui aide à la création du formulaire.

Vue

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

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

{{= BEAUTIFY(request.vars)}}

La forme qui est générée par l'instruction {{= form}}sérialise l'objet FORM. Lorsqu'un utilisateur remplit le formulaire et clique sur le bouton d'envoi, le formulaire s'auto-soumet et la variablerequest.vars.value avec sa valeur d'entrée est affiché en bas.

SQLFORM

Il aide à créer un formulaire dans la base de données existante. Les étapes de sa mise en œuvre sont décrites ci-dessous.

L'établissement de la connexion avec la base de données à l'aide de DAL, est créé à l'aide d'un objet DAL également appelé constructeur DAL. Après avoir établi la connexion, l'utilisateur peut créer la table respective.

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

Ainsi, nous avons créé une table nommée «employé». Le contrôleur crée le formulaire et le bouton avec les instructions suivantes -

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

Par conséquent, pour la table des employés créée, la modification dans le contrôleur serait -

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

Il n'y a pas de modification dans View. Dans le nouveau contrôleur, il est nécessaire de construire un FORM, puisque le constructeur SQLFORM en a construit un à partir de la table db.employee est défini dans le modèle. Le nouveau formulaire, lorsqu'il est sérialisé, apparaît comme suit -

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

Toutes les balises du formulaire ont des noms dérivés du nom de la table et du champ.

Un SQLFORMobject traite également les champs "upload" en enregistrant les fichiers téléchargés dans le dossier "uploads". Cela se fait automatiquement. SQLFORM affiche les valeurs «booléennes» sous forme de cases à cocher et de valeurs textuelles à l’aide de“textareas”.

SQLFORM utilise également la méthode process, ce qui est nécessaire si l'utilisateur souhaite conserver des valeurs avec un SQLFORM associé.

Si form.process(keepvalues = True) alors il est accepté.

Exemple

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

Parfois, l'utilisateur doit générer un formulaire de manière à ce qu'il existe une table de base de données existante sans l'implémentation de la base de données. L'utilisateur souhaite simplement profiter de la fonctionnalité SQLFORM.

Cela se fait via form.factory et il est maintenu dans une session.

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)

Le formulaire apparaîtra comme SQLFORM avec le nom et l'image comme champs, mais il n'y a pas de telle table existante dans la base de données.

La vue "default / form_from_factory.html" sera représentée par -

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

Méthodes CRUD

CRUDest une API utilisée en plus de SQLFORM. Comme son nom l'indique, il est utilisé pour la création, la récupération, la mise à jour et la suppression du formulaire approprié.

CRUD, par rapport aux autres API de web2py, n'est pas exposé; il est donc nécessaire qu'il soit importé.

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

L'objet CRUD défini ci-dessus fournit l'API suivante -

Sr.Non	API et fonctionnalités
1	crud.tables() Renvoie une liste de tables définies dans la base de données.
2	crud.create(db.tablename) Renvoie un formulaire de création pour le table tablename.
3	crud.read(db.tablename, id) Renvoie un formulaire en lecture seule pour tablename et enregistrez l'identifiant.
4	crud.delete(db.tablename, id) supprime l'enregistrement
5	crud.select(db.tablename, query) Renvoie une liste d'enregistrements sélectionnés dans la table.
6	crud.search(db.tablename) Renvoie un tuple (formulaire, enregistrements) où formulaire est un formulaire de recherche.
sept	crud() Renvoie l'un des éléments ci-dessus en fonction de request.args ().

Création de formulaire

Créons un formulaire. Suivez les codes ci-dessous.

Modèle

Un nouveau modèle est créé sous le modelsdossier de l'application. Le nom du fichier serait“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

Manette

Le fichier associé à savoir “dynamic_search.py” sous la section des contrôleurs comprendra le code suivant -

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

Vue

Nous pouvons rendre ceci avec la vue suivante.

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

Voici à quoi cela ressemble -

↰ Previous page Next page ↱

Web2py - Formulaires et validateurs

FORME

Manette

Vue

Manette

Vue

SQLFORM

Exemple

SQLFORM.factory

Méthodes CRUD

Création de formulaire

Modèle

Manette

Vue

Tutoriel Web2py