Inicio de proyecto

.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+
+.env

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true
+}

package.json

@@ -0,0 +1,35 @@
+{
+  "name": "api",
+  "version": "1.0.0",
+  "description": "Esta es la plantilla para una api",
+  "main": "index.js",
+  "scripts": {
+    "test": "node ./server/config/test",
+    "db:install": "node ./server/db/install",
+    "db:data-fake": "node ./server/db/data-fake",
+    "dev": "nodemon ./server/app",
+    "start": "node ./server/app"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "bcrypt": "^5.0.1",
+    "body-parser": "^1.19.0",
+    "colors": "^1.4.0",
+    "cors": "^2.8.5",
+    "dotenv": "^8.2.0",
+    "express": "^4.17.1",
+    "jsonwebtoken": "^8.5.1",
+    "mariadb": "^2.5.3",
+    "moment": "^2.29.1",
+    "sequelize": "^6.6.2",
+    "validator": "^13.6.0"
+  },
+  "devDependencies": {
+    "nodemon": "^2.0.7"
+  }
+}

server/app.js

@@ -0,0 +1,26 @@
+require('./config/config');
+const colors = require('colors');
+const bodyParser = require('body-parser');
+const cors = require('cors');
+const express = require('express');
+const app = express();
+
+app.use(cors());
+
+app.use(
+  bodyParser.urlencoded({
+    extended: false,
+  })
+);
+
+app.use(bodyParser.json());
+
+app.get('/', (req, res) => res.send('API Plantilla'));
+
+app.use(require('./routes/index'));
+
+app.listen(Number(process.env.PORT), () =>
+  console.log(
+    `API Plantilla corriendo en el puerto: ${process.env.PORT}`.rainbow
+  )
+);

server/config/config.js

@@ -0,0 +1,11 @@
+const dotenv = require('dotenv');
+const colors = require('colors');
+let result = {};
+
+try {
+  result = dotenv.config();
+  if (result.error) throw result.error;
+  console.log('El archivo .env se cargado correctamente.'.underline.bold.cyan);
+} catch (err) {
+  console.log('El archivo .env no se cargo.'.underline.bold.red);
+}

server/config/sequelize.conf.js

@@ -0,0 +1,19 @@
+require('./config');
+const { Sequelize } = require('sequelize');
+
+const sequelize = new Sequelize(
+  process.env.DB,
+  process.env.USERDB,
+  process.env.PASSWORDDB,
+  {
+    host: process.env.HOSTDB,
+    dialect: process.env.TYPEDB,
+    logging: false,
+    dialectOptions: {
+      useUTC: false,
+    },
+    timezone: '-05:00',
+  }
+);
+
+module.exports = sequelize;

server/config/test.js

@@ -0,0 +1,13 @@
+const sequelize = require('./sequelize.conf');
+require('colors');
+
+sequelize
+  .authenticate()
+  .then(() => {
+    console.log('Se ha conectado a la base de datos exitosamente.'.green);
+    process.exit();
+  })
+  .catch((err) => {
+    console.error('Hubo un error al conectarse a la base de datos: '.red, err);
+    process.exit();
+  });

server/db/data-fake.js

@@ -0,0 +1,32 @@
+const Usuario = require('./tablas/Usuario');
+const { encriptar } = require('../helper/encriptar');
+
+const dataUsuarios = async () => {
+  let usuario = ['416313221', '111111111', '222222222'];
+  let nombre = [
+    'Adriana De Luna Ramirez',
+    'Nombre Falso 1',
+    'Nombre Falso 2',
+  ];
+
+  for (let i = 0; i < usuario.length; i++) {
+    await Usuario.create({
+      usuario: usuario[i],
+      nombre: nombre[i],
+      password: encriptar('holi'),
+      idTipoUsuario: 2,
+    });
+    console.log(`Se insertó el usuario ${usuario[i]}.`.magenta);
+  }
+};
+
+const exec = async () => {
+  await dataUsuarios();
+  console.log(
+    '\nSe ha instalado exitosamente la información falsa en la base de datos.\n'
+      .underline.bold.green
+  );
+  process.exit();
+};
+
+exec();

server/db/install.js

