initial commit

backend/controllers/citaController.js

@@ -0,0 +1,57 @@
+'use strict'
+var Cita = require('../models/cita.js');
+
+function list_citas(req, res) {
+    Cita.find({}, (err, citas) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get citas!' });
+        }
+        res.status(200).send({ citas });
+    }).populate({
+        path: 'disponibilidad',
+        populate: {
+            path: 'especialista',
+            populate: {
+                path: 'especialidad'
+            }
+        }
+    });
+}
+
+function new_cita(req, res) {
+    try {
+        let cita = new Cita();
+        cita.rut = req.body.rut;
+        cita.disponibilidad = req.body.disponibilidad;
+        cita.save((err, citaSave) => {
+            if (err) {
+                return res.status(400).send({ message: `Error: Could not save cita to database!> ${err}` });
+            }
+            res.status(200).send({ cita: citaSave });
+        });
+    } 
+    catch (error) {
+        res.status(500).send({ message: `error: ` + error });
+    }
+}
+
+function delete_cita(req, res) {
+    let id = { '_id': req.params.id };
+    Cita.deleteOne(id, (err, cita) => {
+        if (err) {
+            return res.status(400).send({ message: `Error: Could not delete cita from database!> ${err}` });
+        }
+        if (cita.deletedCount == 1) {
+            res.status(200).send({ message: `Cita deleted!` });
+        }
+        else {
+            res.status(400).send({ message: `Error: Cita could not be deleted!` });
+        }
+    });
+}
+
+module.exports = {
+    list_citas,
+    new_cita,
+    delete_cita
+};

backend/controllers/disponibilidadController.js

@@ -0,0 +1,140 @@
+'use strict'
+var Disponibilidad = require('../models/disponibilidad.js');
+
+function list_disponibilidades(req, res) {
+    Disponibilidad.find({}, (err, disponibilidades) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get disponibilidades!' });
+        }
+        res.status(200).send({ disponibilidades });
+    }).populate({
+        path: 'especialista',
+        populate: {
+            path: 'especialidad'
+        }
+    });
+}
+
+function list_disponibilidades_especialista(req, res) {
+    let especialista = { 'especialista': req.params.id };
+    Disponibilidad.find(especialista, (err, disponibilidades) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get disponibilidades!' });
+        }
+        res.status(200).send({ disponibilidades });
+    }).populate({
+        path: 'especialista',
+        populate: {
+            path: 'especialidad'
+        }
+    }).sort(
+        {
+            fecha: 1,
+            horario: 1
+        }
+    );
+}
+
+function show_disponibilidad(req, res) {
+    let id = { '_id': req.params.id };
+    Disponibilidad.findOne(id, (err, disponibilidad) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get disponibilidad!' });
+        }
+        res.status(200).send({ disponibilidad });
+    }).populate({
+        path: 'especialista',
+        populate: {
+            path: 'especialidad'
+        }
+    });
+}
+
+function new_disponibilidad(req, res) {
+    try {
+        if (req.body.hasOwnProperty('disponibilidades')) {
+            for (let i = 0; i < req.body.disponibilidades.length; i++) {
+                let disponibilidad = new Disponibilidad();
+                disponibilidad.especialista = req.body.disponibilidades[i].especialista;
+                disponibilidad.fecha = req.body.disponibilidades[i].fecha;
+                disponibilidad.horario = req.body.disponibilidades[i].horario;
+                disponibilidad.save((err) => {
+                    if (err) {
+                        return res.status(400).send({ message: `Error: Could not save disponibilidades to database!> ${err}` });
+                    }
+                });
+            }
+            res.status(200).send({ message: 'Disponibilidades saved!' });
+        }
+        else{
+            let disponibilidad = new Disponibilidad();
+            disponibilidad.especialista = req.body.especialista;
+            disponibilidad.horario = req.body.horario;
+            disponibilidad.save((err, disponibilidadSave) => {
+                if (err) {
+                    return res.status(400).send({ message: `Error: Could not save disponibilidad to database!> ${err}` });
+                }
+                res.status(200).send({ disponibilidad: disponibilidadSave });
+            });
+        }
+    } 
+    catch (error) {
+        res.status(500).send({ message: `error: ` + error });
+    }
+}
+
+function modify_disponibilidad(req, res) {
+    let disponibilidad = new Disponibilidad();
+    disponibilidad._id = req.params.id;
+    disponibilidad.disponible = req.body.disponible;
+    Disponibilidad.updateOne({ '_id': req.params.id }, disponibilidad, (err, disponibilidad) => {
+        if (err) {
+            return res.status(400).send({ message: `Error: Could not save disponibilidad to database!> ${err}` });
+        }
+        if (disponibilidad.nModified == 1) {
+            res.status(200).send({ message: `Disponibilidad modified!` });
+        }
+        else {
+            res.status(400).send({ message: `Error: Disponibilidad could not be modified!` });
+        }
+    });
+}
+
+function delete_disponibilidad(req, res) {
+    let id = { '_id': req.params.id };
+    Disponibilidad.deleteOne(id, (err, disponibilidad) => {
+        if (err) {
+            return res.status(400).send({ message: `Error: Could not delete disponibilidad from database!> ${err}` });
+        }
+        if (disponibilidad.deletedCount == 1) {
+            res.status(200).send({ message: `Disponibilidad deleted!` });
+        }
+        else {
+            res.status(400).send({ message: `Error: Disponibilidad could not be deleted!` });
+        }
+    });
+}
+
+function delete_disponibilidades(req, res) {
+    Disponibilidad.deleteMany({}, (err, disponibilidad) => {
+        if (err) {
+            return res.status(400).send({ message: `Error: Could not delete disponibilidades from database!> ${err}` });
+        }
+        if (disponibilidad.deletedCount >= 1) {
+            res.status(200).send({ message: `Disponibilidades deleted!` });
+        }
+        else {
+            res.status(400).send({ message: `Error: Disponibilidades could not be deleted!` });
+        }
+    });
+}
+
+module.exports = {
+    list_disponibilidades,
+    list_disponibilidades_especialista,
+    show_disponibilidad,
+    new_disponibilidad,
+    modify_disponibilidad,
+    delete_disponibilidad,
+    delete_disponibilidades
+};

