Actualizacion del proyecto mejoras y cambios en autorizacion , ahora es por jwt

classes/szerCampania.js

+const Joi = require('joi');
+
+class szerCampania{
+    constructor(uid){
+        this.uid = uid;
+    }
+    
+}
+
+function validate(json){
+    const schema =Joi.object({
+        'uid' : Joi.string().required().messages({
+            'string.base': `"uid" debe ser una cadena de caracteres`,
+            'string.empty': `"uid" no puede estar vacío`,
+            'any.required': `"uid" es un campo requerido`
+          }),
+    });
+
+    return schema.validate(json);
+}
+
+module.exports = szerCampania;
+module.exports.validate = validate;
\ No newline at end of file

classes/szerUsuario.js

+const Joi = require("joi");
+
+class szerUsuario {
+  constructor(user, password, name) {
+    this.name = name;
+    this.user = user;
+    this.password = password;
+  }
+
+}
+
+function validate(json) {
+    const schema = Joi.object({
+      name: Joi.string().min(10).max(50).required().messages({
+        "string.base": `"name" debe ser una cadena de caracteres`,
+        "string.empty": `"name" no puede estar vacío`,
+        "any.required": `"name" es un campo requerido`,
+        "string.min": `"name" no posee el tamaño correcto`,
+        "string.max": `"name" no posee el tamaño correcto`,
+      }),
+      user: Joi.string().min(6).max(6).required().messages({
+        "string.base": `"user" debe ser una cadena de caracteres`,
+        "string.empty": `"user" no puede estar vacío`,
+        "any.required": `"user" es un campo requerido`,
+        "string.min": `"user" no posee el tamaño correcto`,
+        "string.max": `"user" no posee el tamaño correcto`,
+      }),
+      password: Joi.string().min(8).max(255).required().messages({
+        "string.base": `"password" debe ser una cadena de caracteres`,
+        "string.empty": `"password" no puede estar vacío`,
+        "any.required": `"password" es un campo requerido`,
+        "string.min": `"password" no posee el tamaño correcto`,
+        "string.max": `"password" no posee el tamaño correcto`,
+      }),
+    });
+
+    return schema.validate(json);
+  }
+
+module.exports = szerUsuario;
+module.exports.validate = validate;

config/default.json

@@ -4,7 +4,8 @@
             "OK": 200,
             "BAD_REQUEST": 400,
             "NOT_FOUND": 404,
-            "ERROR": 500
+            "ERROR": 500,
+            "UNAUTHORIZED":401
         },
         "HTML_SECTIONS": {
             "HEAD": 1,

config/development.json

@@ -11,8 +11,10 @@
         "DBUSER": "mcafee_admin_territorios",
         "DBPSSW": "HSuwshhuw43&%1253"
     },
-    "basicAuth": {
+    "customAuth": {
+        "NAME" : "G3ARLABS",
         "USER": "userApi",
-        "PASS" : "34lq4od8usda"
-    }
+        "PASS" : "$2b$10$nd1vR4YSZS/o5ScJyVZZIOiFglpuVOLrCOfY35.YAidlwvWERe3G2"
+    },
+    "pkj": "G3arl@abs"
 }
\ No newline at end of file

config/production.json

@@ -11,9 +11,11 @@
         "DBUSER": "mcafee_admin_territorios",
         "DBPSSW": "HSuwshhuw43&%1253"
     },
-    "basicAuth": {
+    "customAuth": {
+        "NAME" : "G3ARLABS",
         "USER": "userApi",
-        "PASS" : "34lq4od8usda"
-    }
+        "PASS" : "$2b$10$nd1vR4YSZS/o5ScJyVZZIOiFglpuVOLrCOfY35.YAidlwvWERe3G2"
+    },
+    "pkj": "G3arl@abs"
     
 }
\ No newline at end of file

index.js

 const config = require('config');
