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 httpStatus = require('http-status');
const { extractParamsFromRequest, handleErrorResponse, handleResultResponse } = require('../../helpers/controller.helper');
const _find = require("./find");
const httpStatus = require("http-status");
const {
extractParamsFromRequest,
handleErrorResponse,
handleResultResponse,
} = require("../../helpers/controller.helper");
function buildContext(req, config) {
return {
user: req.user,
scopes: [],
...config,
}
return {
user: req.user,
scopes: [],
...config,
};
}
const defaultOptions = {
MODULE_NAME: 'default',
params: {
find: { includeAll: false },
findOne: { includeAll: false, paginate: { limit: 1, page: 1 } },
count: {},
create: {},
update: {},
delete: {},
}
}
MODULE_NAME: "default",
params: {
find: { includeAll: false },
findOne: { includeAll: false, paginate: { limit: 1, page: 1 } },
count: {},
create: {},
update: {},
delete: {},
},
};
const generateControllers = (service, extraControllers = {}, options = {}) => {
const _options = {
...defaultOptions,
...options
};
const _options = {
...defaultOptions,
...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) => {
config = config || {
scopes: [],
};
findOne: (config) => {
return async (req, res, next) => {
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);
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)
}
}
},
count: (config) => {
return async (req, res, next) => {
const params = extractParamsFromRequest(req, res, _options.params.count);
try {
const result = await service.count(params, buildContext(req, config));
return handleResultResponse(result, null, params, res);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, "count", error, res);
}
};
},
findOne: (config) => {
return async (req, res, next) => {
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)
}
}
},
create: (config) => {
return async (req, res, next) => {
const params = extractParamsFromRequest(req, res, _options.params.count);
try {
//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);
}
};
},
count: (config) => {
return async (req, res, next) => {
const params = extractParamsFromRequest(req, res, _options.params.count);
try {
const result = await service.count(params, buildContext(req, config));
return handleResultResponse(result, null, params, res);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, 'count', error, res)
}
}
},
update: (config) => {
return async (req, res, next) => {
try {
const params = extractParamsFromRequest(req, res, _options.params.update);
console.log("SERVICE UPDATE ->", params, req.body);
create: (config) => {
return async (req, res, next) => {
const params = extractParamsFromRequest(req, res, _options.params.count);
try {
//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)
}
};
},
const response = await service.update(params, req.body, buildContext(req, config));
// https://sequelize.org/master/class/lib/model.js~Model.html#static-method-update
// Update devuelve un array de un elemento con el número de filas afectadas
// por la operación. Por comodidad, devuelvo el valor, no el array.
update: (config) => {
return async (req, res, next) => {
try {
const params = extractParamsFromRequest(req, res, _options.params.update);
console.log('SERVICE UPDATE ->', params, req.body);
let result = response[0];
let status = httpStatus.OK;
if (result < 1) {
status = httpStatus.NOT_FOUND;
}
const response = await service.update(params, req.body, buildContext(req, config));
// https://sequelize.org/master/class/lib/model.js~Model.html#static-method-update
// Update devuelve un array de un elemento con el número de filas afectadas
// por la operación. Por comodidad, devuelvo el valor, no el array.
// Express no puede devolver números porque los confunde con el 'status'.
// Convertimos a cadena.
result = result.toString();
let result = response[0];
let status = httpStatus.OK;
if (result < 1) {
status = httpStatus.NOT_FOUND;
}
return handleResultResponse(result, null, req.params, res, status);
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, "update", error, res);
}
};
},
// Express no puede devolver números porque los confunde con el 'status'.
// Convertimos a cadena.
result = result.toString();
delete: (config) => {
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);
}
};
},
};
return handleResultResponse(result, null, req.params, res, status)
} catch (error) {
return handleErrorResponse(_options.MODULE_NAME, 'update', error, res)
}
}
},
//const associationControllers = generateAssociationControllers(model, options);
delete: (config) => {
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
}
}
//console.log(associationControllers);
return {
...defaultControllers,
//...associationControllers
...extraControllers,
};
};
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) => {
if (extraMethods.beforeCreate) {
values = extraMethods.beforeCreate(values, context);
values = await extraMethods.beforeCreate(values, context);
}
var result = await model.scope(context.scopes).create(values);
if (extraMethods.afterCreate) {

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

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

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

@ -34,7 +34,7 @@ async function refreshConfirmed(inscription) {
? inscription.overflowEventId
: inscription.eventId;
let NewConfirmed = 0;
let NewConfirmed = 0;
//Si la inscripción viene por una reserva modificamos los confirmados de la reserva
if (inscription.reservationId != null) {
@ -460,7 +460,7 @@ const extraControllers = {
try {
const inscription = await eventInscriptionService._getInscriptionById(inscriptionId);
console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion a borrar:");
console.log(inscription);
console.log(inscription.id);
//Solo se tiene en cuenta el marketinglist del evento
marketingListId = inscription.event.marketing_list;
@ -477,9 +477,8 @@ const extraControllers = {
if ((await eventInscriptionService._deleteInscription(inscription.id)) > 0) {
console.log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>><Inscripcion borrada");
//Actualizamos confirmados asistentes
refreshConfirmed(inscription);
//En todos los casos en el que se elimine una inscripción hay que refrescar los confirmados de la reserva o del evento
//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) {
//Eliminamos la reserva hecha del centro aliado
if (!((await eventReservationService._deleteReservation(inscription.reservation.id)) > 0))
@ -492,7 +491,11 @@ const extraControllers = {
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);
}
};
}
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
return handleResultResponse("No se pudo eliminar inscripción", null, params, res, httpStatus.NOT_FOUND);
@ -500,7 +503,7 @@ const extraControllers = {
//Quitamos correo en sendinblue
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); }
//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')
return reservation;
eventService._updateAforoOfEventReservation(reservation, reservation.assistants);
await eventService._updateAforoOfEventReservation(reservation, reservation.assistants);
//REvisar confirmados en 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);
return handleResultResponse(result, null, params, res, httpStatus.OK);
} 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();
} catch (error) {
console.log('>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>', error.stack);
return handleResultResponse("Error al checkAssitantsUpdate de la reserva", null, params, res, httpStatus.NOT_FOUND);
//console.log('checkAssitantsUpdate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>', error.stack);
return handleErrorResponse('controllerName', 'methodName', error.stack, res);
}
},
},
///////////////////////////////////////////////////////////////////
//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 = {
beforeCreate(values, context){
async beforeCreate(values, context){
//En el caso de ser una reserva publicada debe descontar del aforo del evento asociado
if (values.state === 'publish') {
eventService._updateAforoOfEventReservation(values, values.assistants);
await eventService._updateAforoOfEventReservation(values, values.assistants);
};
return values;
},