backend/controllers/especialidadController.js

@@ -0,0 +1,59 @@
+'use strict'
+var Especialidad = require('../models/especialidad.js');
+
+function list_especialidades(req, res) {
+    Especialidad.find({}, (err, especialidades) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get especialidades!' });
+        }
+        res.status(200).send({ especialidades });
+    });
+}
+
+function show_especialidad(req, res) {
+    let id = { '_id': req.params.id };
+    Especialidad.findOne(id, (err, especialidad) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get especialidad!' });
+        }
+        res.status(200).send({ especialidad });
+    });
+}
+
+function new_especialidad(req, res) {
+    try {
+        let especialidad = new Especialidad();
+        especialidad.descripcion = req.body.descripcion;
+        especialidad.save((err, especialidadSave) => {
+            if (err) {
+                return res.status(400).send({ message: `Error: Could not save especialidad to database!> ${err}` });
+            }
+            res.status(200).send({ especialidad: especialidadSave });
+        });
+    } 
+    catch (error) {
+        res.status(500).send({ message: `error: ` + error });
+    }
+}
+
+function delete_especialidad(req, res) {
+    let id = { '_id': req.params.id };
+    Especialidad.deleteOne(id, (err, especialidad) => {
+        if (err) {
+            return res.status(400).send({ message: `Error: Could not delete especialidad from database!> ${err}` });
+        }
+        if (especialidad.deletedCount == 1) {
+            res.status(200).send({ message: `Especialidad deleted!` });
+        }
+        else {
+            res.status(400).send({ message: `Error: Especialidad could not be deleted!` });
+        }
+    });
+}
+
+module.exports = {
+    list_especialidades,
+    show_especialidad,
+    new_especialidad,
+    delete_especialidad
+};

backend/controllers/especialistaController.js