-const serverApp = require('./middleware/app');
-const log = require('./middleware/logger');
-
+const serverApp = require('./middleware/server-init');
+const log = require('./utils/logger');
 /*Trick para problema con eventListeners maximos*/
 require('events').EventEmitter.prototype._maxListeners = 100;
 /**
  * Se activa la conexion a la base de datos en modalidad pool
  **/
 
-console.log(`Aplicacion : ${config.get("name")} `);
+log.logger.info(`Aplicacion : ${config.get("name")} `);
 /*
 * Solo en ambientes de desarrollo locales se coloca el puerto directamente al iniciar la aplicacion
 * en servidores, se debe obtener del objeto global "process"
 */
 const port = process.env.PORT || config.get("server.PORT");
 serverApp.listenPort(port);
+
+//crear login para obtener jwt valido para poder realizar las peticiones hacia el endpoint
\ No newline at end of file

legacy/legacy.readme

+app.js:
+const basicAuth = require("express-basic-auth");
+const config = require("config");
+    
+server.use((req, res, next) => {
+  console.log("Verificando Credenciales...");
+  next();
+});
+
+/**
+ * MiddleWare Function : Autorizacion basica permitida para la api generada
+ */
+
+server.use(
+  basicAuth({
+    authorizer: myAuthorizer,
+    unauthorizedResponse: getUnauthorizedResponse,
+  })
+);
+
+server.use((req, res, next) => {
+  console.log("Autentificado correctamente!...");
+  next();
+});
+
+function myAuthorizer(username, password) {
+  const userMatches = basicAuth.safeCompare(
+    username,
+    config.get("basicAuth.USER")
+  );
+  const passwordMatches = basicAuth.safeCompare(
+    password,
+    config.get("basicAuth.PASS")
+  );
+
+  return userMatches & passwordMatches;
+}
+
+function getUnauthorizedResponse(req) {
+  return req.auth
+    ? `Las credenciales ${req.auth.user}:${req.auth.password} no son válidas.`
+    : "No se ingresaron credenciales";
+}

middleware/async.js

+module.exports = function (handler){
+    
+    return async (req,res,next) => {
+        try{
+            handler(req,res);
+        }catch(ex){
+            
+            next(ex);
+        }
+    }
+    
+
+}

middleware/auth-endpoint-validator.js

+const jwt =  require('jsonwebtoken');
+const config = require('config');
+const log = require('../utils/logger');
+
+module.exports=function(req,res,next){
+
+if(!req.header('x-auth-mcafee-token')){
+    let error = new Error('Acceso denegado.No existe un token válido.');
+    log.logger.error(error);
+    return res.status(config.get('constants.HTTP_STATUS_CODE.UNAUTHORIZED')).json({code : config.get('constants.HTTP_STATUS_CODE.UNAUTHORIZED') ,error : error})
+}
+
+try{
+    const decoded =  jwt.decode(req.header('x-auth-mcafee-token'),config.get('pkj'));
+    if(!decoded) {
+        let error = new Error('Token con formato incorrecto.');
+        log.logger.error(error);
+        return res.status(config.get('constants.HTTP_STATUS_CODE.UNAUTHORIZED')).json({code : config.get('constants.HTTP_STATUS_CODE.UNAUTHORIZED') ,error : error})
+    }
+        
+    next();
+
+}catch(ex){
+    let error = new Error('Token Inválido');
+    log.logger.error(error);
+    res.status(config.get('constants.HTTP_STATUS_CODE.BAD_REQUEST')).json({code:config.get('constants.HTTP_STATUS_CODE.BAD_REQUEST') ,error : error});
+}
+
+}
\ No newline at end of file

middleware/auth-login-validator.js

