TurboGears - Utilizzo di MongoDB

TurboGears supporta anche i database di documenti MongoDB. Utilizza Ming, un'API Object Document Mapper. L'utilizzo di Ming è molto simile a SQLAlchemy. Il linguaggio di query Ming rende possibile il porting del progetto TurboGears basato su SQLAlchemy su Ming.

Cos'è PyMongo

PyMongo è una distribuzione Python contenente strumenti per lavorare con MongoDB. Ming estende l'offerta di PyMongo -

Modelli dichiarativi
Convalida e conversione dello schema
Evoluzione dello schema
Implementazione di Pure InMemory MongoDB
Unità di lavoro
Mappa di identità
Relazioni uno-a-molti, molti-a-uno e molti-a-molti

Prima di tutto, devi scaricare e installare MongoDB. L'ultima distribuzione di MongoDB può essere scaricata dahttps://www.mongodb.org/downloads

Su Windows, avvia il server MongoDB fornendo l'opzione -dbpath -

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

D:\mongo folderè designato per archiviare il database MongoDB. Il server inizia ad ascoltarehttp://localhost:27017. Ora per avviare la shell MongoDB usa il seguente comando:

C:\mongodb\bin>Mongo

Il nostro ambiente MongoDB è ora pronto.

Ora crea un progetto TurboGears con l'opzione -ming -

gearbox quickstart --ming Hello

Questo progetto di avvio rapido fornirà un livello di autenticazione e autorizzazione come quello fornito per la versione SQLAlchemy. Questa applicazione ora tenterà di connettersi a un server sulla porta 27017 sulla macchina locale. Il file development.ini nella cartella del progetto contiene le seguenti impostazioni:

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

Imposta il progetto utilizzando il seguente comando:

Python setup.py develop

La cartella del progetto contiene la sottocartella dei modelli che ha i seguenti file:

__init__.py - Qui è dove il file databasel'accesso è impostato. Le tue collezioni dovrebbero essereimported into this module. Ad esempio, aggiungeremo la raccolta studenti in questo pacchetto.
session.py - Questo file definisce il file session of your database connection. Dovrai importarlo ogni volta che dovrai dichiarare un fileMappedClass per specificare la sessione perform queries.
auth.py - Questo file verrà creato, se lo hai enabled authentication and authorizationnell'avvio rapido. Definisce tre collezionirepoze.who, che si basa ulteriormente su: utente, gruppo e autorizzazione.

Definizione della tua collezione

Per impostazione predefinita, TurboGears configura Ming in una modalità dichiarativa. Questo è simile al supporto dichiarativo SQLAlchemy e richiede che ogni modello erediti dalla classe MappedClass.

La MappedClass richiede che al suo interno sia disponibile una sottoclasse __mongometa__, che fornisce ulteriormente i dettagli riguardanti il nome della collezione in cui sono archiviati i documenti e la sessione utilizzata per archiviare i documenti.

MappedClass contiene anche la definizione dei campi nel documento. Il modulo odm di Ming ha definizioni di diversi tipi di proprietà del campo -

FieldProperty
ForeignIdProperty
RelationProperty

Il ming.schema module definisce i seguenti tipi di dati:

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

Per aggiungere la raccolta di studenti in questo modello, salva il codice seguente come student.py nella cartella hello / models.

Ciao \ 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 = ''))

Infine, includi questo modello in hello \ models \ __ init__.py

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

Per configurare questi modelli, eseguire il seguente comando del cambio:

Gearbox setup-app

Avvia il server con il seguente comando gearbox:

Gearbox serve –reload –debug

Apri la homepage di questa applicazione (http://localhost:8080/)e accedi con le credenziali di manager. La pagina di amministrazione di questa applicazione mostrerà l'elenco dei modelli impostati. (accedi come manager, password managepass)

La creazione di raccolte può essere verificata anche nell'interfaccia web di MongoDB e nella shell MongoDB.

ODMSession viene utilizzato per eseguire diverse operazioni di database utilizzando le seguenti funzioni:

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

Progettazione di un modulo ToscoWidget

Progetteremo ora un modulo ToscoWidget per inserire i dati dello studente e aggiungerlo nella tabella sottostante il modello dello studente.

Di seguito è riportato il codice per creare un studentform.py -

Ciao \ 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')

Nel Rootcontroller dell'applicazione l'URL '/ add' che chiama la funzione add (), che aprirà il modulo sopra progettato nel browser. Il suo pulsante di invio richiama quindi la funzione save_record (). Recupera i dati del modulo e li salva nella tabella degli studenti e reindirizza l'applicazione all'URL "/ listrec", che espone il modello dell'elenco degli studenti.

Il file root.py per questa attività è il seguente:

Ciao / 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")

I seguenti modelli vengono creati nella cartella dei modelli:

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

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

Riavvia il server ed entra http://localhost:8080/add nel browser -

Ogni volta che i dati vengono aggiunti e viene premuto il pulsante di invio, verrà visualizzato l'elenco delle voci correnti.