@@ -0,0 +1,46 @@
+require('../config/config');
+const colors = require('colors');
+// const encriptar = require('../helper/encriptar');
+const TipoUsuario = require('./tablas/TipoUsuario');
+const Usuario = require('./tablas/Usuario');
+
+const drop = async () => {
+  console.log('\nPaso 1) Desinstalando la db.'.bold.blue);
+
+  await Usuario.drop();
+  console.log('La tabla Usuario se desinstalo correctamente.'.magenta);
+
+  await TipoUsuario.drop();
+  console.log('La tabla TipoUsuario se desinstalo correctamente.'.magenta);
+};
+
+const sync = async () => {
+  console.log('\nPaso 2) Instalando la db.'.bold.blue);
+
+  await TipoUsuario.sync();
+  console.log('La tabla TipoUsuario se instalo correctamente.'.magenta);
+
+  await Usuario.sync();
+  console.log('La tabla Usuario se instalo correctamente.'.magenta);
+};
+
+const dataTipoUsuario = async () => {
+  const data = ['admin', 'alumno', 'profesor'];
+
+  console.log('\nPaso 3) Instalando catalogo tipo usuario.'.bold.blue);
+  for (let i = 0; i < data.length; i++)
+    await TipoUsuario.create({ tipoUsuario: data[i] });
+};
+
+const exe = async () => {
+  await drop();
+  await sync();
+  await dataTipoUsuario;
+  console.log(
+    '\nSe ha instalado exitosamente la base de datos.\n'.underline.bold.green
+  );
+
+  process.exit();
+};
+
+exe();

server/db/tablas/TipoUsuario.js

@@ -0,0 +1,27 @@
+const { DataTypes, Model } = require('sequelize');
+const sequelize = require('../../config/sequelize.conf');
+
+class TipoUsuario extends Model {}
+TipoUsuario.init(
+  {
+    idTipoUsuario: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+      allowNull: false,
+      unique: true,
+      autoIncrement: true,
+    },
+    tipoUsuario: {
+      type: DataTypes.STRING(15),
+      allowNull: false,
+    },
+  },
+  {
+    sequelize,
+    modelName: 'TipoUsuario',
+    tableName: 'tipo_usuario',
+    timestamps: false,
+  }
+);
+
+module.exports = TipoUsuario;

server/db/tablas/Usuario.js

@@ -0,0 +1,51 @@
+const { DataTypes, Model } = require('sequelize');
+const sequelize = require('../../config/sequelize.conf');
+const TipoUsuario = require('./TipoUsuario');
+
+class Usuario extends Model {}
+Usuario.init(
+  {
+    idUsuario: {
+      type: DataTypes.INTEGER,
+      primaryKey: true,
+      allowNull: false,
+      unique: true,
+      autoIncrement: true,
+    },
+    usuario: {
+      type: DataTypes.STRING(100),
+      allowNull: false,
+      unique: true,
+    },
+    password: {
+      type: DataTypes.STRING(60),
+      allowNull: true,
+      defaultValue: null,
+    },
+    nombre: {
+      type: DataTypes.STRING(70),
+      allowNull: true,
+      defaultValue: null,
+    },
+    activo: {
+      type: DataTypes.BOOLEAN,
+      allowNull: false,
+    },
+  },
+  {
+    sequelize,
+    modelName: 'Usuario',
+    tableName: 'usuario',
+    timestamps: false,
+  }
+);
+
+Usuario.belongsTo(TipoUsuario, {
+  foreignKey: {
+    name: 'idTipoUsuario',
+    type: DataTypes.INTEGER,
+    allowNull: false,
+  },
+});
+
+module.exports = Usuario;

server/helper/encriptar.js

@@ -0,0 +1,23 @@
+const bcrypt = require('bcrypt');
+require('../config/config');
+
+const comparar = (password, dbPassword) => {
+  if (!bcrypt.compareSync(password, dbPassword)) return false;
+  return true;
+};
+
+const encriptar = (password) =>
+  bcrypt.hashSync(password, Number(process.env.SALT_ROUNDS));
+
+const generarPassword = () => {
+  const length = 8;
+  const charset =
+    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+  let password = '';
+
+  for (let i = 0, n = charset.length; i < length; ++i)
+    password += charset.charAt(Math.floor(Math.random() * n));
+  return password;
+};
+
+module.exports = { comparar, encriptar, generarPassword };

server/helper/gmail.js

@@ -0,0 +1,18 @@
+require('../config/config');
+
+const send = require('gmail-send')({
+  user: process.env.GMAIL,
+  pass: process.env.GMAILPASSWORD,
+});
+
+const gmail = (subject, to, text) => {
+  return new Promise((resolve, reject) => {
+    send({ subject, to, text }, (error, result, fullResult) => {
+      if (error) reject(error);
+      console.log(fullResult);
+      resolve(result);
+    });
+  });
+};
+
+module.exports = gmail;

server/helper/helper.js

