TurboGears: uso de MongoDB

TurboGears también admite bases de datos de documentos MongoDB. Utiliza Ming, una API Object Document Mapper. El uso de Ming es muy similar al de SQLAlchemy. El lenguaje de consulta Ming hace posible portar el proyecto TurboGears basado en SQLAlchemy a Ming.

Que es PyMongo

PyMongo es una distribución de Python que contiene herramientas para trabajar con MongoDB. Ming extiende PyMongo proporcionando:

  • Modelos declarativos
  • Validación y conversión de esquemas
  • Evolución del esquema
  • Implementación de Pure InMemory MongoDB
  • Unidad de trabajo
  • Mapa de identidad
  • Relaciones uno a varios, varios a uno y varios a varios

En primer lugar, debe descargar e instalar MongoDB. La última distribución de MongoDB se puede descargar desdehttps://www.mongodb.org/downloads

En Windows, inicie el servidor MongoDB proporcionando la opción -dbpath -

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

D:\mongo folderestá designado para almacenar la base de datos MongoDB. El servidor comienza a escuchar enhttp://localhost:27017. Ahora, para iniciar el shell de MongoDB, use el siguiente comando:

C:\mongodb\bin>Mongo

Nuestro entorno MongoDB ya está listo.

Ahora cree un proyecto TurboGears con la opción -ming -

gearbox quickstart --ming Hello

Este proyecto de inicio rápido proporcionará una capa de autenticación y autorización como la que se proporciona para la versión de SQLAlchemy. Esta aplicación ahora intentará conectarse a un servidor en el puerto 27017 de la máquina local. El archivo development.ini en la carpeta del proyecto contiene la siguiente configuración:

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

Configure el proyecto usando el siguiente comando:

Python setup.py develop

La carpeta del proyecto contiene la subcarpeta de modelos que tiene los siguientes archivos:

  • __init__.py - Aquí es donde el databaseel acceso está configurado. Tus colecciones deben serimported into this module. Por ejemplo, agregaremos la colección de estudiantes en este paquete.

  • session.py - Este archivo define el session of your database connection. Deberá importar esto cada vez que tenga que declarar unMappedClass para especificar la sesión a perform queries.

  • auth.py - Este archivo se creará, si tiene enabled authentication and authorizationen el inicio rápido. Define tres coleccionesrepoze.who, que además se basa en: Usuario, Grupo y Permiso.

Definición de su colección

De forma predeterminada, TurboGears configura Ming en modo declarativo. Esto es similar al soporte declarativo de SQLAlchemy y necesita que cada modelo herede de la clase MappedClass.

MappedClass requiere que haya una subclase __mongometa__ disponible en el interior, que además proporciona los detalles sobre el nombre de la colección que almacena los documentos y la sesión utilizada para almacenar los documentos.

MappedClass también contiene la definición de campos en el documento. El módulo odm de Ming tiene definiciones de diferentes tipos de propiedades de campo:

  • FieldProperty
  • ForeignIdProperty
  • RelationProperty

los ming.schema module define los siguientes tipos de datos:

  • 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

Para agregar la colección de estudiantes en este modelo, guarde el siguiente código como student.py en la carpeta hello / models.

Hola \ modelos \ estudiante.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 = ''))

Finalmente, incluya este modelo en hello \ models \ __ init__.py

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

Para configurar estos modelos, ejecute el siguiente comando de caja de cambios:

Gearbox setup-app

Inicie el servidor con el siguiente comando de caja de cambios:

Gearbox serve –reload –debug

Abra la página de inicio de esta aplicación. (http://localhost:8080/)e inicie sesión con credenciales de administrador. La página de administración de esta aplicación mostrará la lista de modelos configurados. (iniciar sesión como administrador, contraseña administrar contraseña)

La creación de colecciones también se puede verificar en la interfaz web de MongoDB, así como en el shell de MongoDB.

La ODMSession se utiliza para realizar varias operaciones de base de datos utilizando las siguientes funciones:

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

Diseñar un formulario ToscoWidget

Ahora diseñaremos un formulario ToscoWidget para ingresar datos de los estudiantes y agregarlos a la tabla subyacente al modelo del estudiante.

A continuación se muestra el código para crear un studentform.py:

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

En la URL de la aplicación Rootcontroller '/ add' que llama a la función add (), que abrirá el formulario diseñado anteriormente en el navegador. Su botón de envío invoca la función save_record (). Recupera los datos del formulario y los guarda en la tabla de estudiantes y redirige la aplicación a la URL '/ listrec', que expone la plantilla de lista de estudiantes.

El root.py para esta actividad es el siguiente:

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

Las siguientes plantillas se crean en la carpeta de plantillas:

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

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

Reinicie el servidor e ingrese http://localhost:8080/add en el navegador -

Cada vez que se agregan los datos y se presiona el botón Enviar, se mostrará la lista de entradas actuales.