TurboGears - Mit MongoDB

TurboGears unterstützt auch MongoDB-Dokumentendatenbanken. Es verwendet Ming, eine Object Document Mapper-API. Die Verwendung von Ming ist der SQLAlchemy sehr ähnlich. Die Ming-Abfragesprache ermöglicht das Portieren eines SQLAlchemy-basierten TurboGears-Projekts nach Ming.

Was ist PyMongo?

PyMongo ist eine Python-Distribution, die Tools für die Arbeit mit MongoDB enthält. Ming erweitert PyMongo und bietet -

Deklarative Modelle
Schemaüberprüfung und -konvertierung
Schema Evolution
Reine InMemory MongoDB-Implementierung
Arbeitseinheit
Identitätskarte
Eins-zu-viele, viele-zu-eins und viele-zu-viele Beziehungen

Zunächst müssen Sie MongoDB herunterladen und installieren. Die neueste Distribution von MongoDB kann von heruntergeladen werdenhttps://www.mongodb.org/downloads

Starten Sie unter Windows den MongoDB-Server, indem Sie die Option -dbpath angeben.

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

D:\mongo folderdient zum Speichern der MongoDB-Datenbank. Server beginnt zu lauschenhttp://localhost:27017. Verwenden Sie nun den folgenden Befehl, um die MongoDB-Shell zu starten:

C:\mongodb\bin>Mongo

Unsere MongoDB-Umgebung ist jetzt bereit.

Erstellen Sie nun ein TurboGears-Projekt mit der Option -ming -

gearbox quickstart --ming Hello

Dieses schnell gestartete Projekt bietet eine Authentifizierungs- und Autorisierungsschicht, wie sie für die SQLAlchemy-Version bereitgestellt wird. Diese Anwendung versucht nun, eine Verbindung zu einem Server an Port 27017 auf dem lokalen Computer herzustellen. Die Datei development.ini im Projektordner enthält die folgenden Einstellungen:

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

Richten Sie das Projekt mit dem folgenden Befehl ein:

Python setup.py develop

Der Projektordner enthält den Unterordner models mit den folgenden Dateien:

__init__.py - Hier ist die databaseZugang ist eingerichtet. Ihre Sammlungen sollten seinimported into this module. Zum Beispiel werden wir die Studentensammlung in dieses Paket aufnehmen.
session.py - Diese Datei definiert die session of your database connection. Sie müssen dies jedes Mal importieren, wenn Sie a deklarieren müssenMappedClass um die Sitzung anzugeben perform queries.
auth.py - Diese Datei wird erstellt, wenn Sie haben enabled authentication and authorizationim Schnellstart. Es definiert drei Sammlungenrepoze.who, auf das sich außerdem Folgendes stützt: Benutzer, Gruppe und Berechtigung.

Definieren Sie Ihre Sammlung

Standardmäßig konfiguriert TurboGears Ming in einem deklarativen Modus. Dies ähnelt der deklarativen Unterstützung von SQLAlchemy und erfordert, dass jedes Modell von der MappedClass-Klasse erbt.

Für die MappedClass muss eine Unterklasse __mongometa__ verfügbar sein, die die Details zum Namen der Sammlung, in der die Dokumente gespeichert sind, und zur Sitzung, in der die Dokumente gespeichert sind, enthält.

MappedClass enthält auch die Definition von Feldern im Dokument. Das Odm-Modul von Ming enthält Definitionen verschiedener Arten von Feldeigenschaften -

FieldProperty
ForeignIdProperty
RelationProperty

Das ming.schema module definiert die folgenden Datentypen -

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

Speichern Sie den folgenden Code als student.py im Ordner "Hallo / Modelle", um die Schülersammlung in diesem Modell hinzuzufügen.

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

Fügen Sie dieses Modell schließlich in hello \ models \ __ init__.py ein

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

Führen Sie zum Einrichten dieser Modelle den folgenden Getriebebefehl aus:

Gearbox setup-app

Starten Sie den Server mit dem folgenden Getriebebefehl:

Gearbox serve –reload –debug

Öffnen Sie die Homepage dieser Anwendung (http://localhost:8080/)und melden Sie sich mit Manager-Anmeldeinformationen an. Auf der Admin-Seite dieser Anwendung wird die Liste der eingerichteten Modelle angezeigt. (Login als Manager, Passwort-Managementpass)

Die Erstellung von Sammlungen kann auch in der MongoDB-Weboberfläche sowie in der MongoDB-Shell überprüft werden.

Die ODMSession wird verwendet, um mehrere Datenbankoperationen mit den folgenden Funktionen auszuführen:

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

Entwerfen eines ToscoWidget-Formulars

Wir werden nun ein ToscoWidget-Formular entwerfen, um Schülerdaten einzugeben und in die Tabelle aufzunehmen, die dem Schülermodell zugrunde liegt.

Im Folgenden finden Sie den Code zum Erstellen einer studentform.py -

Hallo \ controller \ 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')

In der Rootcontroller-URL '/ add' der Anwendung, die die Funktion add () aufruft, wird das oben gestaltete Formular im Browser geöffnet. Die Senden-Schaltfläche ruft dann die Funktion save_record () auf. Es ruft die Formulardaten ab, speichert sie in der Schülertabelle und leitet die Anwendung an die URL '/ listrec' weiter, wodurch die Vorlage für die Schülerliste verfügbar gemacht wird.

Die root.py für diese Aktivität lautet wie folgt:

Hallo / controller / 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")

Die folgenden Vorlagen werden im Vorlagenordner erstellt:

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

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

Starten Sie den Server neu und geben Sie ein http://localhost:8080/add im Browser -

Jedes Mal, wenn die Daten hinzugefügt und die Schaltfläche "Senden" gedrückt wird, wird die Liste der aktuellen Einträge angezeigt.