@@ -0,0 +1,37 @@
+const fs = require('fs');
+const moment = require('moment');
+
+const crearDDMMAAAA = (date) => {
+  const fechaMoment = moment(date);
+  let ddmmaaaa = '';
+
+  if (fechaMoment.isValid())
+    ddmmaaaa = `${fechaMoment.date()}/${
+      fechaMoment.month() + 1
+    }/${fechaMoment.year()}`;
+  return ddmmaaaa;
+};
+
+const eliminarArchivo = (path) => {
+  return new Promise((resolve, reject) => {
+    fs.unlink(path, (err) => {
+      if (err) reject(err);
+      resolve({ message: 'Se elimino el archivo correctamente.' });
+    });
+  });
+};
+
+const crearArchivo = (path, texto) => {
+  return new Promise((resolve, reject) => {
+    fs.appendFile(path, texto, (err) => {
+      if (err) reject(err);
+      resolve({ message: 'Se creo el archivo correctamente.' });
+    });
+  });
+};
+
+module.exports = {
+  crearDDMMAAAA,
+  eliminarArchivo,
+  crearArchivo,
+};

server/helper/validar.js

@@ -0,0 +1,184 @@
+const moment = require('moment');
+const validator = require('validator');
+
+// Caractéres especiales permitidos en una string
+const caracterEspecial = (char) => {
+  const charset = [
+    ' ',
+    '.',
+    ',',
+    ':',
+    ';',
+    '?',
+    '¿',
+    '!',
+    '¡',
+    '(',
+    ')',
+    '"',
+    "'",
+    '-',
+    '_',
+    '/',
+    '#',
+    '%',
+    '\n',
+  ];
+
+  for (let i = 0; i < charset.length; i++) if (charset[i] === char) return true;
+  return false;
+};
+
+const yaExiste = (campo, m) => {
+  throw new Error(`Ya se encuentra en uso ${m ? 'el' : 'la'} ${campo}.`);
+};
+
+const noValido = (campo, m, razon) => {
+  throw new Error(
+    `${m ? 'El' : 'La'} ${campo} no es valid${m ? 'o' : 'a'}, ${razon}.`
+  );
+};
+
+/*
+  Valida que la variable contenga un valor, de lo contrario saca un error.
+*/
+const noHay = (variable, campo, m) => {
+  if (!variable) throw new Error(`No se mando ${m ? 'el' : 'la'} ${campo}.`);
+};
+
+/*
+  Valida que la variable sea una string y, si se necesita, que mida igual 
+  o menor que una longitud determinada.
+*/
+const validacionBasicaStr = (texto, campo, m, length) => {
+  noHay(texto, campo, m);
+  if (typeof texto !== 'string') noValido(campo, m, 'no se mando una string');
+  if (length && texto.length > length)
+    noValido(campo, m, 'tiene más carecteres de lo permitido');
+  return texto;
+};
+
+/*
+  Valida que la variable sea un numero entero, ya sea que recibe una string o
+  un number. Usualmente se usa para validar ids.
+*/
+const validarNumeroEntero = (numero, campo, m = true) => {
+  noHay(numero, campo, m);
+  if (typeof numero === 'number') numero = numero.toString();
+  if (typeof numero !== 'string')
+    noValido(campo, m, 'no se mando una string o un number');
+  if (!validator.isNumeric(numero, { no_symbols: true }))
+    noValido(campo, m, 'no es un número entero valido');
+  return Number(numero);
+};
+
+/*
+  Valida que la stirng mandada sea un correo valido.
+*/
+const validarCorreo = (correo, campo = 'correo', m = true, length) => {
+  validacionBasicaStr(correo, campo, m, length);
+  if (!validator.isEmail(correo)) noValido(campo, m, 'no es un correo válido');
+  return correo;
+};
+
+/*
+  Valida que la stirng mandada sean caracteres del abcdario.
+  Usualmente se usa para validar nombres, apellidos, etc.
+*/
+const validarTexto = (texto, campo, m, length) => {
+  validacionBasicaStr(texto, campo, m, length);
+  for (let i = 0; i < texto.length; i++)
+    if (
+      !validator.isAlpha(texto[i], 'es-ES') &&
+      texto[i] != ' ' &&
+      texto[i] != '.'
+    )
+      noValido(campo, m, 'contiene caracteres no validos');
+  return texto;
+};
+
+/*
+  Lo mismo que el de arriba pero este permite números y 
+  caracteres especiales.
+*/
+const validarAlfanumerico = (texto, campo, m, length) => {
+  validacionBasicaStr(texto, campo, m, length);
+  for (let i = 0; i < texto.length; i++) {
+    if (caracterEspecial(texto[i])) continue;
+    if (!validator.isAlphanumeric(texto[i], 'es-ES'))
+      noValido(campo, m, 'contiene caracteres no validos');
+  }
+  return texto;
+};
+
+/*
+  Valida que la string sea un número menor a 9 dígitos.
+*/
+const validarNumeroCuenta = (
+  numeroCuenta,
+  campo = 'numero de cuenta',
+  m = true
+) => {
+  validacionBasicaStr(numeroCuenta, campo, m, 9);
+  if (!validator.isNumeric(numeroCuenta, { no_symbols: true }))
+    noValido(campo, m, 'tiene caracteres que nos son números');
+  return numeroCuenta;
+};
+
+/*
+  Valida que la variable sea una fecha moment valida.
+*/
+const validarFecha = (fecha, campo, m) => {
+  let fechaMoment = moment(fecha);
+
+  noHay(fecha, campo, m);
+  if (!fechaMoment.isValid()) noValido(campo, m, 'no es una fecha válida');
+  return fechaMoment;
+};
+
+/*
+  Valida que una string contenga solo números
+*/
+const validarNumero = (
+  numero,
+  campo,
+  m,
+  length,
+  no_symbols = true,
+  makeNumber = false
+) => {
+  validacionBasicaStr(numero, campo, m, length);
+  if (!validator.isNumeric(numero, { no_symbols }))
+    noValido(campo, m, 'tiene caracteres que no son números');
+  if (makeNumber) return Number(numero);
+  return numero;
+};
+
+// const validarAccesibilidad = (usuariosValidos = [], idTipoUsuario) => {
+//   for (let i = 0; i < usuariosValidos.length; i++)
+//     if (idTipoUsuario === usuariosValidos[i]) return;
+//   throw new Error('Este usuario no tiene permitido usar esta linea de la API.');
+// };
+
+/*
+  Te dice si un objeto esta vacio o no.
+*/
+const validarObjetoVacio = (obj) => {
+  for (let key in obj) if (obj.hasOwnProperty(key)) return false;
+  return true;
+};
+
+module.exports = {
+  yaExiste,
+  noValido,
+  noHay,
+  validacionBasicaStr,
+  validarNumeroEntero,
+  validarCorreo,
+  validarTexto,
+  validarAlfanumerico,
+  validarNumeroCuenta,
+  validarFecha,
+  validarNumero,
+  validarObjetoVacio,
+};

