Feat/get points cities

src/controllers/cidades-controller.js

@@ -1,15 +1,16 @@
 import models from '../models';
 
-const {
-    Cidade,
-} = models;
+const { Op } = require('sequelize');
 
-export const listaTodosCidades = where => Cidade.findAndCountAll({
-    attributes: {
-        exclude: ['updated_at', 'created_at'],
-    },
-    where,
-});
+const { Cidade, LocalColeta, Tombo } = models;
+
+export const listaTodosCidades = where =>
+    Cidade.findAndCountAll({
+        attributes: {
+            exclude: ['updated_at', 'created_at'],
+        },
+        where,
+    });
 
 export const listagem = (request, response, next) => {
     let where = {};
@@ -26,3 +27,110 @@ export const listagem = (request, response, next) => {
         })
         .catch(next);
 };
+
+export const ListaTodosOsTombosComLocalizacao = async (req, res, next) => {
+    try {
+        const { cidade, search } = req.query;
+        const { limite: limit, pagina: pageInt, offset } = req.paginacao;
+
+        if (!cidade && !search) {
+            const tombos = await Tombo.findAll({
+                attributes: ['hcf', 'latitude', 'longitude'],
+                include: {
+                    model: LocalColeta,
+                    include: {
+                        model: Cidade,
+                        attributes: ['nome', 'latitude', 'longitude'],
+                    },
+                },
+                order: [['hcf', 'ASC']],
+            });
+
+            const result = tombos.map(tombo => {
+                const localColeta = tombo.locais_coletum;
+                const cidadeObj = localColeta ? localColeta.cidade : null;
+
+                return {
+                    hcf: tombo.hcf,
+                    latitude: tombo.latitude,
+                    longitude: tombo.longitude,
+                    cidade: {
+                        nome: cidadeObj ? cidadeObj.nome : null,
+                        latitude: cidadeObj ? cidadeObj.latitude : null,
+                        longitude: cidadeObj ? cidadeObj.longitude : null,
+                    },
+                };
+            });
+
+            return res.status(200).json(result);
+        }
+
+        const queryOptions = {
+            attributes: ['hcf', 'latitude', 'longitude'],
+            where: {
+                latitude: null,
+                longitude: null,
+            },
+            include: {
+                model: LocalColeta,
+                required: true,
+                include: {
+                    model: Cidade,
+                    required: true,
+                    attributes: ['nome', 'latitude', 'longitude'],
+                    where: {},
+                },
+            },
+            order: [['hcf', 'ASC']],
+        };
+
+        if (req.query.pagina && req.query.limite) {
+            queryOptions.limit = limit;
+            queryOptions.offset = offset;
+        }
+
+        if (cidade) {
+            queryOptions.include.include.where.nome = cidade;
+        }
+
+        if (search) {
+            queryOptions.where.hcf = {
+                [Op.like]: `%${search}%`,
+            };
+        }
+
+        const tombos = await Tombo.findAndCountAll(queryOptions);
+
+        const result = tombos.rows.map(tombo => {
+            const localColeta = tombo.locais_coletum;
+            const cidadeObj = localColeta ? localColeta.cidade : null;
+
+            return {
+                hcf: tombo.hcf,
+                latitude: tombo.latitude,
+                longitude: tombo.longitude,
+                cidade: {
+                    nome: cidadeObj ? cidadeObj.nome : null,
+                    latitude: cidadeObj ? cidadeObj.latitude : null,
+                    longitude: cidadeObj ? cidadeObj.longitude : null,
+                },
+            };
+        });
+
+        const response = {
+            points: result,
+            totalPoints: tombos.count,
+        };
+
+        if (req.query.pagina && req.query.limite) {
+            response.totalPages = Math.ceil(tombos.count / limit);
+            response.currentPage = pageInt;
+        }
+
+        return res.status(200).json(response);
+    } catch (error) {
+        next(error);
+    }
+
+    return res.status(500).json({ message: 'Internal server error' });
+};

src/middlewares/tokens-middleware.js

@@ -9,27 +9,26 @@
     IDENTIFICADOR: 3,
 };
 
-export default (tipoUsuarioPermitido = []) => (request, response, next) => {
+export default (tipoUsuarioPermitido = []) =>
+    (request, response, next) => {
     const token = request.headers['token']; // eslint-disable-line
 
-    try {
-        if (typeof token !== 'string') {
-            throw new ForbiddenException(101);
-        }
+        try {
+            if (typeof token !== 'string') {
+                throw new ForbiddenException(101);
+            }
 
-        const usuario = decodificaTokenUsuario(token);
+            const usuario = decodificaTokenUsuario(token);
 
-        const estaPermitido = !Array.isArray(tipoUsuarioPermitido)
-            || tipoUsuarioPermitido.length < 1
-            || tipoUsuarioPermitido.includes(usuario.tipo_usuario_id);
+            const estaPermitido = !Array.isArray(tipoUsuarioPermitido) || tipoUsuarioPermitido.length < 1 || tipoUsuarioPermitido.includes(usuario.tipo_usuario_id);
 
-        if (!estaPermitido) {
-            throw new ForbiddenException(102);
-        }
+            if (!estaPermitido) {
+                throw new ForbiddenException(102);
+            }
 
-        request.usuario = usuario;
-        next();
-    } catch (err) {
-        next(err);
-    }
-};
+            request.usuario = usuario;
+            next();
+        } catch (err) {
+            next(err);
+        }
+    };

src/models/Cidade.js

@@ -27,6 +27,14 @@ export default (Sequelize, DataTypes) => {
             type: DataTypes.INTEGER,
             allowNull: true,
         },
+        latitude: {
+            type: DataTypes.DOUBLE,
+            allowNull: true,
+        },
+        longitude: {
+            type: DataTypes.DOUBLE,
+            allowNull: true,
+        },
     };
 
     const options = {

src/routes/cidades.js

@@ -1,9 +1,5 @@
 const controller = require('../controllers/cidades-controller');
 
 export default app => {
-
-    app.route('/cidades')
-        .get([
-            controller.listagem,
-        ]);
+    app.route('/cidades').get(controller.listagem);
 };

src/routes/tombos.js

@@ -1,3 +1,4 @@
+import { ListaTodosOsTombosComLocalizacao } from '../controllers/cidades-controller';
 import fichaTomboController from '../controllers/fichas-tombos-controller';
 import {
     getDadosCadTombo, getNumeroTombo, cadastro, listagem,
@@ -143,4 +144,5 @@ export default app => {
 
     // app.route('/fichas/tombos/:tombo_id')
     //     .get(fichaTomboController);
+    app.route('/pontos').get([listagensMiddleware, ListaTodosOsTombosComLocalizacao]);
 };