Curso de Node.js e MongoDB - 18

Node.js e
MongoDB
http://www.luiztools.com.br

Repositório
Api - Cinema-Catalog
Index - Cinema-Catalog
CRONOGRAMA

Repositório
● pesquisar cidades em que a rede possui
cinema;
● pesquisar cinemas por id da cidade;
● pesquisar filmes disponíveis em um cinema;
● pesquisar filmes disponíveis em uma cidade;
● pesquisar sessões disponíveis para um filme
em uma cidade;
● pesquisar sessões disponíveis para um filme
em um cinema;
Funcionalidades

Repositório
const mongodb = require("../config/mongodb");
const ObjectId = require("mongodb").ObjectId;
function getAllCities(callback){
mongodb.connect((err, db) => {
db.collection("cinemaCatalog").find({},
{cidade:1,uf:1,pais:1}).toArray(callback);
})
}
repository.js

Repositório
function getCinemasByCityId(cityId, callback){
var objCityId = ObjectId(cityId);
db.collection("cinemaCatalog").find({_id: objCityId},
{cinemas: 1}).toArray((err, cities) => {
if(err) return callback(err, null);
callback(err, cities[0].cinemas);
});
});
}
repository.js

Repositório
function disconnect(){
return mongodb.disconnect();
}
module.exports = { getAllCities, getCinemasByCityId, disconnect }
repository.js

Repositório
const test = require('tape');
const repository = require('./repository');
function runTests(){
var cityId = null;
var cinemaId = null;
var movieId = null;
//tests here
}
module.exports = { runTests }
repository.test.js

Repositório
test('Repository getAllCities', (t) => {
repository.getAllCities((err, cities) => {
if(cities && cities.length > 0) cityId = cities[1]._id;//Porto
Alegre
t.assert(!err && cities && cities.length > 0, "All Cities
Returned");
t.end();
});
})
repository.test.js

Repositório
test('Repository getCinemasByCityId', (t) => {
repository.getCinemasByCityId(cityId, (err, cinemas) => {
if(cinemas && cinemas.length > 0) cinemaId =
cinemas[0]._id;
t.assert(!err && cinemas && cinemas.length > 0, "All
Cinemas Returned By City Id");
t.end();
});
})
repository.test.js

Repositório
test('Repository Disconnect', (t) => {
t.assert(repository.disconnect(), "Disconnect Ok");
t.end();
})
}
repository.test.js

Repositório
require("dotenv-safe").load();
require("./config/mongodb.test").runTests();
require("./server/server.test").runTests();
require("./repository/repository.test").runTests();
index.test.js

Repositório
function getMoviesByCinemaId(cinemaId, callback){
var objCinemaId = ObjectId(cinemaId);
db.collection("cinemaCatalog").aggregate([
{$match: {"cinemas._id": objCinemaId}},
{$unwind: "$cinemas"},
{$unwind: "$cinemas.salas"},
{$unwind: "$cinemas.salas.sessoes"},
{$group: {_id: { filme: "$cinemas.salas.sessoes.filme",
idFilme: "$cinemas.salas.sessoes.idFilme"}}}
]).toArray(callback);
});
}
repository.js

Repositório
function getMoviesByCityId(cityId, callback){
{$match: {"_id": objCityId}},
{$group: {_id: { filme: "$cinemas.salas.sessoes.filme", idFilme:
"$cinemas.salas.sessoes.idFilme"}}}
]).toArray((err, sessions) => {
callback(err, sessions.map(item => {
return {idFilme: item._id.idFilme, filme: item._id.filme }
} )); }); });
}
repository.js

Repositório
function getMovieSessionsByCityId(movieId, cityId, callback){
var objMovieId = ObjectId(movieId);
{$match: {"_id": objCityId}},
{$match: {"cinemas.salas.sessoes.idFilme": objMovieId}},
{$group: {_id: { filme: "$cinemas.salas.sessoes.filme", idFilme:
"$cinemas.salas.sessoes.idFilme", idCinema: "$cinemas._id", sala:
"$cinemas.salas.nome", sessao: "$cinemas.salas.sessoes"}}}
return {idFilme: item._id.idFilme, filme: item._id.filme,
idCinema: item._id.idCinema, sala: item._id.sala, sessao:
item._id.sessao } } )); }); });
}
repository.js

Repositório
function getMovieSessionsByCinemaId(movieId, cinemaId, callback){
var objCinemaId = ObjectId(cinemaId);
var objMovieId = ObjectId(movieId);
{$match: {"cinemas._id": objCinemaId}},
{$match: {"cinemas.salas.sessoes.idFilme": objMovieId}},
{$group: {_id: { filme: "$cinemas.salas.sessoes.filme",
idFilme: "$cinemas.salas.sessoes.idFilme", sala:
"$cinemas.salas.nome", sessao: "$cinemas.salas.sessoes"}}}
return {idFilme: item._id.idFilme, filme:
item._id.filme, sala: item._id.sala, sessao:
item._id.sessao } } )); }); });
}
repository.js

Repositório
module.exports = {
getAllCities,
getCinemasByCityId,
getMoviesByCityId,
getMoviesByCinemaId,
getMovieSessionsByCityId,
getMovieSessionsByCinemaId, disconnect
}
repository.js