@@ -0,0 +1,71 @@
+'use strict'
+var Especialista = require('../models/especialista.js');
+
+function list_especialistas(req, res) {
+    Especialista.find({}, (err, especialistas) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get especialistas!' });
+        }
+        res.status(200).send({ especialistas });
+    }).populate('especialidad');
+}
+
+function list_especialistas_especialidad(req, res) {
+    let especialidad = { 'especialidad': req.params.id };
+    Especialista.find(especialidad, (err, especialistas) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get especialistas!' });
+        }
+        res.status(200).send({ especialistas });
+    }).populate('especialidad');
+}
+
+function show_especialista(req, res) {
+    let id = { '_id': req.params.id };
+    Especialista.findOne(id, (err, especialista) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get especialista!' });
+        }
+        res.status(200).send({ especialista });
+    }).populate('especialidad');
+}
+
+function new_especialista(req, res) {
+    try {
+        let especialista = new Especialista();
+        especialista.nombre = req.body.nombre;
+        especialista.especialidad = req.body.especialidad;
+        especialista.save((err, especialistaSave) => {
+            if (err) {
+                return res.status(400).send({ message: `Error: Could not save especialista to database!> ${err}` });
+            }
+            res.status(200).send({ especialista: especialistaSave });
+        });
+    } 
+    catch (error) {
+        res.status(500).send({ message: `error: ` + error });
+    }
+}
+
+function delete_especialista(req, res) {
+    let id = { '_id': req.params.id };
+    Especialista.deleteOne(id, (err, especialista) => {
+        if (err) {
+            return res.status(400).send({ message: `Error: Could not delete especialista from database!> ${err}` });
+        }
+        if (especialista.deletedCount == 1) {
+            res.status(200).send({ message: `Especialista deleted!` });
+        }
+        else {
+            res.status(400).send({ message: `Error: Especialista could not be deleted!` });
+        }
+    });
+}
+
+module.exports = {
+    list_especialistas,
+    list_especialistas_especialidad,
+    show_especialista,
+    new_especialista,
+    delete_especialista
+};

backend/controllers/usuarioController.js