+const config = require ('config');
+const bcrypt = require("bcrypt");
+
+module.exports = function (req, res, next) {
+    //Validacion de nombre empresa unico
+    if (req.body.name !== config.get("customAuth.NAME")){
+      log.logger.error(`Nombre ${req.body.user} invalido...`);    
+      return res
+        .status(config.get("constants.HTTP_STATUS_CODE.BAD_REQUEST"))
+        .json(new Error("Identificacion no válida"));
+    }
+    //Validacion de nombre de usuario
+    if (req.body.user !== config.get("customAuth.USER")){
+      log.logger.error(`Usuario ${req.body.user} invalido...`);  
+      return res
+        .status(config.get("constants.HTTP_STATUS_CODE.BAD_REQUEST"))
+        .json(new Error("Usuario y/o Password inválido"));
+    }
+     //Validacion de password
+  
+     if (!bcrypt.compare(req.body.password, config.get('customAuth.PASS'))){
+  
+      log.logger.error(`Password ${req.body.password} invalido...`);
+     
+      return res
+        .status(config.get("constants.HTTP_STATUS_CODE.BAD_REQUEST"))
+        .json(new Error("Usuario y/o Password inválido"));
+     }
+  
+     next();
+  }
\ No newline at end of file

middleware/error.js

+const config = require("config");
+const log = require('../utils/logger');
+const winston = require('winston');
+
+module.exports = (error, req, res, next) => {
+  log.logger.error(error);    
+  res
+    .status(config.get("constants.HTTP_STATUS_CODE.ERROR"))
+    .json({
+      code: config.get("constants.HTTP_STATUS_CODE.ERROR"),
+      error: new Error(error).message,
+    });
+};

middleware/logger.js

-/**
- * Configurations of logger.
- */
-const appRoot = require('app-root-path');
-const winston = require("winston");
-
-var options = {
-  error: { /*Se almacena registro en archivo de error*/
-    level: 'error',
-    name: 'error-file',
-    filename: `${appRoot}/logs/error.log`,
-    handleExceptions: true,
-    json: true,
-    maxsize: 5242880, // 5MB
-    maxFiles: 100,
-    colorize: true,
-    datePattern: "yyyy-MM-dd-",
-    prepend: true,
-  },
-  info: {/*Se almacena registro en archivo de aplicacion*/
-    level: 'info',
-    name: 'success-file',
-    filename: `${appRoot}/logs/app.log`,
-    handleExceptions: true,
-    json: true,
-    maxsize: 5242880, // 5MB
-    maxFiles: 100,
-    colorize: true,
-    datePattern: "yyyy-MM-dd-",
-    prepend: true,
-  },
-  console: {/*Log que va directo a la consola*/
-    level: 'debug',
-    handleExceptions: true,
-    json: false,
-    colorize: true,
-  },
-};
-
-
-
-const consoleConfig = [
-  new winston.transports.Console(options.console),
-  new winston.transports.File(options.error),
-  new winston.transports.File(options.info),
-];
-
-const createLogger = winston.createLogger({
-  transports: consoleConfig,
-  exitOnError: false, // do not exit on handled exceptions
-});
-
-
-
-module.exports.logger = createLogger;

middleware/app.js → middleware/server-init.js

-const config = require("config");
+require('express-async-errors');
+const error = require('../middleware/error');
 const express = require("express");
-const basicAuth = require("express-basic-auth");
 const userAgentValidator = require("express-useragent");
 const server = express();
 const campanias = require('../routes/campanias');
+const auth = require('../routes/auth');
+const internal = require('../routes/internal');
 
-server.use((req, res, next) => {
-  console.log("Verificando Credenciales...");
-  next();
-});
-
-/**
- * MiddleWare Function : Autorizacion basica permitida para la api generada
- */
-server.use(
-  basicAuth({
-    authorizer: myAuthorizer,
-    unauthorizedResponse: getUnauthorizedResponse,
-  })
-);
-
-server.use((req, res, next) => {
-  console.log("Autentificado correctamente!...");
-  next();
-});
-
-function myAuthorizer(username, password) {
-  const userMatches = basicAuth.safeCompare(
-    username,
-    config.get("basicAuth.USER")
-  );
-  const passwordMatches = basicAuth.safeCompare(
-    password,
-    config.get("basicAuth.PASS")
-  );
-
-  return userMatches & passwordMatches;
-}
-
-function getUnauthorizedResponse(req) {
-  return req.auth
-    ? `Las credenciales ${req.auth.user}:${req.auth.password} no son válidas.`
-    : "No se ingresaron credenciales";
-}
 
 /**
  * MiddleWare Function: Verifica que el req.body sea json y lo trata como tal
@@ -73,8 +37,9 @@ server.use(userAgentValidator.express());
  * MiddleWare Function : Se activa la utilizacion de rutas para campanias
  */
 server.use('/endpoint/campania', campanias);
