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

Repaso control del aforo de invitaciones

Browse Source
This commit is contained in:
David Arranz 2023-06-14 11:35:11 +02:00
parent c48f415385
commit 3f0b87870c
6 changed files with 155 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

261
core/controllers/index.js
View File

@ -1,150 +1,157 @@
const _find = require('./find'); const _find = require("./find");
const httpStatus = require('http-status'); const httpStatus = require("http-status");
const { extractParamsFromRequest, handleErrorResponse, handleResultResponse } = require('../../helpers/controller.helper'); const {
extractParamsFromRequest,
handleErrorResponse,
handleResultResponse,
} = require("../../helpers/controller.helper");
function buildContext(req, config) { function buildContext(req, config) {
return { return {
user: req.user, user: req.user,
scopes: [], scopes: [],
...config, ...config,
} };
} }
const defaultOptions = { const defaultOptions = {
MODULE_NAME: 'default', MODULE_NAME: "default",
params: { params: {
find: { includeAll: false }, find: { includeAll: false },
findOne: { includeAll: false, paginate: { limit: 1, page: 1 } }, findOne: { includeAll: false, paginate: { limit: 1, page: 1 } },
count: {}, count: {},
create: {}, create: {},
update: {}, update: {},
delete: {}, delete: {},
} },
} };
const generateControllers = (service, extraControllers = {}, options = {}) => { const generateControllers = (service, extraControllers = {}, options = {}) => {
const _options = { const _options = {
...defaultOptions, ...defaultOptions,
...options ...options,
}; };
const defaultControllers = { const defaultControllers = {
find: (config) => {
return async (req, res, next) => {
config = config || {
scopes: [],
};
find: (config) => { const params = extractParamsFromRequest(req, res, _options.params.find);
try {
const result = await service.fetchAll(params, buildContext(req, config));
return handleResultResponse(result.rows, result.count, params, res);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, "find", error, res);
}
};
},
return async (req, res, next) => { findOne: (config) => {
config = config || { return async (req, res, next) => {
scopes: [], const params = extractParamsFromRequest(req, res, _options.params.findOne);
}; try {
let result = await service.fetchOne(params, buildContext(req, config));
result = _options.findOneCallback !== undefined ? _options.findOneCallback(result) : result;
return handleResultResponse(
result,
null,
params,
res,
result === null ? httpStatus.NOT_FOUND : httpStatus.OK
);
} catch (error) {
console.log(error);
return handleErrorResponse(_options.MODULE_NAME, "findOne", error, res);
}
};
},
const params = extractParamsFromRequest(req, res, _options.params.find); count: (config) => {
try { return async (req, res, next) => {
const result = await service.fetchAll(params, buildContext(req, config)); const params = extractParamsFromRequest(req, res, _options.params.count);
return handleResultResponse(result.rows, result.count, params, res); try {
} catch (error) { const result = await service.count(params, buildContext(req, config));
return handleErrorResponse(_options.MODULE_NAME, 'find', error, res) return handleResultResponse(result, null, params, res);
} } catch (error) {
} return handleErrorResponse(_options.MODULE_NAME, "count", error, res);
}, }
};
},
findOne: (config) => { create: (config) => {
return async (req, res, next) => { return async (req, res, next) => {
const params = extractParamsFromRequest(req, res, _options.params.findOne); const params = extractParamsFromRequest(req, res, _options.params.count);
try { try {
let result = await service.fetchOne(params, buildContext(req, config)); //Asignamos el usuario que crea el elemento si viene
result = _options.findOneCallback !== undefined ? _options.findOneCallback(result) : result; req.body.userId = req.user ? req.user.id : null;
return handleResultResponse(result, null, params, res, (result === null) ? httpStatus.NOT_FOUND : httpStatus.OK); //Añadimos los parametros que vienen por url y en el body
} catch (error) { let values = Object.assign({}, params.params, req.body);
console.log(error); //Quitamos el campo id si viniera, para que no de un conflicto con el id autoinc
return handleErrorResponse(_options.MODULE_NAME, 'findOne', error, res) if (values.id) delete values.id;
} console.log(">> SERVICE CREATE ->", values);
} const result = await service.create(values, buildContext(req, config));
}, return handleResultResponse(result, null, null, res, httpStatus.CREATED);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, "create", error, res);
}
};
},
count: (config) => { update: (config) => {
return async (req, res, next) => { return async (req, res, next) => {
const params = extractParamsFromRequest(req, res, _options.params.count); try {
try { const params = extractParamsFromRequest(req, res, _options.params.update);
const result = await service.count(params, buildContext(req, config)); console.log("SERVICE UPDATE ->", params, req.body);
return handleResultResponse(result, null, params, res);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, 'count', error, res)
}
}
},
create: (config) => { const response = await service.update(params, req.body, buildContext(req, config));
return async (req, res, next) => { // https://sequelize.org/master/class/lib/model.js~Model.html#static-method-update
const params = extractParamsFromRequest(req, res, _options.params.count); // Update devuelve un array de un elemento con el número de filas afectadas
try { // por la operación. Por comodidad, devuelvo el valor, no el array.
//Asignamos el usuario que crea el elemento si viene
req.body.userId = (req.user) ? req.user.id : null;
//Añadimos los parametros que vienen por url y en el body
let values = Object.assign({}, params.params, req.body);
//Quitamos el campo id si viniera, para que no de un conflicto con el id autoinc
if (values.id) delete values.id;
console.log('>> SERVICE CREATE ->', values);
const result = await service.create(values, buildContext(req, config));
return handleResultResponse(result, null, null, res, httpStatus.CREATED)
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, 'create', error, res)
}
};
},
update: (config) => { let result = response[0];
return async (req, res, next) => { let status = httpStatus.OK;
try { if (result < 1) {
const params = extractParamsFromRequest(req, res, _options.params.update); status = httpStatus.NOT_FOUND;
console.log('SERVICE UPDATE ->', params, req.body); }
const response = await service.update(params, req.body, buildContext(req, config)); // Express no puede devolver números porque los confunde con el 'status'.
// https://sequelize.org/master/class/lib/model.js~Model.html#static-method-update // Convertimos a cadena.
// Update devuelve un array de un elemento con el número de filas afectadas result = result.toString();
// por la operación. Por comodidad, devuelvo el valor, no el array.
let result = response[0]; return handleResultResponse(result, null, req.params, res, status);
let status = httpStatus.OK; } catch (error) {
if (result < 1) { return handleErrorResponse(_options.MODULE_NAME, "update", error, res);
status = httpStatus.NOT_FOUND; }
} };
},
// Express no puede devolver números porque los confunde con el 'status'. delete: (config) => {
// Convertimos a cadena. return async (req, res, next) => {
result = result.toString(); try {
const params = extractParamsFromRequest(req, res, _options.params.delete);
console.log("SERVICE DELETE ->", params);
const result = await service.delete(params, buildContext(req, config));
return handleResultResponse(result, null, req.params, res, httpStatus.NO_CONTENT);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, "delete", error, res);
}
};
},
};
return handleResultResponse(result, null, req.params, res, status) //const associationControllers = generateAssociationControllers(model, options);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, 'update', error, res)
}
}
},
delete: (config) => { //console.log(associationControllers);
return async (req, res, next) => {
try {
const params = extractParamsFromRequest(req, res, _options.params.delete);
console.log('SERVICE DELETE ->', params);
const result = await service.delete(params, buildContext(req, config));
return handleResultResponse(result, null, req.params, res, httpStatus.NO_CONTENT);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, 'delete', error, res)
}
}
},
}
//const associationControllers = generateAssociationControllers(model, options);
//console.log(associationControllers);
return {
...defaultControllers,
//...associationControllers
...extraControllers
}
}
return {
...defaultControllers,
//...associationControllers
...extraControllers,
};
};
module.exports = generateControllers; module.exports = generateControllers;
module.exports.buildContext = buildContext; module.exports.buildContext = buildContext;