@@ -0,0 +1,126 @@
+'use strict'
+var Usuario = require('../models/usuario.js');
+const bcrypt = require('bcrypt-nodejs');
+const service = require('../services/index')
+
+function list_usuarios(req, res) {
+    Usuario.find({}, (err, usuario) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get usuarios!' });
+        }
+        res.status(200).send({ usuario });
+    });
+}
+
+function show_usuario(req, res) {
+    let usuario_to_find = { 'mail': req.params.mail };
+    Usuario.find(usuario_to_find, (err, usuario) => {
+        if (err) {
+            return res.status(500).send({ message: 'Error: Could not get usuario!' });
+        }
+        res.status(200).send({ usuario });
+    });
+}
+
+function new_usuario(req, res) {
+    try {
+        let usuario = new Usuario();
+        usuario.nombre = req.body.nombre;
+        usuario.mail = req.body.mail;
+        usuario.pass = req.body.pass;
+        usuario.activo = req.body.activo;
+        usuario.save((err, usuarioSave) => {
+            if (err) {
+                return res.status(400).send({ message: `Error: Could not save usuario to database!> ${err}` });
+            }
+            res.status(200).send({ usuario: usuarioSave });
+        });
+    } 
+    catch (error) {
+        res.status(500).send({ message: `error: ` + error });
+    }
+}
+
+function modify_usuario(req, res) {
+    let usuario = new Usuario();
+    usuario._id = req.params.id;
+    usuario.activo = req.body.activo;
+    Usuario.updateOne({ '_id': usuario._id }, usuario, (err, updatedUsuario) => {
+        if (err) {
+            return res.status(400).send({ message: `Error: Could not save usuario to database!> ${err}` });
+        }
+        if (updatedUsuario.nModified == 1) {
+            res.status(200).send({ message: `Usuario modified!` });
+        }
+        else {
+            res.status(400).send({ message: `Error: Usuario could not be modified!` });
+        }
+    });
+}
+
+function delete_usuario(req, res) {
+    let id = { '_id': req.params.id };
+    Usuario.deleteOne(id, (err, usuario) => {
+        if (err) {
+            return res.status(400).send({ message: `Error: Could not delete usuario from database!> ${err}` });
+        }
+        if (usuario.deletedCount == 1) {
+            res.status(200).send({ message: `Usuario deleted!` });
+        }
+        else {
+            res.status(400).send({ message: `Error: Usuario could not be deleted!` });
+        }
+    });
+}
+
+function validar_usuario(req, res) {
+    var password = req.body.pass;
+    Usuario.findOne({'mail': req.body.mail}, (err, user) => {
+        if (err) {
+            return res.status(500).send({ mensaje: 'error al realizar la peticion' });
+        }
+        if (!user) {
+            return res.status(401).send({ mensaje: 'Error: usuario no existe' });
+        }
+
+        if (!user.activo) {
+            return res.status(401).send({ 'mensaje': 'usuario no está activo'});
+        }
+
+        bcrypt.compare(password, user.pass, function(error, isMatch) {
+            if (error) {
+                res.status(500).send(`Error al validar usuario> ${error}`);
+            }
+            else if (!isMatch) {
+                res.status(401).send({ 'mensaje': 'incorrecto'});
+            }
+            else {
+                res.status(200).send({ 'mensaje': 'correcto', 'token': service.createToken(user)});
+            }
+        });
+    });
+}
+
+const validar_vigencia = (req, res) =>{
+    Usuario.findById(req.usuario, function (err, usuario) {
+        if (err) {
+            return res.status(401).send({'mensaje': 'usuario no autorizado'});
+        }
+
+        if (!usuario.activo) {
+            return res.status(401).send({'mensaje': 'usuario no es activo'});
+        }
+
+        return res.status(200).send({'usuario': usuario.mail});
+    });
+}
+
+module.exports = {
+    list_usuarios,
+    show_usuario,
+    new_usuario,
+    modify_usuario,
+    delete_usuario,
+    validar_usuario,
+    validar_vigencia
+};

backend/index.js

@@ -0,0 +1,50 @@
+'use strict'
+require('dotenv').config();
+const express = require('express');
+const bodyParser = require('body-parser');
+const app = express();
+
+var cors = require('cors');
+app.use(cors());
+app.options('*', cors());
+
+var usuario_route = require('./routes/usuarioRoute');
+var especialidad_route = require('./routes/especialidadRoute');
+var especialista_route = require('./routes/especialistaRoute');
+var disponibilidad_route = require('./routes/disponibilidadRoute');
+var cita_route = require('./routes/citaRoute');
+
+const mongoose = require('mongoose');
+
+app.use(bodyParser.urlencoded({ extended: false }));
+app.use(bodyParser.json());
+
+app.use('/api', usuario_route);
+app.use('/api', especialidad_route);
+app.use('/api', especialista_route);
+app.use('/api', disponibilidad_route);
+app.use('/api', cita_route);
+
+const options = {
+    useNewUrlParser: true,
+    useCreateIndex: true,
+    autoIndex: true,
+    keepAlive: true,
+    poolSize: 10,
+    bufferMaxEntries: 0,
+    connectTimeoutMS: 10000,
+    socketTimeoutMS: 45000,
+    family: 4,
+    useFindAndModify: false,
+    useUnifiedTopology: true
+}
+
+mongoose.connect(`mongodb://192.99.144.232:27017/grupo12?security=false`, options)
+    .then(() => console.log('> Successfully connected to DB'))
+    .catch(err => console.log(err));
+
+app.listen(5000, () => {
+    console.log('> Service running on port 5000');
+})
+
+module.exports = app;