Repositório
test('Repository getMoviesByCinemaId', (t) => {
repository.getMoviesByCinemaId(cinemaId, (err, movies)
=> {
t.assert(!err && movies && movies.length > 0, "Movies By
Cinema Id Returned");
t.end();
});
})
repository.test.js

Repositório
test('Repository getMoviesByCityId', (t) => {
repository.getMoviesByCityId(cityId, (err, movies) => {
if(movies && movies.length > 0) movieId =
movies[1].idFilme;//Era de Ultron
t.assert(!err && movies && movies.length > 0,
"Movies By City Id Returned");
t.end();
});
})
repository.test.js

Repositório
test('Repository getMovieSessionsByCityId', (t) => {
repository.getMovieSessionsByCityId(movieId, cityId, (err,
sessions) => {
t.assert(!err && sessions && sessions.length > 0, "Movie
Sessions By City Id Returned");
t.end();
});
})
repository.test.js

Repositório
test('Repository getMovieSessionsByCinemaId', (t) => {
repository.getMovieSessionsByCinemaId(movieId,
cinemaId, (err, sessions) => {
t.assert(!err && sessions && sessions.length > 0, "Movie
Sessions By Cinema Id Returned");
t.end();
});
})
repository.test.js

API - Cinema Catalog
GET /cities
lista todas cidades onde a rede possui cinema
GET /cities/:city/movies
lista todos os filmes em exibição na cidade especificada;
GET /cities/:city/movies/:movie
lista todos as sessões do filme escolhido na cidade
especificada;
GET /cities/:city/cinemas
lista todos os cinemas em determinada cidade;
GET /cinemas/:cinema/movies
lista todos os filmes em exibição no cinema especificado;
GET /cinemas/:cinema/movies/:movie
lista todas as sessões do filme escolhido no cinema
especificado;
Estrutura

module.exports = (app, repository) => {
app.get('/cities', (req, res, next) => {
repository.getAllCities((err, cities) => {
if(err) return next(err);
res.json(cities);
});
})
//another routes here
}
cinema-catalog.js

app.get('/cities/:city/movies', (req, res, next) => {
repository.getMoviesByCityId(req.params.city, (err, movies)
=> {
res.json(movies)
});
})
cinema-catalog.js

app.get('/cities/:city/movies/:movie', (req, res, next) => {
repository.getMovieSessionsByCityId(req.params.movie,
req.params.city, (err, sessions) => {
res.json(sessions)
});
})
cinema-catalog.js

app.get('/cities/:city/cinemas', (req, res, next) => {
repository.getCinemasByCityId(req.params.city, (err,
cinemas) => {
res.json(cinemas)
});
})
cinema-catalog.js

app.get('/cinemas/:cinema/movies', (req, res, next) => {
repository.getMoviesByCinemaId(req.params.cinema, (err,
movies) => {
res.json(movies)
});
})
cinema-catalog.js

app.get('/cinemas/:cinema/movies/:movie', (req, res, next) => {
repository.getMovieSessionsByCinemaId(req.params.movie
, req.params.cinema, (err, sessions) => {
res.json(sessions)
});
})
cinema-catalog.js

const test = require('tape');
const supertest = require('supertest');
const movies = require('./cinema-catalog');
const server = require("../server/server");
const repository = require("../repository/repository");
function runTests(){
//run tests here
}
module.exports = { runTests }
cinema-catalog.test.js

var app = null;
server.start(movies, repository, (err, app) => {
var cityId = null;
var movieId = null;
var cinemaId = null;
//test cases
})
repository.disconnect();
server.stop();

test('GET /cities', (t) => {
supertest(app) .get('/cities')
.expect('Content-Type', /json/)
.expect(200)
.end((err, res) =>{
if(res.body && res.body.length > 0)
cityId = res.body[1]._id;
t.error(err, 'No errors')
t.assert(res.body && res.body.length > 0, "All
Cities returned")
t.end()
})
})

test('GET /cities/:city/movies', (t) => {
supertest(app)
.get('/cities/' + cityId + "/movies")
.expect(200)
.end((err, res) =>{
movieId = res.body[0].idFilme;
t.assert(res.body, "Movies By City Id returned")
t.end()
})
})

test('GET /cities/:city/movies/:movie', (t) => {
supertest(app)
.get('/cities/' + cityId + '/movies/' + movieId)
.expect(200)
.end((err, res) =>{
cinemaId = res.body[0].idCinema;
t.assert(res.body && res.body.length > 0, "Movie
Sessions by City Id returned")
t.end()
})
})

test('GET /cities/:city/cinemas', (t) => {
supertest(app)
.get('/cities/' + cityId + '/cinemas')
.expect(200)
.end((err, res) =>{
t.assert(res.body, "Cinemas By City Id
returned")
t.end()
})
})

test('GET /cinemas/:cinema/movies', (t) => {
supertest(app)
.get('/cinemas/' + cinemaId + "/movies")
.expect(200)
.end((err, res) =>{
t.assert(res.body, "Movies By Cinema Id
returned")
t.end()
})
})

test('GET /cinemas/:cinema/movies/:movie', (t) => {
supertest(app)
.get('/cinemas/' + cinemaId + "/movies/" + movieId)
.expect(200)
.end((err, res) =>{
t.assert(res.body, "Movie Sessions By Cinema Id
returned")
t.end()
})
})

require("./config/mongodb.test").runTests();
require("./server/server.test").runTests();
require("./repository/repository.test").runTests();
require("./api/cinema-catalog.test").runTests();
index.test.js

Index - Cinema Catalog
const cinemaCatalog = require('./api/cinema-catalog');
const server = require("./server/server");
const repository = require("./repository/repository");
server.start(cinemaCatalog, repository, (err, app) => {
console.log("just started");
});
index.js

1 Adicione outra função no microservice
2 Aplique validação de entrada de dados
3 Adicione o restante do CRUD ao microservice

Curso de Node.js e MongoDB - 18

Mais conteúdo relacionado

Mais de Luiz Duarte (20)

Último (7)

Curso de Node.js e MongoDB - 18