Crie um aplicativo

Em seu projeto quickstart, você pode criar um aplicação que interage com o banco de dados de amostra do Atlas chamado sample_mflix. Este banco de dados contém uma coleção movies, que armazena informações sobre filmes. O banco de dados também contém uma coleção users, que armazena informações sobre os visualizadores de filmes que usam um serviço de streaming.

Para saber mais sobre o sample_mflix banco de dados do, consulte Amostra de conjunto de dados Mflix na documentação do Atlas .

Crie um aplicativo "sample_mflix"

A partir do diretório raiz do seu projeto, execute o seguinte comando para criar um novo aplicativo Django chamado sample_mflix com base em um modelo personalizado:

python manage.py startapp sample_mflix --template https://github.com/mongodb-labs/django-mongodb-app/archive/refs/heads/5.2.x.zip

Observação

Modelo de aplicativo

O modelo django-mongodb-app garante que seu arquivo app.py inclua a linha "default_auto_field = 'django_mongodb_backend.fields.ObjectIdAutoField'".

Criar modelos para dados de filmes, prêmios e visualizadores

Abra o arquivo models.py no diretório sample_mflix e substitua seu conteúdo pelo seguinte código:

from django.db import models
from django.conf import settings
from django_mongodb_backend.fields import EmbeddedModelField, ArrayField
from django_mongodb_backend.models import EmbeddedModel
class Award(EmbeddedModel):
    wins = models.IntegerField(default=0)
    nominations = models.IntegerField(default=0)
    text = models.CharField(max_length=100)
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    awards = EmbeddedModelField(Award, null=True, blank=True)
    genres = ArrayField(models.CharField(max_length=100), null=True, blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    def __str__(self):
        return self.title
class Viewer(models.Model):
    name = models.CharField(max_length=100)
    email = models.CharField(max_length=200)
    class Meta:
        db_table = "users"
        managed = False
    def __str__(self):
        return self.name

O modelo Movie representa a collection sample_mflix.movies e armazena informações sobre filmes. Este modelo contém um campo de modelo embarcado chamado awards, que armazena um objeto Award. O modelo também contém um campo de array chamado genres, que armazena uma lista de gêneros que descrevem o filme.

O modelo Award não representa uma collection separada. Em vez disso, ele representa os valores do documento incorporado armazenados no modelo Movie.

O modelo Viewer representa a coleção sample_mflix.users e armazena informações de conta para visualizadores de filmes.

Criar visualizações para exibir dados

Abra o arquivo views.py no seu diretório sample_mflix e substitua seu conteúdo pelo seguinte código:

from django.http import HttpResponse
from django.shortcuts import render
from .models import Movie, Viewer
def index(request):
    return HttpResponse("Hello, world. You're at the application index.")
def recent_movies(request):
    movies = Movie.objects.order_by("-released")[:5]
    return render(request, "recent_movies.html", {"movies": movies})
def viewers_list(request):
    viewers = Viewer.objects.order_by("name")[:10]
    return render(request, "viewers_list.html", {"viewers": viewers})

Estas visualizações exibem uma mensagem da página de destino e informações sobre seus modelos Movie e Viewer.

Configurar URLs para suas visualizações

Crie um novo arquivo chamado arquivo urls.py no seu diretório sample_mflix. Para mapear as visualizações definidas na etapa anterior para URLs, cole o seguinte código em urls.py:

from django.urls import path
from . import views
urlpatterns = [
    path("recent_movies/", views.recent_movies, name="recent_movies"),
    path("viewers_list/", views.viewers_list, name="viewers_list"),
    path("", views.index, name="index"),
]

Em seguida, navegue até o arquivo quickstart/urls.py e substitua seu conteúdo pelo seguinte código:

from django.contrib import admin
from django.urls import include, path
urlpatterns = [
    path("admin/", admin.site.urls),
    path("", include("sample_mflix.urls")),
]

Criar modelos para formatar seus dados

No seu diretório sample_mflix, crie um subdiretório denominado templates. Em seguida, crie um arquivo chamado recent_movies.html e cole o seguinte código:

<!-- templates/recent_movies.html -->
<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Recent Movies</title>
</head>
<body>
   <h1>Five Most Recent Movies</h1>
   <ul>
      {% for movie in movies %}
            <li>
               <strong>{{ movie.title }}</strong> (Released: {{ movie.released }})
            </li>
      {% empty %}
            <li>No movies found.</li>
      {% endfor %}
   </ul>
</body>
</html>

Este modelo formata os dados do filme solicitados pela visualização recent_movies.

Crie outro arquivo no diretório sample_mflix/templates chamado viewers_list.html e cole o seguinte código:

<!-- templates/viewers_list.html -->
<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Viewers List</title>
</head>
<body>
   <h1>Alphabetical Viewers List</h1>
   <table>
      <thead>
            <tr>
               <th>Name</th>
               <th>Email</th>
            </tr>
      </thead>
      <tbody>
            {% for viewer in viewers %}
               <tr>
                  <td>{{ viewer.name }}</td>
                  <td>{{ viewer.email }}</td>
               </tr>
            {% empty %}
               <tr>
                  <td colspan="2">No viewer found.</td>
               </tr>
            {% endfor %}
      </tbody>
   </table>
</body>
</html>

Este modelo formata os dados de usuário solicitados pela visualização viewers_list.

Incluir sua aplicação em seu projeto

Abra o arquivo settings.py em quickstart e edite sua configuração INSTALLED_APPS para se assemelhar ao seguinte código:

INSTALLED_APPS = [
    'sample_mflix.apps.SampleMflixConfig',
    'quickstart.apps.MongoAdminConfig',
    'quickstart.apps.MongoAuthConfig',
    'quickstart.apps.MongoContentTypesConfig',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Criar migrações para seus novos modelos

A partir da raiz do projeto , execute o seguinte comando para criar migrações para os modelos Movie, Award e Viewer e aplicar as alterações no banco de dados:

python manage.py makemigrations sample_mflix
python manage.py migrate

Depois de concluir essas etapas, você tem um aplicativo básico de backend do Django MongoDB que pode ser usado para acessar o banco de dados sample_mflix do Atlas .

Voltar

Configurar sua conexão MongoDB

Gravar dados no MongoDB