backend/middlewares/auth.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const jwt = require('jwt-simple');
+const moment = require('moment');
+require('dotenv').config();
+
+function isAuth(req, res, next) {
+    if (!req.headers.authorization) {
+        return res.status(403).send({ message: 'No tienes autorización' });
+    }
+
+    const token = req.headers.authorization.split(" ")[1]
+
+    try {
+        const payload = jwt.decode(token, process.env.SECRET_TOKEN);
+
+        if (payload.exp < moment().unix()) {
+            return res.status(401).send({ message: 'El token ha expirado' });
+        }
+
+        req.usuario = payload.sub
+    }
+    catch (err) {
+        return res.status(401).send({ message: 'El token no es valido' });
+    }
+
+    next();
+}
+
+module.exports = {
+    isAuth
+};

backend/models/cita.js

@@ -0,0 +1,19 @@
+'use strict'
+const mongoose = require('mongoose');
+const CitaSchema = mongoose.Schema({
+    rut: {
+        type: String,
+        required: true
+    },
+    // La especialista viene de la disponibilidad, es redundante aquí.
+    /*especialista: {
+        type: mongoose.Schema.ObjectId, ref: "especialista",
+        required: true
+    },*/
+    disponibilidad: {
+        type: mongoose.Schema.ObjectId, ref: "disponibilidad",
+        required:  true
+    }
+});
+
+module.exports = mongoose.model('cita', CitaSchema);

backend/models/disponibilidad.js

@@ -0,0 +1,23 @@
+'use strict'
+const mongoose = require('mongoose');
+const DisponibilidadSchema = mongoose.Schema({
+    especialista: {
+        type: mongoose.Schema.ObjectId, ref: "especialista",
+        required: true
+    },
+    fecha: {
+        type: Date,
+        required: true
+    },
+    horario: {
+        type: String,
+        required: true
+    },
+    disponible: {
+        type: Boolean,
+        default: true,
+        required: true
+    }
+});
+
+module.exports = mongoose.model('disponibilidad', DisponibilidadSchema);

backend/models/especialidad.js

@@ -0,0 +1,10 @@
+'use strict'
+const mongoose = require('mongoose');
+const EspecialidadSchema = mongoose.Schema({
+    descripcion: {
+        type: String,
+        required: true
+    }
+});
+
+module.exports = mongoose.model('especialidad', EspecialidadSchema);

backend/models/especialista.js

@@ -0,0 +1,14 @@
+'use strict'
+const mongoose = require('mongoose');
+const EspecialistaSchema = mongoose.Schema({
+    nombre: {
+        type: String,
+        required: true
+    },
+    especialidad: { 
+        type: mongoose.Schema.ObjectId, ref: "especialidad",
+        required: true
+    }
+});
+
+module.exports = mongoose.model('especialista', EspecialistaSchema);

backend/models/usuario.js

@@ -0,0 +1,46 @@
+'use strict'
+const bcrypt = require('bcrypt-nodejs');
+const mongoose = require('mongoose');
+const UsuarioSchema = mongoose.Schema({
+    nombre: {
+        type: String,
+        required: true
+    },
+    mail: {
+        type: String,
+        required: true
+    },
+    pass: {
+        type: String,
+        required: true
+    },
+    activo: {
+        type: Boolean
+    }
+});
+
+UsuarioSchema.pre('save', function(next) {
+    const usuario = this;
+    if (!usuario.isModified('pass')) {
+        return next();
+    }
+
+    if (!usuario.hasOwnProperty('activo')) {
+        usuario.activo = true;
+    }
+
+    bcrypt.genSalt(10, (err, salt) => {
+        if (err) {
+            next(err);
+        }
+        bcrypt.hash(usuario.pass, salt, null, (err, hash) => {
+            if (err) {
+                next(err);
+            }
+            usuario.pass = hash;
+            next();
+        });
+    });
+});
+
+module.exports = mongoose.model('usuario', UsuarioSchema);

backend/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "backend",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "nodemon index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "bcrypt-nodejs": "0.0.3",
+    "body-parser": "^1.19.1",
+    "cors": "^2.8.5",
+    "dotenv": "^10.0.0",
+    "express": "^4.17.1",
+    "jwt-simple": "^0.5.6",
+    "moment": "^2.29.1",
+    "mongoose": "5.9.24"
+  },
+  "devDependencies": {
+    "nodemon": "^2.0.15"
+  }
+}

