TurboGears - Usando MongoDB

O TurboGears também oferece suporte a bancos de dados de documentos MongoDB. Ele usa Ming, uma API Object Document Mapper. O uso de Ming é muito semelhante ao SQLAlchemy. A linguagem de consulta Ming torna possível portar o projeto TurboGears baseado em SQLAlchemy para Ming.

O que é PyMongo

PyMongo é uma distribuição Python que contém ferramentas para trabalhar com MongoDB. Ming estende PyMongo fornecendo -

Modelos Declarativos
Validação e conversão de esquema
Evolução do esquema
Implementação do Pure InMemory MongoDB
Unidade de Trabalho
Mapa de Identidade
Relações um-para-muitos, muitos-para-um e muitos-para-muitos

Em primeiro lugar, você precisa baixar e instalar o MongoDB. A distribuição mais recente do MongoDB pode ser baixada emhttps://www.mongodb.org/downloads

No Windows, inicie o servidor MongoDB fornecendo a opção -dbpath -

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

D:\mongo folderé designado para armazenar o banco de dados MongoDB. O servidor começa a escutar àshttp://localhost:27017. Agora, para iniciar o shell do MongoDB, use o seguinte comando -

C:\mongodb\bin>Mongo

Nosso ambiente MongoDB agora está pronto.

Agora crie um projeto TurboGears com a opção -ming -

gearbox quickstart --ming Hello

Este projeto de início rápido fornecerá uma camada de autenticação e autorização como a fornecida para a versão SQLAlchemy. Este aplicativo agora tentará se conectar a um servidor na porta 27017 na máquina local. O arquivo development.ini na pasta do projeto contém as seguintes configurações -

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

Configure o projeto usando o seguinte comando -

Python setup.py develop

A pasta do projeto contém a subpasta de modelos que contém os seguintes arquivos -

__init__.py - É aqui que o databaseo acesso está configurado. Suas coleções devem serimported into this module. Por exemplo, devemos adicionar a coleção do aluno neste pacote.
session.py - Este arquivo define o session of your database connection. Você precisará importar isso toda vez que precisar declarar umMappedClass para especificar a sessão para perform queries.
auth.py - Este arquivo será criado, se você tiver enabled authentication and authorizationno início rápido. Ele define três coleçõesrepoze.who, que depende ainda de: Usuário, Grupo e Permissão.

Definindo sua coleção

Por padrão, TurboGears configura Ming em um modo declarativo. Isso é semelhante ao suporte declarativo SQLAlchemy e precisa que cada modelo herde da classe MappedClass.

O MappedClass requer que uma subclasse __mongometa__ esteja disponível dentro, o que fornece mais detalhes sobre o nome da coleção que armazena os documentos e a sessão usada para armazenar os documentos.

MappedClass também contém a definição de campos no documento. O módulo odm de Ming tem definições de diferentes tipos de propriedades de campo -

FieldProperty
ForeignIdProperty
RelationProperty

o ming.schema module define os seguintes tipos de dados -

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 adicionar a coleção do aluno neste modelo, salve o seguinte código como student.py na pasta hello / models.

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

Por fim, inclua este modelo em 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 esses modelos, execute o seguinte comando da caixa de engrenagens -

Gearbox setup-app

Inicie o servidor com o seguinte comando da caixa de velocidades -

Gearbox serve –reload –debug

Abra a página inicial deste aplicativo (http://localhost:8080/)e faça login com credenciais de gerente. A página de administração deste aplicativo mostrará a lista de modelos configurados. (faça login como gerente, senha para gerenciar)

A criação de coleções também pode ser verificada na interface da web do MongoDB, bem como no shell do MongoDB.

A ODMSession é usada para realizar várias operações de banco de dados usando as seguintes funções -

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

Projetando um formulário ToscoWidget

Devemos agora projetar um formulário ToscoWidget para inserir os dados do aluno e adicioná-los à tabela subjacente ao modelo do aluno.

A seguir está o código para criar um studentform.py -

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

No URL '/ add' do controlador raiz do aplicativo que chama a função add (), que abrirá o formulário projetado acima no navegador. Seu botão de envio invoca a função save_record (). Ele recupera os dados do formulário e os salva na tabela do aluno e redireciona o aplicativo para a URL '/ listrec', que expõe o modelo da lista de alunos.

O root.py para esta atividade é o seguinte -

Olá / 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")

Os seguintes modelos são criados na pasta de modelos -

Olá \ 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>

Hello \ 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 o servidor e entre http://localhost:8080/add no navegador -

Cada vez que os dados são adicionados e o botão enviar é pressionado, a lista de entradas atuais será exibida.