TurboGears - Utilisation de MongoDB

TurboGears prend également en charge les bases de données de documents MongoDB. Il utilise Ming, une API Object Document Mapper. L'utilisation de Ming est très similaire à SQLAlchemy. Le langage de requête Ming permet de porter un projet TurboGears basé sur SQLAlchemy vers Ming.

Qu'est-ce que PyMongo

PyMongo est une distribution Python contenant des outils pour travailler avec MongoDB. Ming étend PyMongo en fournissant -

  • Modèles déclaratifs
  • Validation et conversion de schéma
  • Evolution du schéma
  • Implémentation Pure InMemory MongoDB
  • Unité de travail
  • Carte d'identité
  • Relations un-à-plusieurs, plusieurs-à-un et plusieurs-à-plusieurs

Tout d'abord, vous devez télécharger et installer MongoDB. La dernière distribution de MongoDB peut être téléchargée surhttps://www.mongodb.org/downloads

Sous Windows, démarrez le serveur MongoDB en fournissant l'option -dbpath -

C:\mongodb\bin>Mongod --dbpath d:\mongo

D:\mongo folderest désigné pour stocker la base de données MongoDB. Le serveur commence à écouter àhttp://localhost:27017. Maintenant, pour démarrer le shell MongoDB, utilisez la commande suivante -

C:\mongodb\bin>Mongo

Notre environnement MongoDB est maintenant prêt.

Créez maintenant un projet TurboGears avec l'option -ming -

gearbox quickstart --ming Hello

Ce projet à démarrage rapide fournira une couche d'authentification et d'autorisation comme celle fournie pour la version SQLAlchemy. Cette application va maintenant essayer de se connecter à un serveur sur le port 27017 sur la machine locale. Le fichier development.ini dans le dossier du projet contient les paramètres suivants -

ming.url = mongodb://localhost:27017/
ming.db = hello

Configurez le projet à l'aide de la commande suivante -

Python setup.py develop

Le dossier du projet contient le sous-dossier des modèles qui contient les fichiers suivants -

  • __init__.py - C'est là que le databasel'accès est mis en place. Vos collections doivent êtreimported into this module. Par exemple, nous ajouterons une collection étudiante dans ce package.

  • session.py - Ce fichier définit le session of your database connection. Vous devrez l'importer chaque fois que vous devrez déclarer unMappedClass pour spécifier la session à perform queries.

  • auth.py - Ce fichier sera créé, si vous avez enabled authentication and authorizationdans le démarrage rapide. Il définit trois collectionsrepoze.who, qui repose en outre sur: l'utilisateur, le groupe et l'autorisation.

Définir votre collection

Par défaut, TurboGears configure Ming en mode déclaratif. Ceci est similaire à la prise en charge déclarative de SQLAlchemy et nécessite que chaque modèle hérite de la classe MappedClass.

La classe MappedClass nécessite qu'une sous-classe __mongometa__ soit disponible à l'intérieur, qui fournit en outre les détails concernant le nom de la collection stockant les documents et la session utilisée pour stocker les documents.

MappedClass contient également la définition des champs dans le document. Le module odm de Ming a des définitions de différents types de propriétés de champ -

  • FieldProperty
  • ForeignIdProperty
  • RelationProperty

le ming.schema module définit les types de données suivants -

  • ming.schema.Anything
  • ming.schema.Array
  • ming.schema.Binary
  • ming.schema.Bool
  • ming.schema.Float
  • ming.schema.Int
  • ming.schema.ObjectId
  • ming.schema.Scalar
  • ming.schema.String

Pour ajouter la collection student dans ce modèle, enregistrez le code suivant sous le nom student.py dans le dossier hello / models.

Bonjour \ models \ student.py

from ming import schema
from ming.odm import MappedClass
from ming.odm import FieldProperty, ForeignIdProperty
from hello.model import DBSession
   
Class student(MappedClass):
   class __mongometa__:
      session = DBSession
      name = 'student'
      
   _id = FieldProperty(schema.ObjectId)
   name = FieldProperty(schema.String(required = True))
   city = FieldProperty(schema.String(if_missing = ''))
   address = FieldProperty(schema.String(if_missing = ''))
   pincode = FieldProperty(schema.String(if_missing = ''))

Enfin, incluez ce modèle dans hello \ models \ __ init__.py

# Import your model modules here.
from hello.model.auth import User, Group, Permission
from hello.model.student import student

Pour configurer ces modèles, exécutez la commande de boîte de vitesses suivante -