backend/routes/citaRoute.js

@@ -0,0 +1,13 @@
+'use strict'
+var express = require('express');
+
+var citaController = require('../controllers/citaController');
+const auth = require('../middlewares/auth');
+
+var api = express.Router();
+
+api.get('/cita', citaController.list_citas);
+api.post('/cita', citaController.new_cita);
+api.delete('/cita/:id', auth.isAuth, citaController.delete_cita);
+
+module.exports = api;

backend/routes/disponibilidadRoute.js

@@ -0,0 +1,17 @@
+'use strict'
+var express = require('express');
+
+var disponibilidadController = require('../controllers/disponibilidadController');
+const auth = require('../middlewares/auth');
+
+var api = express.Router();
+
+api.get('/disponibilidad', disponibilidadController.list_disponibilidades);
+api.get('/disponibilidad/especialista/:id', disponibilidadController.list_disponibilidades_especialista);
+api.get('/disponibilidad/:id', disponibilidadController.show_disponibilidad);
+api.post('/disponibilidad', auth.isAuth, disponibilidadController.new_disponibilidad);
+api.put('/disponibilidad/:id', disponibilidadController.modify_disponibilidad);
+api.delete('/disponibilidad/:id', auth.isAuth, disponibilidadController.delete_disponibilidad);
+api.delete('/disponibilidad', auth.isAuth, disponibilidadController.delete_disponibilidades);
+
+module.exports = api;

backend/routes/especialidadRoute.js

@@ -0,0 +1,14 @@
+'use strict'
+var express = require('express');
+
+var especialidadController = require('../controllers/especialidadController');
+const auth = require('../middlewares/auth');
+
+var api = express.Router();
+
+api.get('/especialidad', especialidadController.list_especialidades);
+api.get('/especialidad/:id', especialidadController.show_especialidad);
+api.post('/especialidad', auth.isAuth, especialidadController.new_especialidad);
+api.delete('/especialidad/:id', auth.isAuth, especialidadController.delete_especialidad);
+
+module.exports = api;

backend/routes/especialistaRoute.js

@@ -0,0 +1,15 @@
+'use strict'
+var express = require('express');
+
+var especialistaController = require('../controllers/especialistaController');
+const auth = require('../middlewares/auth');
+
+var api = express.Router();
+
+api.get('/especialista', especialistaController.list_especialistas);
+api.get('/especialista/especialidad/:id', especialistaController.list_especialistas_especialidad);
+api.get('/especialista/:id', especialistaController.show_especialista);
+api.post('/especialista', auth.isAuth, especialistaController.new_especialista);
+api.delete('/especialista/:id', auth.isAuth, especialistaController.delete_especialista);
+
+module.exports = api;

backend/routes/usuarioRoute.js

@@ -0,0 +1,16 @@
+'use strict'
+var express = require('express');
+
+var usuarioController = require('../controllers/usuarioController');
+const auth = require('../middlewares/auth');
+
+var api = express.Router();
+
+api.get('/usuario', auth.isAuth, usuarioController.list_usuarios);
+api.post('/usuario', auth.isAuth, usuarioController.new_usuario);
+api.put('/usuario/:id', auth.isAuth, usuarioController.modify_usuario);
+api.delete('/usuario/:id', auth.isAuth, usuarioController.delete_usuario);
+api.post('/usuario/validar', usuarioController.validar_usuario);
+api.post('/usuario/vigencia', auth.isAuth, usuarioController.validar_vigencia);
+
+module.exports = api;

backend/services/index.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const jwt = require('jwt-simple');
+const moment = require('moment');
+require('dotenv').config();
+
+function createToken(user) {
+    const payload ={
+        sub: user._id,
+        iat: moment().unix(),
+        exp: moment().add(1, 'days').unix(), 
+    };
+
+    return jwt.encode(payload, process.env.SECRET_TOKEN);
+}
+
+module.exports = {
+    createToken
+};