-
-
+server.use('/endpoint/auth', auth);
+server.use('/endpoint/internal', internal)
+server.use(error);
 
 /**
  * Definicion de funciones asociadas a endpoints

middleware/validation.js

-const Joi = require('joi');
-
-class szerCampaniaValidator{
-    validate(szerCampania){
-        const schema =Joi.object({
-            'uid' : Joi.string().required().messages({
-                'string.base': `"uid" debe ser una cadena de caracteres`,
-                'string.empty': `"uid" no puede estar vacío`,
-                'any.required': `"uid" es un campo requerido`
-              }),
-        });
-    
-        return schema.validate(szerCampania, this);
-    }
-}
-
-module.exports = szerCampaniaValidator;
\ No newline at end of file

package.json

@@ -13,11 +13,14 @@
   "dependencies": {
     "app-root-path": "^3.0.0",
     "basic-auth": "^2.0.1",
+    "bcrypt": "^5.0.0",
     "config": "^3.3.2",
     "express": "^4.17.1",
+    "express-async-errors": "^3.1.1",
     "express-basic-auth": "^1.2.0",
     "express-useragent": "^1.0.15",
     "joi": "^17.2.1",
+    "jsonwebtoken": "^8.5.1",
     "log": "^6.0.0",
     "log-node": "^7.0.0",
     "mongoose": "^5.10.9",

routes/auth.js

+const jwt = require("jsonwebtoken");
+const express = require("express");
+const config = require("config");
+const log = require("../utils/logger");
+const authloginvalidation = require("../middleware/auth-login-validator");
+const router = express.Router();
+const jsonResponse = {};
+
+router.post("/",authloginvalidation, async (req, res) => {
+
+const ip = req.ip;
+const token = jwt.sign({'ip':ip, 'identifier': req.body.name}, config.get('pkj'));
+res.status(config.get('constants.HTTP_STATUS_CODE.OK')).json(token);
+});
+
+
+
+module.exports = router;

routes/campanias.js

 const express = require("express");
-const router = express.Router();
 const config = require("config");
-const dbConn = require("../middleware/database");
-const szerCampaniaValidator = require("../middleware/validation");
-const log = require('../middleware/logger');
+const dbConn = require("../utils/database");
+const szerCampania= require("../classes/szerCampania");
+const log = require('../utils/logger');
+const auth_endpoint_validator = require('../middleware/auth-endpoint-validator');
+const router = express.Router();
 const jsonResponse = {};
 
 dbConn.getConnection((err, connection) => {
@@ -13,42 +14,43 @@ dbConn.getConnection((err, connection) => {
   } else console.log("Conectado!...");
 });
 
-router.post("/obtener/contenido", (req, res) => {
-  const validateCampania = new szerCampaniaValidator();
-  //Si falta el parametro uid, error 400
-  var { error } = validateCampania.validate(req.body);
+
+
+router.post("/obtener/contenido",auth_endpoint_validator,  async (req, res) => {//Como segundo parametro puede ir una funcion middleware o un array de middlewares en el orden en que funcionan. //IMPLEMENTAR JWT
+  //Si parametro uid no cumple la validacion, error 400
+  var { error } = szerCampania.validate(req.body);
   if (error) {
-    res
+    return res
       .status(config.get("constants.HTTP_STATUS_CODE.BAD_REQUEST"))
       .json({ error: error.details[0].message });
-    return;
+    ;
   }
 
-  //Seteo de UID ingresado en la peticion
-  let { uid } = req.body;
+  //seteo de objeto en base a modelo szerCampania
+  const campaniaObj = new szerCampania(req.body.uid);
+
   //Seteo de entorno mediante userAgent
   let isMobile = req.useragent.isMobile;
-  processHtml(res, uid, isMobile);
+  await processHtml(res, campaniaObj.uid, isMobile);
 });
 
 async function processHtml(res, uid, isMobile) {
   //Buscar UID , si no esta es error 404
   //console.log("obteniendo campaña asociada...");
-  try {
     const campania = await getCampaniaById([uid]);
     if (!campania || campania.length == 0) {
-      res
+      return res
         .status(config.get("constants.HTTP_STATUS_CODE.NOT_FOUND"))
         .json({ error: `El uid ${uid} no esta asociado a ninguna campaña.` });
-      return;
+      
     }
     //console.log(campania[0].cam_id);
     const template = await getTemplateById([campania[0].tem_id]);
     if (!template || template.length == 0) {
-      res.status(config.get("constants.HTTP_STATUS_CODE.NOT_FOUND")).json({
+      return res.status(config.get("constants.HTTP_STATUS_CODE.NOT_FOUND")).json({
         error: `La campaña uid ${uid}  no tiene asociado ninguna plantilla de diseño.`,
       });
-      return;
+      ;
     }
     //console.log(template[0].tem_id);
 
@@ -77,16 +79,9 @@ async function processHtml(res, uid, isMobile) {
     jsonResponse.terminosCondiciones = generateHtmlCondiciones(campania);
 
     res.status(config.get("constants.HTTP_STATUS_CODE.OK")).send(jsonResponse);
-  } catch (err) {
-    log.logger.error(`Error : ${err.message}`);
-    res
-      .status(config.get("constants.HTTP_STATUS_CODE.ERROR"))
-      .json({ error: `Ha ocurrido un error : ${err.message}` });
-  }
 }
 
 async function generateHtmlSection(campania, type, isMobile) {
-  try {
     let contenidos = await getContenido(campania, type, isMobile, false);
     let countContenido = await getContenido(campania, type, isMobile, true);
     var posContenido = 0;
@@ -125,10 +120,6 @@ async function generateHtmlSection(campania, type, isMobile) {
     });
 
     return arrayJson;
-  } catch (err) {
-    log.logger.error(`Error : ${err.message}`);
-    return [];
-  }
 }
 
 async function getContenido(campania, type, isMobile, isCount) {

routes/internal.js

+const bcrypt = require("bcrypt");
+const express = require("express");
+const config = require("config");
+const log = require('../utils/logger');
+const router = express.Router();
+const jsonResponse = {};
+
+router.post("/" ,async (req, res) => {
+
+const salt = await bcrypt.genSalt(10);
+const bcryptpass = await bcrypt.hash(req.body.password, salt);
+
+res.status(config.get('constants.HTTP_STATUS_CODE.OK')).json(bcryptpass);
+
+});
+
+
+module.exports = router;
\ No newline at end of file

utils/logger.js

+const appRoot = require('app-root-path');
+const winston = require('winston');
+// Use JSON logging for log files
+// Here winston.format.errors() just seem to work
+// because there is no winston.format.simple()
+const jsonLogFileFormat = winston.format.combine(
+  winston.format.errors({ stack: true }),
+  winston.format.timestamp(),
+  winston.format.prettyPrint(),
+);
+
+// Create file loggers
+const logger = winston.createLogger({
+  level: 'debug',
+  format: jsonLogFileFormat,
+  transports: [
+    //
+    // - Write to all logs with level `info` and below to `combined.log`
+    // - Write all logs error (and below) to `error.log`.
+    //
+    new winston.transports.File({ filename:  `${appRoot}/logs/error.log`, level: 'error' }),
+    new winston.transports.File({ filename:  `${appRoot}/logs/app.log`, level: 'info' })
+  ],
+  expressFormat: true,
+});
+
+module.exports.logger = logger;
\ No newline at end of file