lqdvi/app2-api
2
0
Fork 0
Code Issues 24 Pull Requests Actions Packages Projects Releases Wiki Activity

.

Browse Source
This commit is contained in:
David Arranz 2022-02-17 14:20:42 +01:00
parent 49e43cb27a
commit 2675762f69
2 changed files with 465 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

682
modules/auth/auth.controller.js
View File

@ -1,333 +1,481 @@
'use strict'; "use strict";
const _ = require('lodash'); const _ = require("lodash");
const moment = require('moment'); const moment = require("moment");
const httpStatus = require('http-status'); const httpStatus = require("http-status");
const controllerHelper = require('../../helpers/controller.helper'); const controllerHelper = require("../../helpers/controller.helper");
const crypto = require('crypto'); const crypto = require("crypto");
const securityHelper = require('../../helpers/security.helper'); const securityHelper = require("../../helpers/security.helper");
const authService = require('./auth.service'); const authService = require("./auth.service");
const userService = require('./user.service'); const userService = require("./user.service");
const eventInscriptionService = require('../events/events_inscriptions.service'); const eventInscriptionService = require("../events/events_inscriptions.service");
const { RequestContactImportNewList } = require('sib-api-v3-sdk'); const { RequestContactImportNewList } = require("sib-api-v3-sdk");
moment.locale('es'); moment.locale("es");
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// CONSTANTS // CONSTANTS
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Module Name // Module Name
const MODULE_NAME = '[auth.controller]'; const MODULE_NAME = "[auth.controller]";
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// PUBLIC METHODS // PUBLIC METHODS
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
async function login(req, res, next) { async function login(req, res, next) {
try { try {
const data = { const data = {
id: req.user.id, id: req.user.id,
email: req.user.email, email: req.user.email,
phone: req.user.phoneNumber, phone: req.user.phoneNumber,
fbuid: req.user.uid fbuid: req.user.uid,
}; };
const tokens = securityHelper.generateToken(data); const tokens = securityHelper.generateToken(data);
const response = { const response = {
token: tokens.token, token: tokens.token,
refreshToken: tokens.refreshToken, refreshToken: tokens.refreshToken,
user: req.user, user: req.user,
}; };
return controllerHelper.handleResultResponse(response, null, req.params, res, httpStatus.OK); return controllerHelper.handleResultResponse(
} catch (error) { response,
return controllerHelper.handleErrorResponse(MODULE_NAME, login.name, error, res) null,
} req.params,
res,
httpStatus.OK
);
} catch (error) {
return controllerHelper.handleErrorResponse(
MODULE_NAME,
login.name,
error,
res
);
}
} }
async function loginWithPhone(req, res, next) { async function loginWithPhone(req, res, next) {
try { try {
const appVersion = ((req && req.headers && req.headers['accept-version']) ? req.headers['accept-version'] : null); const appVersion =
console.log('loginWithPhone - appVersion: ', appVersion); req && req.headers && req.headers["accept-version"]
? req.headers["accept-version"]
: null;
console.log("loginWithPhone - appVersion: ", appVersion);
console.log(req.user); console.log(req.user);
const findOptions = { const findOptions = {
phone: req.user.phoneNumber, phone: req.user.phoneNumber,
fbuid: req.user.uid fbuid: req.user.uid,
}; };
//Comprobamos si el usuario ya existe en nuestro sistema //Comprobamos si el usuario ya existe en nuestro sistema
let _user = await authService.extraMethods.findUserByPhone(req.user.phoneNumber); let _user = await authService.extraMethods.findUserByPhone(
if (_user) { req.user.phoneNumber
_user = _user.toJSON(); );
if (appVersion) { if (_user) {
if (_user.app_version != appVersion) { _user = _user.toJSON();
const result = userService._updateLastLoginAndVersionUser(_user.id, appVersion); if (appVersion) {
console.log('PRUEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEBA>>>> ', result); if (_user.app_version != appVersion) {
_user.app_version = appVersion; const result = userService._updateLastLoginAndVersionUser(
} _user.id,
} appVersion
);
console.log("PRUEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEBA>>>> ", result);
const tokenData = { _user.app_version = appVersion;
id: _user.id,
email: _user.email,
phone: _user.phone,
fbuid: _user.fbuid,
};
const tokens = securityHelper.generateToken(tokenData);
_user.token = tokens.token;
//Recuperamos el número de tickets para los proximos eventos
try {
const result = await eventInscriptionService._getInscriptionsOfNextEventsUser(_user.id);
console.log('Entradas del usuario', result);
_user.nextTicketsCount = result;
} catch (error) {
console.error(error);
return handleErrorResponse(MODULE_NAME, 'getInscriptionsOfNextEventsCount', error, res)
}
return controllerHelper.handleResultResponse(_user, null, req.params, res, httpStatus.OK);
} else {
return controllerHelper.handleResultResponse(null, null, req.params, res, httpStatus.NOT_FOUND);
} }
} catch (error) { }
const tokenData = {
id: _user.id,
email: _user.email,
phone: _user.phone,
fbuid: _user.fbuid,
};
const tokens = securityHelper.generateToken(tokenData);
_user.token = tokens.token;
//Recuperamos el número de tickets para los proximos eventos
try {
const result =
await eventInscriptionService._getInscriptionsOfNextEventsUser(
_user.id
);
console.log("Entradas del usuario", result);
_user.nextTicketsCount = result;
} catch (error) {
console.error(error); console.error(error);
return controllerHelper.handleErrorResponse(MODULE_NAME, login.name, error, res) return handleErrorResponse(
MODULE_NAME,
"getInscriptionsOfNextEventsCount",
error,
res
);
}
return controllerHelper.handleResultResponse(
_user,
null,
req.params,
res,
httpStatus.OK
);
} else {
return controllerHelper.handleResultResponse(
null,
null,
req.params,
res,
httpStatus.NOT_FOUND
);
} }
} catch (error) {
console.error(error);
return controllerHelper.handleErrorResponse(
MODULE_NAME,
login.name,
error,
res
);
}
} }
async function register(req, res, next) { async function register(req, res, next) {
function cleanAdminData(user) {
let cUser = user;
delete cUser.lastLogin;
delete cUser.state;
delete cUser.createdAt;
delete cUser.updatedAt;
return cUser;
}
function cleanAdminData(user) { const values = {
let cUser = user; phone: req.body.phone,
delete cUser.lastLogin; fbuid: req.body.fbuid,
delete cUser.state; };
delete cUser.createdAt;
delete cUser.updatedAt;
return cUser;
}
const values = { const appVersion =
req && req.headers && req.headers["accept-version"]
? req.headers["accept-version"]
: null;
console.log("register - appVersion: ", appVersion);
//Comprobamos si el usuario ya existe en nuestro sistema
let newUser = await authService.extraMethods.findUserByPhone(values.phone);
console.log("COMPROBAMOS IS EXISTE EN NUESTRO SISTEMA", newUser);
if (!newUser) {
try {
const data = {
//refresh_token: tokens.refreshToken,
phone: req.body.phone, phone: req.body.phone,
fbuid: req.body.fbuid fbuid: req.body.fbuid,
}; email: req.body.email,
name: req.body.name,
surname: req.body.surname,
entityId: req.body.entityid,
accessibility: req.body.accesssibility,
profile: req.body.profile,
app_version: appVersion,
lastlogin: moment().utc(),
};
const appVersion = ((req && req.headers && req.headers['accept-version']) ? req.headers['accept-version'] : null); newUser = await authService.extraMethods.createUser(data);
console.log('register - appVersion: ', appVersion); console.log("CREAMOS EL USUARIO EN NUESTRO SISTEMA", newUser);
} catch (error) {
console.error(error);
//Comprobamos si el usuario ya existe en nuestro sistema return controllerHelper.handleErrorResponse(
let newUser = await authService.extraMethods.findUserByPhone(values.phone); MODULE_NAME,
console.log('COMPROBAMOS IS EXISTE EN NUESTRO SISTEMA', newUser); register.name,
if (!newUser) { error,
res
try { );
const data = {
//refresh_token: tokens.refreshToken,
phone: req.body.phone,
fbuid: req.body.fbuid,
email: req.body.email,
name: req.body.name,
surname: req.body.surname,
entityId: req.body.entityid,
accessibility: req.body.accesssibility,
profile: req.body.profile,
app_version: appVersion,
lastlogin: moment().utc(),
};
newUser = await authService.extraMethods.createUser(data);
console.log('CREAMOS EL USUARIO EN NUESTRO SISTEMA', newUser);
} catch (error) {
console.error(error);
return controllerHelper.handleErrorResponse(MODULE_NAME, register.name, error, res);
}
};
if (newUser) {
newUser = newUser.toJSON();
newUser = cleanAdminData(newUser);
if (appVersion) {
if (newUser.app_version != appVersion) {
const result = userService._updateLastLoginAndVersionUser(newUser.id, appVersion);
console.log('PRUEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEBA>>>> ', result);
newUser.app_version = appVersion;
}
}
const tokenData = {
phone: values.phone,
fbuid: values.fbuid,
id: newUser.id,
email: newUser.email,
};
const tokens = securityHelper.generateToken(tokenData);
newUser.token = tokens.token;
console.log('COMO YA EXISTE CREAMOS EL TOKEN Y LO ASIGNAMOS', newUser);
} }
}
return controllerHelper.handleResultResponse(newUser, null, req.params, res, httpStatus.OK);
if (newUser) {
newUser = newUser.toJSON();
newUser = cleanAdminData(newUser);
if (appVersion) {
if (newUser.app_version != appVersion) {
const result = userService._updateLastLoginAndVersionUser(
newUser.id,
appVersion
);
console.log("PRUEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEBA>>>> ", result);
newUser.app_version = appVersion;
}
}
const tokenData = {
phone: values.phone,
fbuid: values.fbuid,
id: newUser.id,
email: newUser.email,
};
const tokens = securityHelper.generateToken(tokenData);
newUser.token = tokens.token;
console.log("COMO YA EXISTE CREAMOS EL TOKEN Y LO ASIGNAMOS", newUser);
}
return controllerHelper.handleResultResponse(
newUser,
null,
req.params,
res,
httpStatus.OK
);
} }
async function regenerateToken(req, res, next) { async function regenerateToken(req, res, next) {
const refreshToken = req.body.token; const refreshToken = req.body.token;
const phone = req.body.phone; const phone = req.body.phone;
const email = req.body.email; const email = req.body.email;
const user = await authService.extraMethods.findUserByRefreshToken(refreshToken); const user = await authService.extraMethods.findUserByRefreshToken(
refreshToken
);
console.debug(user, req.body); console.debug(user, req.body);
if (user && user.phone === phone && user.email === email) { if (user && user.phone === phone && user.email === email) {
const tokenData = { const tokenData = {
phone: user.phone, phone: user.phone,
fbuid: user.fbuid, fbuid: user.fbuid,
id: user.id, id: user.id,
email: user.email, email: user.email,
}; };
try { try {
const tokens = securityHelper.generateToken(tokenData); const tokens = securityHelper.generateToken(tokenData);
await authService.extraMethods.updateUserRefreshToken(user.id, tokens.refreshToken); await authService.extraMethods.updateUserRefreshToken(
const result = { token: tokens.token }; user.id,
return controllerHelper.handleResultResponse(result, null, req.params, res, httpStatus.OK); tokens.refreshToken
} catch(error) { );
return controllerHelper.handleErrorResponse(MODULE_NAME, regenerateToken.name, error, res); const result = { token: tokens.token };
} return controllerHelper.handleResultResponse(
} else { result,
return controllerHelper.handleResultResponse(null, null, req.params, res, httpStatus.UNAUTHORIZED); null,
req.params,
res,
httpStatus.OK
);
} catch (error) {
return controllerHelper.handleErrorResponse(
MODULE_NAME,
regenerateToken.name,
error,
res
);
} }
} else {
return controllerHelper.handleResultResponse(
null,
null,
req.params,
res,
httpStatus.UNAUTHORIZED
);
}
} }
async function rejectToken(req, res, next) { async function rejectToken(req, res, next) {
const refreshToken = req.body.refreshToken; const refreshToken = req.body.refreshToken;
const user = await authService.extraMethods.findUserByRefreshToken(refreshToken); const user = await authService.extraMethods.findUserByRefreshToken(
refreshToken
);
if (user && user.token === refreshToken ) { if (user && user.token === refreshToken) {
try { try {
await authService.extraMethods.deleteRefreshToken(refreshToken); await authService.extraMethods.deleteRefreshToken(refreshToken);
return controllerHelper.handleResultResponse(result, null, req.params, res, httpStatus.OK); return controllerHelper.handleResultResponse(
} catch (error) { result,
return controllerHelper.handleErrorResponse(MODULE_NAME, rejectToken.name, error, res); null,
} req.params,
} else { res,
return controllerHelper.handleResultResponse(null, null, req.params, res, httpStatus.NOT_FOUND); httpStatus.OK
);
} catch (error) {
return controllerHelper.handleErrorResponse(
MODULE_NAME,
rejectToken.name,
error,
res
);
} }
} else {
return controllerHelper.handleResultResponse(
null,
null,
req.params,
res,
httpStatus.NOT_FOUND
);
}
} }
// Registro por email y por password // Registro por email y por password
async function singup(req, res, next) { async function singup(req, res, next) {
var newUser = undefined; var newUser = undefined;
try { try {
const data = { const data = {
email: req.body.email, email: req.body.email,
name: req.body.name, name: req.body.name,
surname: req.body.surname, surname: req.body.surname,
level: 8, level: 8,
password: crypto.createHash('sha512').update(req.body.password).digest('hex') password: crypto
}; .createHash("sha512")
.update(req.body.password)
.digest("hex"),
};
newUser = await authService.extraMethods.createUser(data); newUser = await authService.extraMethods.createUser(data);
} catch (error) {
console.error(error);
return controllerHelper.handleErrorResponse(
MODULE_NAME,
register.name,
error,
res
);
}
} catch (error) { if (newUser) {
console.error(error); newUser = newUser.toJSON();
return controllerHelper.handleErrorResponse(MODULE_NAME, register.name, error, res);
}
if (newUser) { const tokenData = {
newUser = newUser.toJSON(); phone: undefined,
fbuid: undefined,
id: newUser.id,
email: newUser.email,
};
const tokens = securityHelper.generateToken(tokenData);
const tokenData = { newUser.token = tokens.token;
phone: undefined, }
fbuid: undefined,
id: newUser.id,
email: newUser.email,
};
const tokens = securityHelper.generateToken(tokenData);
newUser.token = tokens.token; return controllerHelper.handleResultResponse(
} newUser,
null,
return controllerHelper.handleResultResponse(newUser, null, req.params, res, httpStatus.OK); req.params,
res,
httpStatus.OK
);
} }
function verify(req, res, next) { function verify(req, res, next) {
const params = controllerHelper.extractParamsFromRequest(req, res, {}); const params = controllerHelper.extractParamsFromRequest(req, res, {});
const phone = params.query.phone; const phone = params.query.phone;
const email = params.query.email; const email = params.query.email;
const fbuid = params.query.fbuid; const fbuid = params.query.fbuid;
const user = req.user; const user = req.user;
if (user && user.phone === phone && user.email === email && user.fbuid === fbuid) { if (
return controllerHelper.handleResultResponse(user, null, req.params, res, httpStatus.OK); user &&
} else { user.phone === phone &&
return controllerHelper.handleResultResponse(null, null, req.params, res, httpStatus.UNAUTHORIZED); user.email === email &&
} user.fbuid === fbuid
) {
return controllerHelper.handleResultResponse(
user,
null,
req.params,
res,
httpStatus.OK
);
} else {
return controllerHelper.handleResultResponse(
null,
null,
req.params,
res,
httpStatus.UNAUTHORIZED
);
}
} }
async function getOrCreateUser(req, res, next) { async function getOrCreateUser(req, res, next) {
console.log('>>>>>>>>>>>>>>>>>>>> getOrCreateUser'); console.log(">>>>>>>>>>>>>>>>>>>> getOrCreateUser");
const params = controllerHelper.extractParamsFromRequest(req, res, {}); const params = controllerHelper.extractParamsFromRequest(req, res, {});
let dataInscription = res.locals.dataInscription; let dataInscription = res.locals.dataInscription;
if (!dataInscription) if (!dataInscription)
return handleResultResponse("Error getOrCreateUser, prepareInscription, recuperateEvent, recuperateReservation requerida", null, params, res, httpStatus.NOT_FOUND); return handleResultResponse(
"Error getOrCreateUser, prepareInscription, recuperateEvent, recuperateReservation requerida",
null,
params,
res,
httpStatus.NOT_FOUND
);
//Iniciamos el usuario relacionadas con la inscripción. //Iniciamos el usuario relacionadas con la inscripción.
let dataUser = { let dataUser = {
id: (req.user) ? req.user.id : null, id: req.user ? req.user.id : null,
phone: (req.user) ? req.user.phone : null, //((req.body.phone != '+34') ? req.body.phone : null), lo quitamos de momento por la de movistar phone: req.user ? req.user.phone : null, //((req.body.phone != '+34') ? req.body.phone : null), lo quitamos de momento por la de movistar
name: (req.user) ? req.user.name : req.body.name, name: req.user ? req.user.name : req.body.name,
surname: (req.user) ? req.user.surname : req.body.surname, surname: req.user ? req.user.surname : req.body.surname,
email: (req.user) ? req.user.email : req.body.email, email: req.user ? req.user.email : req.body.email,
entityId: null, entityId: null,
entityName: null, entityName: null,
entityLevel: null, entityLevel: null,
userResult: (req.user) ? req.user : null, userResult: req.user ? req.user : null,
}; };
//Asignamos a los datos del usuario a crear, el id de la entidad a la que pertenece, este caso solo es necesario cuando viene la inscripción por web ya que hay que crear un usuario nuevo
if (dataInscription.reservation) {
dataUser.entityId = dataInscription.reservation.entityId;
};
//creamos o recuperamos el usuario teniendo en cuenta que pude venir por APP o WEB //Asignamos a los datos del usuario a crear, el id de la entidad a la que pertenece, este caso solo es necesario cuando viene la inscripción por web ya que hay que crear un usuario nuevo
//si viene por web se tendra en cuenta el email y si viene por APP el phone para buscar if (dataInscription.reservation) {
try { dataUser.entityId = dataInscription.reservation.entityId;
//CHAPUZA PARA PODER DAR DE ALTA USUARIOS CON EL MISMO CORREO ELECTRONICO, PERO DISTINTO NOMBRE Y APELLIDO. }
if (req.user) //? 'app' : 'web', //En el caso de tener ya usuario viene por APP sino viene por web
dataUser.userResult = await userService._getOrCreateUser(dataUser)
else
dataUser.userResult = await userService._getOrCreateUserWEB(dataUser);
if (!dataUser.userResult) { //creamos o recuperamos el usuario teniendo en cuenta que pude venir por APP o WEB
// No se ha encontrado //si viene por web se tendra en cuenta el email y si viene por APP el phone para buscar
return handleResultResponse("No se ha podido crear o encontrar el usuario dado", null, params, res, httpStatus.NOT_FOUND); try {
}; //CHAPUZA PARA PODER DAR DE ALTA USUARIOS CON EL MISMO CORREO ELECTRONICO, PERO DISTINTO NOMBRE Y APELLIDO.
} catch (error) { if (req.user)
return handleErrorResponse(MODULE_NAME, 'createInscription', error, res); //? 'app' : 'web', //En el caso de tener ya usuario viene por APP sino viene por web
}; dataUser.userResult = await userService._getOrCreateUser(dataUser);
console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>', dataUser.userResult.user.Entity); else dataUser.userResult = await userService._getOrCreateUserWEB(dataUser);
dataUser.entityId = (dataUser.userResult.user.Entity) ? dataUser.userResult.user.Entity.id : null;
dataUser.entityName = (dataUser.userResult.user.Entity) ? dataUser.userResult.user.Entity.name : 'DEFAULT'; if (!dataUser.userResult) {
dataUser.entityLevel = (dataUser.userResult.user.Entity) ? dataUser.userResult.user.Entity.level : null; // No se ha encontrado
res.locals.dataUser = dataUser; return handleResultResponse(
next(); "No se ha podido crear o encontrar el usuario dado",
null,
params,
res,
httpStatus.NOT_FOUND
);
}
} catch (error) {
return handleErrorResponse(MODULE_NAME, "createInscription", error, res);
}
console.log(
">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>",
dataUser.userResult.user.Entity
);
dataUser.entityId = dataUser.userResult.user.Entity
? dataUser.userResult.user.Entity.id
: null;
dataUser.entityName = dataUser.userResult.user.Entity
? dataUser.userResult.user.Entity.name
: "DEFAULT";
dataUser.entityLevel = dataUser.userResult.user.Entity
? dataUser.userResult.user.Entity.level
: null;
res.locals.dataUser = dataUser;
next();
} }
module.exports = { module.exports = {
login, login,
loginWithPhone, loginWithPhone,
register, register,
regenerateToken, regenerateToken,
rejectToken, rejectToken,
singup, singup,
verify, verify,
getOrCreateUser, getOrCreateUser,
MODULE_NAME MODULE_NAME,
} };