2
helpers/service.helper.js
View File

@ -188,7 +188,7 @@ const generateService = (model, extraMethods = {}, options = defaultOptions) =>
create: async (values, context) => { create: async (values, context) => {
if (extraMethods.beforeCreate) { if (extraMethods.beforeCreate) {
values = extraMethods.beforeCreate(values, context); values = await extraMethods.beforeCreate(values, context);
} }
var result = await model.scope(context.scopes).create(values); var result = await model.scope(context.scopes).create(values);
if (extraMethods.afterCreate) { if (extraMethods.afterCreate) {

2
modules/events/event.routes.js
View File

@ -535,7 +535,7 @@ routes.put(
"/admin/reservations/:id", "/admin/reservations/:id",
isAdministratorUser, isAdministratorUser,
//SchemaValidator(eventValidation.ReservationInputType, true), //SchemaValidator(eventValidation.ReservationInputType, true),
eventReservationController.checkAssitantsUpdate, eventReservationController.checkAssitantsUpdate,
eventReservationController.update() eventReservationController.update()
); );

17
modules/events/events_inscriptions.controller.js
View File

@ -34,7 +34,7 @@ async function refreshConfirmed(inscription) {
? inscription.overflowEventId ? inscription.overflowEventId
: inscription.eventId; : inscription.eventId;
let NewConfirmed = 0; let NewConfirmed = 0;
//Si la inscripción viene por una reserva modificamos los confirmados de la reserva //Si la inscripción viene por una reserva modificamos los confirmados de la reserva
if (inscription.reservationId != null) { if (inscription.reservationId != null) {
@ -460,7 +460,7 @@ const extraControllers = {
try { try {
const inscription = await eventInscriptionService._getInscriptionById(inscriptionId); const inscription = await eventInscriptionService._getInscriptionById(inscriptionId);
console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion a borrar:"); console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion a borrar:");
console.log(inscription); console.log(inscription.id);
//Solo se tiene en cuenta el marketinglist del evento //Solo se tiene en cuenta el marketinglist del evento
marketingListId = inscription.event.marketing_list; marketingListId = inscription.event.marketing_list;
@ -477,9 +477,8 @@ const extraControllers = {
if ((await eventInscriptionService._deleteInscription(inscription.id)) > 0) { if ((await eventInscriptionService._deleteInscription(inscription.id)) > 0) {
console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion borrada"); console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion borrada");
//Actualizamos confirmados asistentes //En todos los casos en el que se elimine una inscripción hay que refrescar los confirmados de la reserva o del evento
refreshConfirmed(inscription); //en el caso de ser un tutor que ha realizado una reserva y solo está el confirmado, se borra y punto no se actualiza nada
if (inscription.user.profile === "tutor" && inscription.reservation && inscription.reservation.confirmed === 1) { if (inscription.user.profile === "tutor" && inscription.reservation && inscription.reservation.confirmed === 1) {
//Eliminamos la reserva hecha del centro aliado //Eliminamos la reserva hecha del centro aliado
if (!((await eventReservationService._deleteReservation(inscription.reservation.id)) > 0)) if (!((await eventReservationService._deleteReservation(inscription.reservation.id)) > 0))
@ -492,7 +491,11 @@ const extraControllers = {
if (!(await eventService._updateAssistantsEvent(eventOfReservation.id, newAforo))) if (!(await eventService._updateAssistantsEvent(eventOfReservation.id, newAforo)))
return handleResultResponse("No se ha podido actualizar el aforo del evento, para reservar las plazas solicitadas", null, params, res, httpStatus.NOT_FOUND); return handleResultResponse("No se ha podido actualizar el aforo del evento, para reservar las plazas solicitadas", null, params, res, httpStatus.NOT_FOUND);
} }
}; }
else
//En el caso de ser cualquier usuario o un tutor inscrito de forma libre o a una reserva de la que no es titular
//Actualizamos confirmados asistentes
refreshConfirmed(inscription);
} }
else else
return handleResultResponse("No se pudo eliminar inscripción", null, params, res, httpStatus.NOT_FOUND); return handleResultResponse("No se pudo eliminar inscripción", null, params, res, httpStatus.NOT_FOUND);
@ -500,7 +503,7 @@ const extraControllers = {
//Quitamos correo en sendinblue //Quitamos correo en sendinblue
try { try {
marketingListService._deleteMember(marketingListId, inscription.user.email); await marketingListService._deleteMember(marketingListId, inscription.user.email);
} catch (error) { console.log('Se ha producido un error al eliminar de SenINBlue>>>>>>>>>>>>>>>>><<', error); } } catch (error) { console.log('Se ha producido un error al eliminar de SenINBlue>>>>>>>>>>>>>>>>><<', error); }
//Mandamos correo de confirmación de eliminación //Mandamos correo de confirmación de eliminación

12
modules/events/events_reservations.controller.js
View File

@ -35,7 +35,7 @@ async function activeReservation(reservation) {
if (reservation.state === 'publish') if (reservation.state === 'publish')
return reservation; return reservation;
eventService._updateAforoOfEventReservation(reservation, reservation.assistants); await eventService._updateAforoOfEventReservation(reservation, reservation.assistants);
//REvisar confirmados en lista de espera //REvisar confirmados en lista de espera
//Finalmente publicamos la reserva solo si no está asociada a la lista de espera //Finalmente publicamos la reserva solo si no está asociada a la lista de espera
@ -377,7 +377,9 @@ const extraControllers = {
let result = await activeReservationById(idResevation); let result = await activeReservationById(idResevation);
return handleResultResponse(result, null, params, res, httpStatus.OK); return handleResultResponse(result, null, params, res, httpStatus.OK);
} catch (error) { } catch (error) {
return handleResultResponse("Error al buscar las reservas", null, params, res, httpStatus.NOT_FOUND); console.log('********************************************************************************************', error);
//return handleResultResponse("Error al buscar las reservas", null, params, res, httpStatus.NOT_FOUND);
return handleErrorResponse('activarReservation', 'methodName', error.stack, res);
} }
}, },
@ -435,10 +437,10 @@ const extraControllers = {
next(); next();
} catch (error) { } catch (error) {
console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>', error.stack); //console.log('checkAssitantsUpdate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>', error.stack);
return handleResultResponse("Error al checkAssitantsUpdate de la reserva", null, params, res, httpStatus.NOT_FOUND); return handleErrorResponse('controllerName', 'methodName', error.stack, res);
} }
}, },
/////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////
//Esta función se llama desde APP y desde WEB //Esta función se llama desde APP y desde WEB

4
modules/events/events_reservations.service.js
View File

@ -19,10 +19,10 @@ function getWhereTypeEntity(entityType) {
} }
const extraMethods = { const extraMethods = {
beforeCreate(values, context){ async beforeCreate(values, context){
//En el caso de ser una reserva publicada debe descontar del aforo del evento asociado //En el caso de ser una reserva publicada debe descontar del aforo del evento asociado
if (values.state === 'publish') { if (values.state === 'publish') {
eventService._updateAforoOfEventReservation(values, values.assistants); await eventService._updateAforoOfEventReservation(values, values.assistants);
}; };
return values; return values;
}, },