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

server/src/Models/Appointments/Appointments.Interface.ts

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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);
+    });
+});

server/src/api/Appointments/Appointments.Controller.ts

@@ -6,6 +6,8 @@ import {
     AppointmentAdminByDateView,
     CreateAppointmentParams,
     CreateImmediateAppointmentNotificationJobsParams,
+    AppointmentNotificationPreviewParams,
+    AppointmentNotificationPreviewResult,
     DeleteAppointmentParams,
     FindAppointmentsParams,
     FindAppointmentSchedulesParams,
@@ -368,6 +370,27 @@ export class CreateImmediateAppointmentNotificationJobsController extends Contro
     }
 }
 
+@Route("appointments/notification-preview")
+@Middlewares(authenticateMiddleware)
+export class AppointmentNotificationPreviewController extends Controller {
+    @Response<ApiValidationError>(500, "Ha ocurrido un error")
+    @SuccessResponse(200, "Done")
+    @Post()
+    public async getAppointmentNotificationPreview(
+        @Body() requestBody: AppointmentNotificationPreviewParams
+    ): Promise<AppointmentNotificationPreviewResult | ApiValidationError> {
+        try {
+            const preview = await new AppointmentService().getAppointmentNotificationPreview(requestBody);
+            this.setStatus(200);
+            return preview;
+        } catch (e) {
+            const errorOccurred: Error = e as Error; console.error("GET EVENT ERROR:", errorOccurred);
+            this.setStatus(500);
+            return new ApiValidationError(500, errorOccurred.message);
+        }
+    }
+}
+
 @Route("appointments/apply-discount")
 @Middlewares(authenticateMiddleware)
 export class ApplyAppointmentDiscountContrnoller extends Controller {

server/src/api/Appointments/Appointments.Service.ts

@@ -2,6 +2,8 @@ import { TextObjectFilterResult } from "../../Models/TextObjectFilter.model";
 import AppointmentList from "../../Models/Appointments/Appointments";
 import {
     CreateImmediateAppointmentNotificationJobsParams,
+    AppointmentNotificationPreviewParams,
+    AppointmentNotificationPreviewResult,
     AppointmentAdminByClientView,
     AppointmentAdminByDateView,
     CreateAppointmentParams,
@@ -167,6 +169,11 @@ export class AppointmentService {
         await AppointmentList.createImmediateNotificationJobs(data);
     }
 
+    public async getAppointmentNotificationPreview(data: AppointmentNotificationPreviewParams): Promise<AppointmentNotificationPreviewResult> {
+        await connect(`${process.env.DATABASE_CONNECTION}`);
+        return AppointmentList.getAppointmentNotificationPreview(data);
+    }
+
     public async applyDiscount(data: ApplyAppointmentDiscountParams): Promise<void> {
         await connect(`${process.env.DATABASE_CONNECTION}`);
         await AppointmentList.applyDiscount(data);