102
modules/auth/auth.service.js
View File

@ -1,61 +1,59 @@
'use strict'; "use strict";
//const JwtHelper = require('../../helpers/jwt.helper'); //const JwtHelper = require('../../helpers/jwt.helper');
const models = require('../../core/models'); const models = require("../../core/models");
const extraMethods = { const extraMethods = {
findUser: async (params, context) => {
findUser: async (params, context) => { return await models.User.findOne({
return await models.User.findOne({ where: params,
where: params, include: [
include: [{ {
required: false, required: false,
model: models.Entity, model: models.Entity,
as: 'Entity', as: "Entity",
}] },
],
});
},
}); findUserByPhone: async (Phone) => {
}, return await models.User.findOne({
where: { phone: Phone },
});
},
findUserByPhone: async (Phone) => { createUser: async (params, context) => {
return await models.User.findOne({ // return models.sequelize.transaction(async transaction => {
where: {phone: Phone}, //const result = await models.User.create(params, { transaction });
}); const result = await models.User.create(params);
}, return result;
// });
},
createUser: async (params, context) => { findUserByRefreshToken: async (refreshToken) => {
// return models.sequelize.transaction(async transaction => { return await models.User.findOne({
//const result = await models.User.create(params, { transaction }); where: {
const result = await models.User.create(params); refresh_token: refreshToken,
return result; state: "active",
// }); },
}, });
},
findUserByRefreshToken: async(refreshToken) => { updateUserRefreshToken: async (userId, newRefreshToken) => {
return await models.User.findOne({ return await models.User.update(
where: { { refresh_token: newRefreshToken },
refresh_token: refreshToken, { where: { id: userId } }
state: 'active' );
} },
})
},
updateUserRefreshToken: async(userId, newRefreshToken) => { deleteRefreshToken: async (userId, refreshToken) => {
return await models.User.update( return await models.User.update(
{ refresh_token: newRefreshToken }, { refresh_token: null },
{ where: { id: userId }} { where: { id: userId } }
); );
}, },
deleteRefreshToken: async (userId, refreshToken) => {
return await models.User.update(
{ refresh_token: null },
{ where: { id: userId } }
);
}
}
module.exports = {
extraMethods
}; };
module.exports = {
extraMethods,
};