horacio/turnosxpress
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add appointment notification sharing functionality via WhatsApp, email, and system clipboard

Browse Source
This commit is contained in:
Horacio Daniel Ros
2026-07-29 14:38:13 -03:00
parent 3d8911c093
commit 2a33f636a0
19 changed files with 679 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/src/Models/Appointments/Appointments.Interface.ts
+10
View File
@@ -54,6 +54,15 @@ export type CreateImmediateAppointmentNotificationJobsParams = {
type: APPOINTMENT_NOTIFICATION_TYPE;
};
export type AppointmentNotificationPreviewParams = CreateImmediateAppointmentNotificationJobsParams;
export type AppointmentNotificationPreviewResult = {
subject: string;
message: string;
emailMessage: string;
wapMessage: string;
};
export type MoveAppointmentParams = {
id: string;
companyId: string;
@@ -328,6 +337,7 @@ export interface IAppointmentsManager {
sendWapNotification(data: SendAppointmentNotificationParams): Promise<void>;
sendEmailNotification(data: SendAppointmentNotificationParams): Promise<void>;
createImmediateNotificationJobs(data: CreateImmediateAppointmentNotificationJobsParams): Promise<void>;
getAppointmentNotificationPreview(data: AppointmentNotificationPreviewParams): Promise<AppointmentNotificationPreviewResult>;
sendWapSystemNotification(data: SendWapSystemNotificationParams): Promise<void>;
deleteAppointmentsByCompany(data: DeleteAppointmentsByCompanyParams): Promise<void>;
changeEmployeeToOwner(data: ChangeEmployeeToOwnerParams): Promise<void>;
server/src/Models/Appointments/Appointments.ts
+47
View File
@@ -7,6 +7,7 @@ import {
AppointmentEvent,
AppointmentEventByClient,
AppointmentNotificationIntent,
AppointmentNotificationPreviewResult,
ChangeEmployeeToOwnerParams,
CountAppointmentsByMonthParams,
CreateAppointmentParams,
@@ -2903,6 +2904,52 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
});
}
public async getAppointmentNotificationPreview(data: CreateImmediateAppointmentNotificationJobsParams): Promise<AppointmentNotificationPreviewResult> {
await validateSessionUser({ sessionUser: data.sessionUser });
if (![APPOINTMENT_NOTIFICATION_TYPE.CREATION, APPOINTMENT_NOTIFICATION_TYPE.REMINDER].includes(data.type)) {
throw new Error("El tipo de notificación no es válido para esta acción");
}
const checkAppointment = await this.Appointments.findOne({
_id: data.appointmentId,
});
if (!checkAppointment) {
throw new Error("El turno no existe");
}
await validatePermissionsByCompany({
companyId: String(checkAppointment.companyId),
sessionUser: data.sessionUser,
});
const emailContent = await this.tryToSendNotification({
appointmentId: data.appointmentId,
sessionUser: data.sessionUser,
type: data.type,
channel: "email",
});
const wapContent = await this.tryToSendNotification({
appointmentId: data.appointmentId,
sessionUser: data.sessionUser,
type: data.type,
channel: "whatsapp",
});
const isCreation = data.type === APPOINTMENT_NOTIFICATION_TYPE.CREATION;
const subject = isCreation
? `Turno reservado en ${emailContent.companyCheck.name}`
: `Recordatorio de turno en ${emailContent.companyCheck.name}`;
return {
subject,
message: emailContent.message,
emailMessage: emailContent.message,
wapMessage: wapContent.message,
};
}
public async sendWapNotification(data: SendAppointmentNotificationParams): Promise<void> {
if (!data.sessionUser) {
throw new Error("No se ha encontrado el usuario o no tiene permisos para realizar esta acción");
server/src/Models/NotificationJobs/NotificationJobs.Adapter.Mongoose.ts
+56
View File
@@ -1,11 +1,21 @@
import { Document, Model, Schema, model } from "mongoose";
import {
CreateJobParams,
DeleteOldJobsParams,
DeleteOldJobsResult,
INotificationJob,
INotificationJobAdapter,
NotificationJobStatus,
} from "./NotificationJobs.Interface";
export const NOTIFICATION_JOB_CLEANUP_RETENTION_DAYS = 7;
export const NOTIFICATION_JOB_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
export const NOTIFICATION_JOB_CLEANUP_STATUSES = [
NotificationJobStatus.SENT,
NotificationJobStatus.FAILED,
NotificationJobStatus.CANCELLED,
];
export interface INotificationJobDocument
extends Omit<INotificationJob, "id">,
Document {}
@@ -13,6 +23,7 @@ export interface INotificationJobDocument
export class NotificationJobsAdapterMongoose implements INotificationJobAdapter {
schema: Schema;
notificationJobList: Model<INotificationJobDocument>;
private lastCleanupAt?: number;
constructor() {
this.schema = new Schema(
@@ -73,6 +84,7 @@ export class NotificationJobsAdapterMongoose implements INotificationJobAdapter
}
public async create(data: CreateJobParams): Promise<INotificationJob> {
await this.cleanupOldJobsIfDueSafely();
const doc = await this.notificationJobList.create({
...data,
status: NotificationJobStatus.PENDING,
@@ -111,6 +123,7 @@ export class NotificationJobsAdapterMongoose implements INotificationJobAdapter
}
public async cancelByAppointment(appointmentId: string): Promise<void> {
await this.cleanupOldJobsIfDueSafely();
await this.notificationJobList
.updateMany(
{
@@ -123,9 +136,52 @@ export class NotificationJobsAdapterMongoose implements INotificationJobAdapter
}
public async findByAppointment(appointmentId: string): Promise<INotificationJob[]> {
await this.cleanupOldJobsIfDueSafely();
const docs = await this.notificationJobList
.find({ appointmentId })
.exec();
return docs.map((d) => d.toObject() as INotificationJob);
}
public async deleteOldJobs(
data: DeleteOldJobsParams
): Promise<DeleteOldJobsResult> {
const result = await this.notificationJobList
.deleteMany({
scheduledAt: { $lt: data.scheduledBefore },
status: { $in: data.statuses },
})
.exec();
return { deletedCount: result.deletedCount || 0 };
}
public async cleanupOldJobsIfDue(now = new Date()): Promise<void> {
if (
this.lastCleanupAt !== undefined &&
now.getTime() - this.lastCleanupAt < NOTIFICATION_JOB_CLEANUP_INTERVAL_MS
) {
return;
}
const scheduledBefore = new Date(now.getTime());
scheduledBefore.setDate(
scheduledBefore.getDate() - NOTIFICATION_JOB_CLEANUP_RETENTION_DAYS
);
await this.deleteOldJobs({
scheduledBefore,
statuses: NOTIFICATION_JOB_CLEANUP_STATUSES,
});
this.lastCleanupAt = now.getTime();
}
private async cleanupOldJobsIfDueSafely(): Promise<void> {
try {
await this.cleanupOldJobsIfDue();
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
console.warn(`Notification jobs cleanup failed: ${message}`);
}
}
}
server/src/Models/NotificationJobs/NotificationJobs.Interface.ts
+10
View File
@@ -58,6 +58,15 @@ export interface CreateJobParams {
payload?: NotificationJobPayload;
}
export interface DeleteOldJobsParams {
scheduledBefore: Date;
statuses: NotificationJobStatus[];
}
export interface DeleteOldJobsResult {
deletedCount: number;
}
export interface INotificationJobAdapter {
create(data: CreateJobParams): Promise<INotificationJob>;
findPendingDue(now: Date): Promise<INotificationJob[]>;
@@ -68,4 +77,5 @@ export interface INotificationJobAdapter {
): Promise<void>;
cancelByAppointment(appointmentId: string): Promise<void>;
findByAppointment(appointmentId: string): Promise<INotificationJob[]>;
deleteOldJobs(data: DeleteOldJobsParams): Promise<DeleteOldJobsResult>;
}
server/src/Models/NotificationJobs/__tests__/NotificationJobs.Adapter.Mongoose.test.ts
+89
View File
@@ -0,0 +1,89 @@
import {
NOTIFICATION_JOB_CLEANUP_STATUSES,
NotificationJobsAdapterMongoose,
} from "../NotificationJobs.Adapter.Mongoose";
import { NotificationJobStatus } from "../NotificationJobs.Interface";
describe("NotificationJobsAdapterMongoose cleanup", () => {
const now = new Date("2026-07-21T15:30:00.000Z");
function buildAdapter() {
return Object.create(NotificationJobsAdapterMongoose.prototype) as NotificationJobsAdapterMongoose;
}
it("runs throttled retention cleanup before create on the production adapter path", async () => {
const adapter = buildAdapter();
const deleteOldJobs = jest.fn().mockResolvedValue({ deletedCount: 2 });
const create = jest.fn().mockResolvedValue({ toObject: () => ({ id: "job-1" }) });
(adapter as any).deleteOldJobs = deleteOldJobs;
(adapter as any).notificationJobList = { create };
jest.useFakeTimers().setSystemTime(now);
await adapter.create({
companyId: "company-1",
appointmentId: "appointment-1",
clientId: "client-1",
channel: "email",
type: "creation",
scheduledAt: now,
});
expect(deleteOldJobs).toHaveBeenCalledWith({
scheduledBefore: new Date("2026-07-14T15:30:00.000Z"),
statuses: NOTIFICATION_JOB_CLEANUP_STATUSES,
});
expect(NOTIFICATION_JOB_CLEANUP_STATUSES).toEqual([
NotificationJobStatus.SENT,
NotificationJobStatus.FAILED,
NotificationJobStatus.CANCELLED,
]);
expect(create).toHaveBeenCalledWith(expect.objectContaining({
status: NotificationJobStatus.PENDING,
attempts: 0,
maxAttempts: 3,
}));
});
it("continues creating jobs when production cleanup fails", async () => {
const adapter = buildAdapter();
const deleteOldJobs = jest.fn().mockRejectedValue(new Error("database down"));
const create = jest.fn().mockResolvedValue({ toObject: () => ({ id: "job-1" }) });
const warn = jest.spyOn(console, "warn").mockImplementation(() => undefined);
(adapter as any).deleteOldJobs = deleteOldJobs;
(adapter as any).notificationJobList = { create };
await expect(adapter.create({
companyId: "company-1",
appointmentId: "appointment-1",
clientId: "client-1",
channel: "email",
type: "creation",
scheduledAt: now,
})).resolves.toEqual({ id: "job-1" });
expect(warn).toHaveBeenCalledWith("Notification jobs cleanup failed: database down");
expect(create).toHaveBeenCalledWith(expect.objectContaining({
status: NotificationJobStatus.PENDING,
}));
warn.mockRestore();
});
it("throttles only after cleanup succeeds", async () => {
const adapter = buildAdapter();
const deleteOldJobs = jest
.fn()
.mockRejectedValueOnce(new Error("database down"))
.mockResolvedValueOnce({ deletedCount: 0 })
.mockResolvedValueOnce({ deletedCount: 0 });
(adapter as any).deleteOldJobs = deleteOldJobs;
await expect(adapter.cleanupOldJobsIfDue(now)).rejects.toThrow("database down");
await adapter.cleanupOldJobsIfDue(new Date(now.getTime() + 1000));
await adapter.cleanupOldJobsIfDue(new Date(now.getTime() + 2000));
await adapter.cleanupOldJobsIfDue(new Date(now.getTime() + 60 * 60 * 1000 + 1000));
expect(deleteOldJobs).toHaveBeenCalledTimes(3);
});
});
server/src/Models/NotificationJobs/__tests__/NotificationJobs.test.ts
+87
View File
@@ -0,0 +1,87 @@
import { NotificationJobStatus } from "../NotificationJobs.Interface";
const mockCreate = jest.fn();
const mockCancelByAppointment = jest.fn();
const mockFindByAppointment = jest.fn();
const mockDeleteOldJobs = jest.fn();
jest.mock("../NotificationJobs.Adapter.Mongoose", () => ({
NotificationJobsAdapterMongoose: jest.fn().mockImplementation(() => ({
create: mockCreate,
cancelByAppointment: mockCancelByAppointment,
findByAppointment: mockFindByAppointment,
deleteOldJobs: mockDeleteOldJobs,
})),
}));
describe("NotificationJobManager cleanup", () => {
const loadNotificationJobsList = () => {
jest.isolateModules(() => {
// eslint-disable-next-line @typescript-eslint/no-var-requires
require("../NotificationJobs");
});
// eslint-disable-next-line @typescript-eslint/no-var-requires
return require("../NotificationJobs").default;
};
beforeEach(() => {
jest.resetModules();
jest.clearAllMocks();
jest.useFakeTimers().setSystemTime(new Date("2026-07-29T12:00:00.000Z"));
mockCreate.mockResolvedValue({ id: "job-1" });
mockCancelByAppointment.mockResolvedValue(undefined);
mockFindByAppointment.mockResolvedValue([]);
mockDeleteOldJobs.mockResolvedValue({ deletedCount: 0 });
});
afterEach(() => {
jest.useRealTimers();
});
it("deletes only completed old jobs before creating a job", async () => {
const NotificationJobsList = loadNotificationJobsList();
await NotificationJobsList.createJob({
companyId: "company-1",
appointmentId: "appointment-1",
clientId: "client-1",
channel: "email",
type: "creation",
scheduledAt: new Date("2026-07-29T12:30:00.000Z"),
});
expect(mockDeleteOldJobs).toHaveBeenCalledWith({
scheduledBefore: new Date("2026-07-22T12:00:00.000Z"),
statuses: [
NotificationJobStatus.SENT,
NotificationJobStatus.FAILED,
NotificationJobStatus.CANCELLED,
],
});
expect(mockCreate).toHaveBeenCalledTimes(1);
});
it("throttles cleanup across manager operations", async () => {
const NotificationJobsList = loadNotificationJobsList();
await NotificationJobsList.createJob({
companyId: "company-1",
appointmentId: "appointment-1",
clientId: "client-1",
channel: "email",
type: "creation",
scheduledAt: new Date("2026-07-29T12:30:00.000Z"),
});
await NotificationJobsList.cancelByAppointment("appointment-1");
await NotificationJobsList.findByAppointment("appointment-1");
expect(mockDeleteOldJobs).toHaveBeenCalledTimes(1);
jest.setSystemTime(new Date("2026-07-29T13:00:00.000Z"));
await NotificationJobsList.findByAppointment("appointment-1");
expect(mockDeleteOldJobs).toHaveBeenCalledTimes(2);
});
});