How to do it...

First, manually create a database in MongoDB using the command line. Let's name this database my_catalog:

>>> mongo
MongoDB shell version: v4.0.4
> use my_catalog
switched to db my_catalog

The following is an application that is a rewrite of our catalog application using MongoDB.

The first change comes to our configuration file, my_app/__init__.py:

from flask import Flask 
from flask_mongoengine import MongoEngine 
from redis import Redis 
 
 
app = Flask(__name__) 
app.config['MONGODB_SETTINGS'] = {'DB': 'my_catalog'} 
app.debug = True 
db = MongoEngine(app) 
 
redis = Redis() 
 
from my_app.catalog.views import catalog 
app.register_blueprint(catalog)

Note that instead of the usual SQLAlchemy-centric settings, we now have MONGODB_SETTINGS. Here, we just specify the name of the database to use, which, in our case, is my_catalog.

Next, we will create a Product model using MongoDB fields. This happens as usual in the models file, flask_catalog/my_app/catalog/models.py:

import datetime 
from my_app import db 
 
 
class Product(db.Document): 
    created_at = db.DateTimeField( 
        default=datetime.datetime.now, required=True 
    ) 
    key = db.StringField(max_length=255, required=True) 
    name = db.StringField(max_length=255, required=True) 
    price = db.DecimalField() 
 
    def __repr__(self): 
        return '<Product %r>' % self.id

Now would be a good time to look at the MongoDB fields used to create the model above, and their similarity with the SQLAlchemy fields used in the previous recipes. Here, instead of an ID field, we have created_at, which stores the timestamp in which the record was created. Also note the class that is inherited by Product while creating the model. In case of SQLAlchemy, it is db.Model and, in the case of MongoDB, it is db.Document. This is in accordance with how these database systems work. SQLAlchemy works with conventional RDBMS, but MongoDB is a NoSQL document database system.

The following is the views file, namely, flask_catalog/my_app/catalog/views.py:

from decimal import Decimal 
from flask import request, Blueprint, jsonify 
from my_app.catalog.models import Product 
 
catalog = Blueprint('catalog', __name__) 
 
@catalog.route('/') 
@catalog.route('/home') 
def home(): 
    return "Welcome to the Catalog Home." 
 
@catalog.route('/product/<key>') 
def product(key): 
    product = Product.objects.get_or_404(key=key) 
    return 'Product - %s, $%s' % (product.name, product.price) 
 
@catalog.route('/products') 
def products(): 
    products = Product.objects.all() 
    res = {} 
    for product in products: 
        res[product.key] = { 
            'name': product.name, 
            'price': str(product.price), 
        } 
    return jsonify(res) 
 
@catalog.route('/product-create', methods=['POST',]) 
def create_product(): 
    name = request.form.get('name') 
    key = request.form.get('key') 
    price = request.form.get('price') 
    product = Product( 
        name=name, 
        key=key, 
        price=Decimal(price) 
    ) 
    product.save() 
    return 'Product created.'

You will notice that it is very similar to the views created for the SQLAlchemy-based models. There are just a few differences in the methods that are called from the MongoEngine extension, and these should be easy to understand.

本周热推：

网络互联技术（实践篇）异构蜂窝网络关键理论与技术 Django 2 Web Development Cookbook Oracle Service Bus 11g Development Cookbook 边做边学物联网技术