Gearbox setup-app

Démarrez le serveur avec la commande de boîte de vitesses suivante -

Gearbox serve –reload –debug

Ouvrez la page d'accueil de cette application (http://localhost:8080/)et connectez-vous avec les informations d'identification du gestionnaire. La page d'administration de cette application affichera la liste des modèles configurés. (connexion en tant que gestionnaire, gestion du mot de passe)

La création de collections peut également être vérifiée dans l'interface Web MongoDB ainsi que dans le shell MongoDB.

ODMSession est utilisé pour effectuer plusieurs opérations de base de données à l'aide des fonctions suivantes -

  • model.query.find()
  • model.query.find_and_modify()
  • model.remove()
  • model.update()
  • model.flush()

Conception d'un formulaire ToscoWidget

Nous allons maintenant concevoir un formulaire ToscoWidget pour saisir les données des étudiants et les ajouter dans le tableau sous-jacent au modèle étudiant.

Voici le code pour créer un studentform.py -

Bonjour \ controllers \ studentform.py

import tw2.core as twc
import tw2.forms as twf
   
class StudentForm(twf.Form):

   class child(twf.TableLayout):
      name = twf.TextField(size = 20)
      city = twf.TextField()
      address = twf.TextArea("",rows = 5, cols = 30)
      pincode = twf.NumberField()
		
   action = '/save_record'
   submit = twf.SubmitButton(value = 'Submit')

Dans l'URL '/ add' du Rootcontroller de l'application qui appelle la fonction add (), qui ouvrira le formulaire ci-dessus dans le navigateur. Son bouton de soumission appelle alors la fonction save_record (). Il récupère les données du formulaire et les enregistre dans la table des étudiants et redirige l'application vers l'URL '/ listrec', qui expose le modèle de liste d'étudiants.

Le root.py pour cette activité est le suivant -

Bonjour / controllers / root.py

from hello.lib.base import BaseController
from tg import expose, flash, redirect, request,url, lurl
from tg import redirect, validate
from hello import model
from hello.model import DBSession
from hello.model.student import student
   
from hello.controllers.studentform import StudentForm
   
class RootController(BaseController):
   @expose()
   def index(self):
      return "<h1>Hello World</h1>"
         
   @expose ("hello.templates.studentlist")
   def listrec(self):
      entries = student.query.find()
      return dict(entries = entries)
               
   @expose('hello.templates.studentform')
   def add(self, *args, **kw):
      return dict(page = 'studentform', form = StudentForm)
         
   @expose()
   def save_record(self, **kw):
      newstudent = student(name = kw['name'],city = kw['city'],
         address = kw['address'], pincode = kw['pincode'])
      DBSession.flush()
      flash(message = "new entry added successfully")
      redirect("/listrec")

Les modèles suivants sont créés dans le dossier des modèles -

Bonjour \ templates \ studentform.html

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:py = "http://genshi.edgewall.org/" lang = "en">
	
   <head>
      <title>Student Registration Form</title>
   </head>
	

   <body>
      <div id = "getting_started">
         ${form.display(value = dict(title = 'Enter data'))}
      </div>
   </body>
	
</html>

Bonjour \ templates \ studentlist.html

<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:py = "http://genshi.edgewall.org/">

   <head>
      <link rel = "stylesheet" type = "text/css" media = "screen" 
         href = ${tg.url('/css/style.css')}" />
      <title>Welcome to TurboGears</title>
   </head>
   
   <body>
      <h1>Welcome to TurboGears</h1>
		
      <py:with vars = "flash = tg.flash_obj.render('flash', use_js = False)">
         <div py:if = "flash" py:replace = "Markup(flash)" />
      </py:with>
      
      <h2>Current Entries</h2>
		
      <table border = '1'>
         <thead>
            <tr>
               <th>Name</th>
               <th>City</th>
               <th>Address</th>
               <th>Pincode</th>
            </tr>
         </thead>
         
         <tbody>
            <py:for each = "entry in entries">
               <tr>
                  <td>${entry.name}</td>
                  <td>${entry.city}</td>
                  <td>${entry.address}</td>
                  <td>${entry.pincode}</td>
               </tr>
            </py:for>
         </tbody>
      </table>
		
   </body>
	
</html>

Redémarrez le serveur et entrez http://localhost:8080/add dans le navigateur -

Chaque fois que les données sont ajoutées et que le bouton Soumettre est pressé, la liste des entrées actuelles sera affichée.