server/middleware/autentificacion.js

@@ -0,0 +1,46 @@
+require('../config/config');
+const jwt = require('jsonwebtoken');
+
+const verificaToken = (req, res, next) => {
+  let token = req.headers.token;
+
+  if (!token)
+    return res.status(400).json({
+      message: 'No hay token',
+    });
+  jwt.verify(token, process.env.KEY, (err, decoded) => {
+    if (err) {
+      let message = '';
+
+      if (err.message === 'invalid signature')
+        message = 'El token no es valido. Inicia sesión de nuevo.';
+      if (err.message === 'jwt expired')
+        message = 'El token expiro. Inicia sesión de nuevo.';
+      if (err.message === 'jwt malformed')
+        message = 'Hubo un problema con el token. Inicia sesión de nuevo.';
+      return res.status(401).json({ message, err: 'token error' });
+    }
+    req.decoded = decoded;
+    next();
+  });
+};
+
+const crearToken = (data) => {
+  return jwt.sign({ data }, process.env.KEY, {
+    expiresIn: Number(process.env.CADUCIDAD_TOKEN),
+  });
+};
+
+const crearTokenUsuario = (data) => {
+  return jwt.sign({ data }, process.env.KEY, {
+    expiresIn: Number(process.env.CADUCIDAD_TOKEN_USUARIO),
+  });
+};
+
+const crearTokenOperador = (data) => {
+  return jwt.sign({ data }, process.env.KEY, {
+    expiresIn: Number(process.env.CADUCIDAD_TOKEN_OPERADOR),
+  });
+};
+
+module.exports = { verificaToken, crearToken };

server/routes/Usuario .js

@@ -0,0 +1,18 @@
+const express = require('express');
+const app = express();
+const { verificaToken } = require('../middleware/autentificacion');
+const route = '/usuario';
+// const controllerPath = '../controller/Usuario';
+// const login = require(`${controllerPath}/login`);
+
+// app.post(`${route}/login`, (req, res) => {
+//   return login(req.body)
+//     .then((data) => {
+//       res.status(200).json(data);
+//     })
+//     .catch((err) => {
+//       res.status(400).json({ message: err.message });
+//     });
+// });
+
+module.exports = app;

server/routes/index.js

@@ -0,0 +1,6 @@
+const express = require("express");
+const app = express();
+
+// app.use(require("./"));
+
+module.exports = app;