@imj_media/tareas 0.0.7

package/src/functions/taskCalculations.tsx

@@ -0,0 +1,818 @@
+import { normalizeData } from '../api/NormalizeData';
+import { axiosQuery, createItem, deleteItem, updateItem } from '../api/axiosQuery';
+import { equiposToDropdownQuery, plantillaQuery, usersQuery } from '../api/querys';
+
+export const prioridadValues = [
+	['none', 0],
+	['baja', 1],
+	['media', 2],
+	['alta', 3],
+];
+
+export const ROLENEEDSTOSHOWALLPROYECTS = ['PM', 'Operation Manager', 'Administrador'];
+
+export const ESTATUSTASKSTOSTRINGS = {
+	0: 'Por hacer',
+	1: 'Trabajando',
+	2: 'Completadas',
+};
+
+export const ESTATUSTASKSTONUMBERS = {
+	'Por hacer': 0,
+	Trabajando: 1,
+	Completadas: 2,
+};
+
+export const dificultyValues = [
+	{ id: 1, title: 'Muy fácil' },
+	{ id: 2, title: 'Fácil' },
+	{ id: 3, title: 'Normal' },
+	{ id: 4, title: 'Dificil' },
+	{ id: 5, title: 'Muy dificil' },
+];
+
+export const statusValues = [
+	['Por hacer', 0],
+	['Trabajando', 1],
+	['Completadas', 2],
+];
+
+export const plantillaCampaniaValues = [
+	{ id: 0, title: 'Sitios' },
+	{ id: 1, title: 'Rutas' },
+	{ id: 2, title: 'Indoors' },
+	{ id: 3, title: 'Vallas Móviles' },
+	{ id: 4, title: 'Sitios Digitales' },
+	{ id: 5, title: 'Indoors Digitales' },
+];
+
+export const plantillaTiposValues = [
+	{ id: 1, title: 'Preventa' },
+	{ id: 2, title: 'Venta' },
+	{ id: 3, title: 'Postventa' },
+];
+
+export const idsFromCampaniaTask = ['idmedio', 'idruta', 'idindoor', 'idvalla'];
+
+export const rolesAdmin = [22 /** Operation manager */, 5 /** Admin */, 23 /** Super admin */];
+
+export const getPrioridadText = (value: number) => {
+	if (!value) return prioridadValues[0][0];
+	return prioridadValues.find((e) => e[1] === value)[0];
+};
+
+export const getPrioridadNumber = (value: string) => {
+	return prioridadValues.find((e) => e[0] === value)[1];
+};
+
+export const getStatusText = (value: number) => {
+	return statusValues.find((e) => e[1] === value)[0];
+};
+
+export const getStatusNumber = (value: string) => {
+	return statusValues.find((e) => e[0] === value)[1];
+};
+
+export const getStatusOfTask = (tasks) => {
+	let status = 1;
+	let today = new Date();
+	tasks?.forEach((task) => {
+		if (task.estatus !== 2) {
+			let ffin_plus10 = new Date(task.ffin);
+			ffin_plus10.setDate(ffin_plus10.getDate() + 10);
+			if (new Date(task.ffin) < today && status < 2) status = 2;
+			if (ffin_plus10 < today && status < 3) status = 3;
+		}
+	});
+	return status;
+};
+
+export const getStatusTask = (task) => {
+	let status = 1,
+		today = new Date(),
+		ffin_plus = new Date(task?.ffin);
+	ffin_plus.setDate(ffin_plus.getDate() + 10);
+	if (task?.estatus === 2) status = 1;
+	else {
+		if (new Date(task?.ffin) < today && status < 2) status = 2;
+		if (ffin_plus < today && status < 3) status = 3;
+	}
+	return status;
+};
+
+export const getPersentageOfTask = (tareas) => {
+	let completed = 0;
+	let total = tareas?.length ?? 0;
+
+	tareas?.forEach((tarea) => {
+		if (tarea?.estatus === 2) completed++;
+	});
+	return Math.round((completed / total) * 100);
+};
+
+export const getRandId = () => {
+	return Math.floor(Math.random() * (99999 - 10000 + 1)) + 10000;
+};
+
+export const getRandIdTemplates = () => {
+	return Math.floor(Math.random() * (999999 - 100000 + 1)) + 100000;
+};
+
+export const getDataToSubmenu = (
+	menuOptions,
+	titleValue = 'nombre',
+	onClick = (e: any) => {},
+	classNameValue = null
+) => {
+	return [
+		...(menuOptions?.map((option) => {
+			return {
+				id: option.id,
+				title: option[titleValue],
+				onClick: onClick,
+				className: classNameValue,
+			};
+		}) || []),
+		{
+			id: null,
+			title: 'Ninguno',
+			onClick: onClick,
+			className: classNameValue,
+		},
+	];
+};
+
+export const sortByOrden = (array) => {
+	return array.sort((a, b) => a.orden - b.orden);
+};
+
+export const addTaskFromTemplate = (setData, template, fromTask, newElement) => {
+	let today = new Date();
+	let dict = {};
+
+	template?.tarea_plantillas?.forEach((e) => {
+		dict[e.id] = getRandIdTemplates();
+	});
+
+	let newTasksWithId = template?.tarea_plantillas?.map((e) => {
+		return {
+			...e,
+			id: dict[e.id],
+			tarea_padre: dict[e?.tarea_padre?.id] || null,
+		};
+	});
+
+	const getDateWithDuration = (date, duration) => {
+		let newDate = new Date(date);
+		newDate.setDate(newDate.getDate() + duration);
+		return newDate.toISOString().slice(0, 16);
+	};
+
+	setData((prevState) => {
+		const numHermanas = prevState?.tasks?.filter((e) => e.fromTask === fromTask).length || 0;
+
+		let newElements =
+			newTasksWithId?.map((e) => {
+				let extraData = {
+					idTask: e.id,
+					startDate: today.toISOString().slice(0, 16),
+					endDate: getDateWithDuration(today, e.duracion),
+					responsable: e.responsable,
+					supervisor: e.supervisor,
+					recordatorio: e?.recordatorio,
+					texto_corto: e?.texto_corto,
+					texto_largo: e?.texto_largo,
+					dependence: e?.id_t_requerida
+						? {
+								id: dict[e?.id_t_requerida?.id] || null,
+								title: e?.id_t_requerida?.texto_corto,
+								onClick: () => {},
+						  }
+						: null,
+					nivel_dificultad: e?.nivel_dificultad,
+				};
+				let actualOrder = e.orden;
+				if (!e?.tarea_padre) {
+					actualOrder += numHermanas;
+				}
+				return newElement(e?.tarea_padre || fromTask, extraData, actualOrder);
+			}) || [];
+
+		return {
+			...prevState,
+			tasks: prevState?.tasks ? [...prevState.tasks, ...newElements] : [...newElements],
+		};
+	});
+};
+
+export const addTemplateFromTemplate = (setData, template, fromTask, newElement) => {
+	let dict = {};
+
+	template?.tarea_plantillas?.forEach((e) => {
+		dict[e.id] = getRandIdTemplates();
+	});
+
+	let newTasksWithId = template?.tarea_plantillas?.map((e) => {
+		return {
+			...e,
+			id: dict[e.id],
+			tarea_padre: dict[e?.tarea_padre?.id] || null,
+		};
+	});
+
+	setData((prevState) => {
+		const numHermanas =
+			prevState?.tasks?.filter((e) => {
+				let tareaPadre = e?.fromTask ? e?.fromTask : e?.tarea_padre;
+
+				return tareaPadre === fromTask;
+			}).length || 0;
+
+		let newElements =
+			newTasksWithId?.map((e) => {
+				let newTask = newElement(e?.tarea_padre);
+
+				let actualOrder = e?.orden;
+				if (!e?.tarea_padre) {
+					actualOrder += numHermanas;
+				}
+				newTask.idTask = e?.id;
+				newTask.durationValue = e?.duracion;
+				newTask.responsable = e?.responsable;
+				newTask.valueResponsable = e?.responsable?.nombre;
+				newTask.revisionInfo = e?.supervisor;
+				newTask.valueRevision = e?.supervisor?.nombre;
+				newTask.recordatorio = e?.recordatorio;
+				newTask.valueTask = e?.texto_corto;
+				newTask.valueDescription = e?.texto_largo;
+				newTask.dependence = e?.id_t_requerida
+					? {
+							id: dict[e?.id_t_requerida?.id] || null,
+							title: e?.id_t_requerida?.texto_corto,
+							onClick: () => {},
+					  }
+					: null;
+				newTask.nivel_dificultad = e.nivel_dificultad;
+				newTask.orden = actualOrder;
+
+				return { ...e, ...newTask };
+			}) || [];
+
+		let tasks = prevState?.tasks ? prevState.tasks : [];
+		tasks.push(...newElements);
+
+		return {
+			...prevState,
+			tasks,
+		};
+	});
+};
+
+export const getSubtask = (item) => {
+	let subTask = [];
+	const extractSubTask = (tasks) => {
+		if (!tasks?.tareas || tasks?.tareas?.length === 0) return;
+		tasks?.tareas?.forEach((sub) => {
+			subTask.push({
+				...sub,
+				tareas: null,
+			});
+			extractSubTask(sub);
+		});
+	};
+	extractSubTask(item);
+	return subTask;
+};
+
+export const getUsers = async (setUsers) => {
+	const users = await axiosQuery(
+		'GET',
+		'api/users',
+		{
+			...usersQuery,
+		},
+		null
+	);
+
+	users?.data && setUsers(users.data?.filter((user) => !user.blocked));
+};
+
+export const getPlantillas = async (user, setPlantillas) => {
+	const plantillas = await axiosQuery(
+		'GET',
+		'api/plantillas',
+		{
+			...plantillaQuery(user), // Poner el id del usuario
+		},
+		null
+	);
+
+	plantillas?.data && setPlantillas(plantillas.data);
+};
+
+export const getEquipos = async (setEquipos) => {
+	const equipos = await axiosQuery(
+		'GET',
+		'api/equipos',
+		{
+			...equiposToDropdownQuery,
+		},
+		null
+	);
+
+	equipos?.data && setEquipos(equipos.data);
+};
+
+export const getEncargadoDeEquipo = async (id) => {
+	return await axiosQuery(
+		'GET',
+		'api/encargadoequipo',
+		{
+			id,
+		},
+		null
+	).then((res) => {
+		if (res['data']) {
+			return res['data'];
+		} else {
+			console.log(res['error']);
+		}
+	});
+};
+
+export const validatePlantillaProyecto = (data) => {
+	let response = { reason: 'Guardando', isValid: true };
+	if (
+		(!data?.projectName && !data?.nombre_plantilla) ||
+		data?.projectName === '' ||
+		data?.nombre_plantilla === ''
+	)
+		return { reason: 'No se ha asignado nombre.', isValid: false };
+
+	response = validateTasks(data?.tasks);
+	return response;
+};
+
+export const validateTasks = (tasks, isPM = false) => {
+	if (!tasks || tasks?.length === 0)
+		return { reason: 'No hay tareas por guardar', isValid: false };
+
+	let tareasWithoutName = tasks?.filter((e) => !e.valueTask || e.valueTask === '');
+
+	if (tareasWithoutName?.length > 0)
+		return {
+			reason: 'Existen tareas sin nombre',
+			isValid: false,
+		};
+
+	let tareasWithoutResponsable = tasks?.filter(
+		(e) => !e.fromTask && (!e.responsable || !e?.responsable?.id)
+	);
+
+	if (tareasWithoutResponsable?.length > 0 && isPM)
+		return {
+			reason: 'Existen tareas principales sin responsable',
+			isValid: false,
+		};
+
+	return { reason: 'Guardando', isValid: true };
+};
+
+export const validateTeam = (team) => {
+	if (!team?.teamName || team?.teamName === '')
+		return { reason: 'Se necesita agregar nombre al equipo.', isValid: false };
+
+	if (!team?.color || team?.color === '')
+		return {
+			reason: 'Se necesita agregar un color al equipo.',
+			isValid: false,
+		};
+
+	if (!team?.members || team?.members?.length < 2)
+		return {
+			reason: 'Se necesita agregar al menos un encargado y un integrante al equipo.',
+			isValid: false,
+		};
+
+	return { reason: 'Guardando', isValid: true };
+};
+
+export const validateTasksWithoutResponsable = (tasks) => {
+	if (!tasks || tasks?.length === 0)
+		return { reason: 'No hay tareas por guardar', isValid: false };
+
+	let tareasWithoutName = tasks?.filter((e) => !e.valueTask || e.valueTask === '');
+
+	if (tareasWithoutName?.length > 0)
+		return {
+			reason: 'Existen tareas sin nombre',
+			isValid: false,
+		};
+
+	return { reason: 'Guardando', isValid: true };
+};
+
+export const getTareasPadre = (idTask, tasks) => {
+	let tareasPadre = [];
+	let tareaActual = idTask;
+
+	while (tareaActual) {
+		let tarea = tasks?.find((t) => t.idTask === tareaActual);
+		if (tarea) {
+			tareasPadre.push(tarea.idTask);
+			tareaActual = tarea?.fromTask;
+		} else {
+			tareaActual = null;
+		}
+	}
+
+	return tareasPadre.filter((e) => e !== idTask);
+};
+
+export const getTareasHijas = (idTask, tasks) => {
+	let tareasHijas = [];
+	let aux = tasks?.filter((t) => t.fromTask === idTask).map((t) => t.idTask);
+	tareasHijas = [...aux];
+	aux.forEach((id) => {
+		tareasHijas = [...getTareasHijas(id, tasks), ...tareasHijas];
+	});
+	return tareasHijas;
+};
+
+export const getTareasHermanas = (idTask, tasks) => {
+	let tareaActual = tasks?.find((t) => t.idTask === idTask);
+	let tareasHermanas = tasks?.filter((t) => t.fromTask === tareaActual.fromTask);
+	return tareasHermanas;
+};
+
+export const getTareasWithEstatus = (idTask, estatus, tasks) => {
+	let newTasks = tasks?.length > 0 ?
+		[
+			...tasks?.map((t) => {
+				if (t.idTask === idTask) {
+					t.estatus = estatus;
+					t.check = estatus === 2;
+				}
+				return t;
+			}),
+		] : [];
+	let tareasHijas = getTareasHijas(idTask, tasks);
+	let tareasPadres = getTareasPadre(idTask, tasks);
+
+	if (estatus === 2) {
+		if (tareasHijas.length > 0) {
+			newTasks = newTasks.map((t) => {
+				if (tareasHijas.includes(t.idTask)) {
+					t.estatus = 2;
+					t.check = true;
+				}
+				return t;
+			});
+		}
+		if (tareasPadres.length > 0) {
+			tareasPadres.forEach((id) => {
+				let tareasDePadre = newTasks.filter((t) => t.fromTask === id);
+				if (tareasDePadre.every((t) => t.estatus === 2)) {
+					newTasks = newTasks.map((t) => {
+						if (t.idTask === id) {
+							t.estatus = 2;
+							t.check = true;
+						}
+						return t;
+					});
+				}
+			});
+		}
+	} else if (estatus === 0) {
+		if (tareasHijas.length > 0) {
+			newTasks = newTasks.map((t) => {
+				if (tareasHijas.includes(t.idTask)) {
+					t.estatus = 0;
+					t.check = false;
+				}
+				return t;
+			});
+		}
+		if (tareasPadres.length > 0) {
+			newTasks = newTasks.map((t) => {
+				if (tareasPadres.includes(t.idTask) && t.estatus === 2) {
+					t.estatus = 0;
+					t.check = false;
+				}
+				return t;
+			});
+		}
+	}
+	return newTasks;
+};
+
+export const saveTasks = (tasks, onFinishSaved, user, firstFather = null) => {
+	let saved = [];
+	let isEditingChilds = firstFather ? true : false;
+
+	const saveTaskFrom = (fatherID) => {
+		let tasksToSave = tasks.filter((e) =>
+			isEditingChilds
+				? (e.fromTask || e?.tarea_padre) === fatherID
+				: ((e.fromTask || e?.tarea_padre) === fatherID && !e?.id_t_requerida) ||
+				  (e?.id_t_requerida === fatherID && fatherID)
+		);
+		if (tasksToSave?.length === 0) {
+			return;
+		}
+		tasksToSave.forEach((task) => {
+			let tareaPadre = task?.fromTask ? task?.fromTask : task?.tarea_padre;
+			let dataToSave = {
+				...task,
+				tarea_padre: isEditingChilds
+					? firstFather
+					: saved.find((e) => e?.idTask === tareaPadre)?.idDB ?? null,
+				id_t_requerida: task?.id_t_requerida ?? null,
+				responsable: task?.responsable ? task.responsable : task?.equipo ? null : user?.id,
+				equipo: task?.equipo ?? null,
+				updated_by: user?.id,
+				es_pausable: task?.es_pausable ?? false,
+				supervisor: task?.supervisor ?? null,
+			};
+
+			if (!task?.idDB) {
+				dataToSave.created_by = user?.id;
+			}
+
+			isEditingChilds = false;
+
+			if (task?.idDB) {
+				updateItem(
+					'api/tareas',
+					task?.idDB,
+					{
+						...dataToSave,
+						idTask: null, //! Puede eliminarse
+					},
+					async (e) => {
+						saved.push(task);
+						if (saved.length === tasks.length) {
+							onFinishSaved(saved);
+							return;
+						}
+						saveTaskFrom(task.idTask);
+					},
+					(error) => {
+						console.log('Error al actualizar la tarea: ', error, task?.idTask);
+					}
+				);
+			} else {
+				createItem(
+					'api/tareas',
+					{
+						...dataToSave,
+						idTask: null, //! Puede eliminarse
+					},
+					async (e) => {
+						task.idDB = e.id;
+						saved.push(task);
+						if (saved.length === tasks.length) {
+							onFinishSaved(saved);
+							return;
+						}
+						saveTaskFrom(task.idTask);
+					},
+					(error) => {
+						console.log('Error al crear la tarea: ', error);
+					}
+				);
+			}
+		});
+	};
+
+	saveTaskFrom(firstFather);
+};
+
+export const deleteTasks = async (tasks, setLoadingOverlay = null, setRefresh = null) => {
+	if (setLoadingOverlay) setLoadingOverlay(true);
+	for (const task of tasks) {
+		if (task.idindoor || task.idmedio || task.idruta || task.tipo_tarea) {
+			await updateItem(
+				'api/tareas',
+				task.id,
+				{
+					cancelada: true,
+				},
+				async () => {
+					console.log('Tarea eliminada');
+				},
+				(error) => {
+					console.log('Error al eliminar tarea', error);
+				}
+			);
+		} else {
+			await deleteItem(
+				'api/tareas',
+				task.id,
+				async () => {
+					console.log('Tarea eliminada');
+				},
+				(error) => {
+					console.log('Error al eliminar tarea', error);
+				}
+			);
+		}
+	}
+	if (setLoadingOverlay) setLoadingOverlay(false);
+	if (setRefresh) setRefresh(true);
+};
+
+export const deleteProject = async (project, setLoadingOverlay = null, setRefresh = null) => {
+	if (setLoadingOverlay) setLoadingOverlay(true);
+
+	if (project.responsable || project.comercial || project.linkkey) {
+		await updateItem(
+			'api/proyectos',
+			project.id,
+			{
+				cancelada: true,
+			},
+			async () => {
+				console.log('Proyecto eliminada');
+			},
+			(error) => {
+				console.log('Error al eliminar proyecto', error);
+			}
+		);
+	} else {
+		await deleteItem(
+			'api/proyectos',
+			project.id,
+			async () => {
+				console.log('Proyecto eliminada');
+			},
+			(error) => {
+				console.log('Error al eliminar proyecto', error);
+			}
+		);
+	}
+
+	if (setLoadingOverlay) setLoadingOverlay(false);
+	if (setRefresh) setRefresh(true);
+};
+
+export const getTaskToShow = (tasks, onHandleChangeTask, isPlantilla = false) => {
+	if (isPlantilla) {
+		return (
+			tasks?.map((e) => {
+				return {
+					...e,
+					dependenciesOptions: getTareasHermanas(e.idTask, tasks)
+						?.filter((task) => task.idTask !== e.idTask)
+						?.filter((task) => task?.dependence?.id !== e.idTask)
+						.map((task) => ({
+							id: task.idTask,
+							title: task.valueTask,
+							onClick: () =>
+								onHandleChangeTask(e.idTask, 'dependence', {
+									id: task.idTask,
+									title: task.valueTask,
+									onClick: () => {},
+								}),
+						}))
+						.concat({
+							id: null,
+							title: 'Sin dependencia',
+							onClick: () => onHandleChangeTask(e.idTask, 'dependence', null),
+						}),
+				};
+			}) || []
+		);
+	}
+	return (
+		tasks?.map((e) => {
+			let tareaPadre = tasks?.find((t) => t.idTask === e.fromTask) || null;
+			let dificultadVal =
+				dificultyValues?.find((dif) => dif.id === e.nivel_dificultad) || dificultyValues[0];
+			return {
+				...e,
+				maxEndDate: tareaPadre?.endDateValue || null,
+				maxStartDate: tareaPadre?.endDateValue || null,
+				minEndDate: tareaPadre?.startDateValue || null,
+				minStartDate: tareaPadre?.startDateValue || null,
+				pausable: tareaPadre?.pausable || false,
+				dependenciesOptions: getTareasHermanas(e.idTask, tasks)
+					?.filter((task) => task.idTask !== e.idTask)
+					?.filter((task) => task?.dependence?.id !== e.idTask)
+					.map((task) => ({
+						id: task.idTask,
+						title: task.valueTask,
+						onClick: () =>
+							onHandleChangeTask(e.idTask, 'dependence', {
+								id: task.idTask,
+								title: task.valueTask,
+								onClick: () => {},
+							}),
+					}))
+					.concat({
+						id: null,
+						title: 'Sin dependencia',
+						onClick: () => onHandleChangeTask(e.idTask, 'dependence', null),
+					}),
+				valueDificultad: { ...dificultadVal, id: dificultadVal.id.toString() },
+				onCh_dificultad: (dif) => {
+					onHandleChangeTask(e.idTask, 'nivel_dificultad', Number(dif.target.id));
+				},
+			};
+		}) || []
+	);
+};
+
+export const getOrdenGrafica = (tasks) => {
+	let ordenGrafica = [];
+
+	const getOrden = (tareasAAcomodar) => {
+		tareasAAcomodar.forEach((task) => {
+			ordenGrafica.push(task);
+			let subTasks = tasks.filter((e) => e?.tarea_padre?.id === task.id);
+			if (subTasks.length > 0) {
+				getOrden(subTasks);
+			}
+		});
+	};
+
+	getOrden(tasks.filter((e) => !e.tarea_padre));
+	return ordenGrafica;
+};
+
+export function incrementarBrillo(color, incremento) {
+	// Parseamos el color a valores RGB
+	const r = parseInt(color.substr(1, 2), 16);
+	const g = parseInt(color.substr(3, 2), 16);
+	const b = parseInt(color.substr(5, 2), 16);
+
+	// Incrementamos el brillo
+	const incrementoR = Math.round(r + incremento * 255);
+	const incrementoG = Math.round(g + incremento * 255);
+	const incrementoB = Math.round(b + incremento * 255);
+
+	// Limitamos los valores a 0-255
+	const brilloR = Math.min(255, Math.max(0, incrementoR));
+	const brilloG = Math.min(255, Math.max(0, incrementoG));
+	const brilloB = Math.min(255, Math.max(0, incrementoB));
+
+	// Convertimos los valores a hexadecimal
+	const nuevoColor = `#${componenteHexadecimal(brilloR)}${componenteHexadecimal(
+		brilloG
+	)}${componenteHexadecimal(brilloB)}`;
+
+	return nuevoColor;
+}
+
+function componenteHexadecimal(componente) {
+	const hex = componente.toString(16);
+	return hex.length === 1 ? `0${hex}` : hex;
+}
+
+export function seguirTarea(idTarea, user, setLoading, onSucces, onError) {
+	setLoading(true);
+	axiosQuery(
+		'GET',
+		'api/notificaciones',
+		{ filters: { tarea: idTarea, user: user.id } },
+		null
+	).then(async (res) => {
+		if (res['data']) {
+			let response = normalizeData(res['data']);
+			if (response?.length > 0) {
+				await deleteSeguimientoTarea(response[0].id, onError, onError);
+			} else {
+				await createItem(
+					'api/notificaciones',
+					{ tarea: idTarea, user: user.id },
+					async () => {
+						console.log('Notificación creada');
+						onSucces('Notificación creada');
+					},
+					(error) => {
+						console.log('Error al crear la notificación: ', error);
+						onError('Error al crear la notificación');
+					}
+				);
+			}
+		} else {
+			console.log(res['error']);
+		}
+		setLoading(false);
+	});
+}
+
+export const deleteSeguimientoTarea = async (idNotificacion, onSucces, onError) => {
+	await deleteItem(
+		'api/notificaciones',
+		idNotificacion,
+		async () => {
+			console.log('Notificación eliminada');
+			onSucces('Notificación eliminada');
+		},
+		() => {
+			console.log('Error al eliminar la notificación');
+			onError('Error al eliminar la notificación');
+		}
+	);
+};