feat: agregar funcionalidad de edición de cabecera y colores en OrganizationHeaderEdit

- Dialog centrado (no bottom-sheet) con ThemeProvider
- Botones Cancelar/Guardar en texto plano (sin iconos), mismo patrón que Confirm.tsx
- Recibe valores actuales por props para no depender de store global
- Titulo dice 'Personalizar' solamente
- Cierre se hace con icono X en el title bar

.gitignore

@@ -24,6 +24,16 @@ server/*.local
 server/build
 # server/uploads
 
+# txadmin Electron app
+txadmin/node_modules
+txadmin/dist
+txadmin/dist-electron
+txadmin/release
+txadmin/release-portable
+txadmin/*.local
+txadmin/*.tsbuildinfo
+txadmin/node_modules/.tmp
+
 # Editor directories and files
 .vscode/*
 !.vscode/extensions.json

.opencode/skills/engram-cloud-sync/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: engram-cloud-sync
+description: "Trigger: sync engram cloud, sincronizar memoria, push engram, engram cloud sync. Synchronize local Engram project to remote cloud server."
+license: Apache-2.0
+metadata:
+  author: "horacio"
+  version: "1.0"
+---
+
+## Activation Contract
+
+Load this skill whenever the user explicitly asks to synchronize, push, or sync their Engram memory with the cloud.
+
+## Hard Rules
+
+- **Never skip the sync** when requested. Execute `engram sync --cloud --project turnosxpress` every time.
+- **Always verify** the cloud server is reachable and the project is enrolled before syncing.
+- **Report results to the user**: sessions, observations, prompts, mutations exported.
+- **Fail fast** on 403/forbidden errors — that means the project needs enrollment first.
+
+## Execution Steps
+
+1. **Check cloud status:** `engram cloud status --cwd <repo>` (default: current project directory). If `Auth status: ready` and `Sync readiness: pending`, continue.
+2. **If project is not enrolled** (`403: forbidden: project is not allowed` or similar), run `engram cloud enroll turnosxpress --cwd <repo>` then re-check status.
+3. **Execute sync:** `engram sync --cloud --project turnosxpress --cwd <repo>`.
+4. **Report results** — sessions, observations, prompts, mutations count. If sync fails, surface the exact error and suggest running `engram serve` for autosync mode.
+
+## Output Contract
+
+Return:
+- Cloud server URL and enrollment status.
+- Export counts: sessions, observations, prompts, mutations.
+- Confirmation: "Cloud sync complete" or actionable error if it failed.

.opencode/skills/tx-admin-endpoint/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: tx-admin-endpoint
+description: "Trigger: crear colección, nueva colección, crear endpoint, nuevo endpoint, Models, api, turnosxpress admin. Reglas para crear colecciones y endpoints del backend admin de turnosxpress."
+license: Apache-2.0
+metadata:
+  author: gentleman-programming
+  version: "1.0"
+---
+
+## Activation Contract
+
+Load this skill when creating a new collection or a new endpoint in the `server` backend of the turnosxpress admin (the API consumed by admins/employees, not the public client app). Applies to both the data layer (`server/src/Models`) and the HTTP layer (`server/src/api`). Example to imitate: `Clients`, `Posts`, `SchedulesDisabled`.
+
+## Hard Rules
+
+- Use the ACTUAL paths: collections live in `server/src/Models/<Name>/`, endpoints in `server/src/api/<Name>/`. The folder name is the collection name (e.g. `Clients`, `Posts`).
+- A collection is ALWAYS exactly 3 files with separated responsibilities (never collapse them):
+
+| File | Owns | Forbidden here |
+|------|------|-----------------|
+| `<Name>.Interface.ts` | All TS types: `*Params` (Create/Update/Delete/Find), `IX`, `IXDocument` re-export, `IXAdapter`, `IXManager`, view/result types. | No Mongoose, no business logic. |
+| `<Name>.Adapter.Mongoose.ts` | Mongoose ONLY: `Schema`, `IXDocument extends IX & Document`, `model()`, and pure DB ops (`create`, `delete`, `find`, `findOne`, `paginate`). Implements `IXAdapter`. | No business rules, NO security checks. |
+| `<Name>.ts` | Business rules AND security. A `<Name>Manager implements IXManager` class that instantiates the adapter in the constructor; exported as a singleton (`const XList = new ...Manager(); export default XList;`). | No Schema, no `model()`. |
+
+- SECURITY STANDARD (mandatory, even though `Clients.ts` inlines it — that is legacy): use the shared helpers from `server/src/helpers/check.ts`:
+  - `validateSessionUser({ sessionUser })` — confirm the session user exists. Call FIRST in any method that receives `sessionUser`.
+  - `validatePermissionsByCompany({ companyId, sessionUser })` — confirm the company exists AND the session user has ADMIN role. Call whenever a `companyId` is involved.
+  - Modern reference: `server/src/Models/Posts/Posts.ts`, `server/src/Models/SchedulesDisabled/SchedulesDisabled.ts`.
+  - Role checks beyond ADMIN (EMPLOYEE, etc.) go through `EmployeesList.checkPermission` / `checkRoleById`.
+- An endpoint is ALWAYS 2 files:
+  - `<Name>.Controller.ts` — tsoa decorators. One controller class per `@Route("resource/action")`. Each handler `@Post()`, takes `@Body()`, sets status, wraps in try/catch and returns `new ApiValidationError(500, message)` on error. Import `ApiValidationError` from `../../Models/Server.Error.model`.
+  - `<Name>.Service.ts` — thin: each method `await connect(process.env.DATABASE_CONNECTION)` then delegates to the manager singleton. No business logic here.
+- `authenticationMiddleware` (from `server/src/middleware/authentication.ts`) MUST be applied with `@Middlewares(authenticateMiddleware)` on EVERY controller, UNLESS the endpoint is intentionally public. Never omit it without explicit confirmation (see Ask Before Building).
+- 99% of endpoints use `@Post()`. Default to POST; use GET/other only with a concrete, justified reason.
+- After adding/changing controllers, regenerate the tsoa routes/spec: `npm run routes` (binds `tsoa spec-and-routes`); compile with `npm run build`.
+
+## Decision Gates
+
+| Situation | Decision |
+|-----------|----------|
+| Does the method take `sessionUser`? | Call `validateSessionUser` first. |
+| Does the method act on a `companyId`? | Then `validatePermissionsByCompany`. |
+| Endpoint exposed in the admin backend? | Default: `@Middlewares(authenticateMiddleware)`. |
+| Endpoint hits WhatsApp notification / public recovery / ratings or another abuse-prone path? | Consider `rateLimiter` (or `ratingRateLimiter`) from `server/src/middleware/ratelimiter.ts`. When both apply: `@Middlewares([rateLimiter, authenticateMiddleware])`. |
+| Internal/system-only endpoint? | Use `systemTokenMiddleware` instead of/with the above. |
+| Doubt about middleware, role, or method? | STOP and ask. See Ask Before Building. |
+
+## Ask Before Building (HARD — security first)
+
+STOP and ask the user BEFORE writing security or middleware code whenever there is ANY doubt. Never guess on these:
+
+1. Which validations/roles/plan features the new method requires (ADMIN vs EMPLOYEE vs extra feature gates).
+2. Whether the endpoint should be public (no `authenticateMiddleware`) or authenticated. A missing auth middleware is a security hole — when unsure, default to KEEPING `authenticateMiddleware` and confirm.
+3. Whether `rateLimiter` should be applied to a given endpoint. Do NOT add it by default; ask when the endpoint could be abuse-prone.
+4. Whether a non-POST method is genuinely needed.
+
+Ask at most a couple of focused questions, then wait. Do not proceed by assumption on security.
+
+## Execution Steps
+
+Creating a collection:
+
+1. Create `server/src/Models/<Name>/<Name>.Interface.ts` — define all params, `IX`, `IXAdapter`, `IXManager`, view/result types.
+2. Create `server/src/Models/<Name>/<Name>.Adapter.Mongoose.ts` — schema, `IXDocument`, `model()`, pure DB ops implementing `IXAdapter`.
+3. Create `server/src/Models/<Name>/<Name>.ts` — `<Name>Manager implements IXManager`; instantiate the adapter in the constructor; put business rules; call `validateSessionUser` / `validatePermissionsByCompany` at the top of each secured method; export a singleton default.
+4. Re-check Ask Before Building for any unconfirmed security requirement.
+
+Creating an endpoint:
+
+1. Create `server/src/api/<Name>/<Name>.Service.ts` — one method per action, `connect(process.env.DATABASE_CONNECTION)` then delegate to the manager singleton.
+2. Create `server/src/api/<Name>/<Name>.Controller.ts` — one controller class per `@Route`; `@Middlewares(authenticateMiddleware)` unless confirmed public; `@Post()` + `@Body()`; try/catch returning `ApiValidationError`.
+3. Apply Decision Gates (rateLimiter? system token? method?).
+4. Regenerate routes: `npm run routes` then `npm run build`.
+
+## Output Contract
+
+Return: files created, the singletons/middlewares wired, any security decision that was confirmed with the user, and whether `npm run routes` / `npm run build` were run.
+
+## References
+
+- `server/src/Models/Clients/Clients.ts`, `Clients.Interface.ts`, `Clients.Adapter.Mongoose.ts` — canonical 3-file collection example (note: Clients inlines security; do NOT copy that part).
+- `server/src/Models/Posts/Posts.ts` — modern security pattern using the shared helpers.
+- `server/src/helpers/check.ts` — `validateSessionUser`, `validatePermissionsByCompany`, `validatePermissionsByClient`.
+- `server/src/api/Clients/Clients.Controller.ts`, `Clients.Service.ts` — endpoint pattern (Controller + Service).
+- `server/src/middleware/authentication.ts`, `server/src/middleware/ratelimiter.ts` — middleware sources.
+- `server/tsoa.json`, `server/package.json` (`npm run routes`) — route generation.

bot-admin-api/.env

@@ -1,4 +1,4 @@
-DATABASE_CONNECTION = mongodb://horacio:frx8us2w@192.168.1.50:20215/turnosxpress
+DATABASE_CONNECTION = mongodb://horacio:frx8us2w@localhost:20215/turnosxpress
 DATABASE_CONNECTION_ATLAS = mongodb+srv://horacio:frx8us2w@reservar.a2cgd.mongodb.net/reservar
 DATABASE_CONNECTION_LOCAL = mongodb://horacio:frx8us2w@192.168.1.50:20215/turnosxpress
 

com.hdrdevs.turnosxpress/app/src/main/java/com/hdrdevs/turnosxpress/MainActivity.java

@@ -1,9 +1,17 @@
 package com.hdrdevs.turnosxpress;
 
 import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
 
+import android.Manifest;
 import android.os.Bundle;
+import android.os.Build;
+import android.os.Message;
+import android.content.ActivityNotFoundException;
 import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.media.MediaScannerConnection;
 import android.net.Uri;
 import android.util.Log;
 import android.view.KeyEvent;
@@ -31,6 +39,7 @@ import android.content.ContentResolver;
 public class MainActivity extends AppCompatActivity {
 
     private static final int LOGIN_REQUEST_CODE = 1;
+    private static final int STORAGE_PERMISSION_REQUEST_CODE = 2;
     private WebView webView;
     private ValueCallback<Uri[]> fileChooserCallback;
 
@@ -41,6 +50,7 @@ public class MainActivity extends AppCompatActivity {
         super.onCreate(savedInstanceState);
 
         tokenResult = "";
+        requestLegacyStoragePermissionIfNeeded();
 
         // For Android Emulator, use 10.0.2.2 to access localhost on your development machine.
         // If testing on a physical device, replace 10.0.2.2 with your development machine's actual local IP address.
@@ -70,11 +80,10 @@ public class MainActivity extends AppCompatActivity {
         webView.setWebViewClient(new WebViewClient() {
             @Override
             public boolean shouldOverrideUrlLoading(WebView vw, WebResourceRequest request) {
-                if (request.getUrl().toString().contains(home.getHost())) {
+                if (shouldLoadInsideApp(request.getUrl(), home)) {
                     vw.loadUrl(request.getUrl().toString());
                 } else {
-                    Intent intent = new Intent(Intent.ACTION_VIEW, request.getUrl());
+                    openExternalUri(request.getUrl());
-                    vw.getContext().startActivity(intent);
                 }
 
                 return true;
@@ -95,7 +104,7 @@ public class MainActivity extends AppCompatActivity {
 
             @Override
             public boolean onShowFileChooser(WebView vw, ValueCallback<Uri[]> filePathCallback,
-                                             FileChooserParams fileChooserParams) {
+                                              FileChooserParams fileChooserParams) {
                 if (fileChooserCallback != null) {
                     fileChooserCallback.onReceiveValue(null);
                 }
@@ -112,6 +121,25 @@ public class MainActivity extends AppCompatActivity {
                 return true;
             }
 
+            @Override
+            public boolean onCreateWindow(WebView view, boolean isDialog, boolean isUserGesture, Message resultMsg) {
+                WebView popupWebView = new WebView(MainActivity.this);
+                popupWebView.setWebViewClient(new WebViewClient() {
+                    @Override
+                    public boolean shouldOverrideUrlLoading(WebView popupView, WebResourceRequest request) {
+                        openExternalUri(request.getUrl());
+                        popupWebView.destroy();
+                        return true;
+                    }
+                });
+
+                WebView.WebViewTransport transport = (WebView.WebViewTransport) resultMsg.obj;
+                transport.setWebView(popupWebView);
+                resultMsg.sendToTarget();
+
+                return true;
+            }
+
 
         });
         webView.setOnKeyListener((v, keyCode, event) ->
@@ -163,13 +191,65 @@ public class MainActivity extends AppCompatActivity {
 
     private void handleURI(String uri) {
         if (uri != null) {
-            Intent i = new Intent(Intent.ACTION_VIEW);
+            openExternalUri(Uri.parse(uri.replaceFirst("^blob:", "")));
-            i.setData(Uri.parse(uri.replaceFirst("^blob:", "")));
-
-            startActivity(i);
         }
     }
 
+    private boolean shouldLoadInsideApp(Uri uri, Uri home) {
+        return uri != null
+                && uri.getHost() != null
+                && uri.getHost().equals(home.getHost())
+                && ("http".equals(uri.getScheme()) || "https".equals(uri.getScheme()));
+    }
+
+    private void openExternalUri(Uri uri) {
+        if (uri == null) {
+            return;
+        }
+
+        try {
+            Intent intent;
+
+            if ("intent".equals(uri.getScheme())) {
+                intent = Intent.parseUri(uri.toString(), Intent.URI_INTENT_SCHEME);
+                intent.addCategory(Intent.CATEGORY_BROWSABLE);
+                intent.setComponent(null);
+            } else {
+                intent = new Intent(Intent.ACTION_VIEW, uri);
+            }
+
+            startActivity(intent);
+        } catch (ActivityNotFoundException e) {
+            Log.w("WEBVIEW", "No app can handle URI: " + uri, e);
+            Toast.makeText(this, "No hay una aplicación disponible para abrir este enlace", Toast.LENGTH_LONG).show();
+        } catch (Exception e) {
+            Log.e("WEBVIEW", "Error opening URI: " + uri, e);
+            Toast.makeText(this, "No se pudo abrir el enlace", Toast.LENGTH_LONG).show();
+        }
+    }
+
+    private void requestLegacyStoragePermissionIfNeeded() {
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P
+                && ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
+            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, STORAGE_PERMISSION_REQUEST_CODE);
+        }
+    }
+
+    private String safePdfFilename(String filename) {
+        String safeName = filename == null ? "reporte.pdf" : filename.trim();
+        safeName = safeName.replaceAll("[\\\\/:*?\"<>|]", "_");
+
+        if (safeName.length() == 0) {
+            safeName = "reporte.pdf";
+        }
+
+        if (!safeName.toLowerCase().endsWith(".pdf")) {
+            safeName += ".pdf";
+        }
+
+        return safeName;
+    }
+
     public class WebAppInterface {
         @JavascriptInterface
         public void startGoogleLogin() {
@@ -185,16 +265,20 @@ public class MainActivity extends AppCompatActivity {
 
         @JavascriptInterface
         public void savePdf(String base64Data, String filename) {
+            String safeFilename = safePdfFilename(filename);
+
             try {
-                byte[] pdfAsBytes = Base64.decode(base64Data, 0);
+                String normalizedBase64 = base64Data == null ? "" : base64Data.replaceFirst("^data:application/pdf;base64,", "");
+                byte[] pdfAsBytes = Base64.decode(normalizedBase64, Base64.DEFAULT);
                 boolean isSaved = false;
 
-                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                     ContentResolver resolver = getContentResolver();
                     ContentValues contentValues = new ContentValues();
-                    contentValues.put(MediaStore.MediaColumns.DISPLAY_NAME, filename);
+                    contentValues.put(MediaStore.MediaColumns.DISPLAY_NAME, safeFilename);
                     contentValues.put(MediaStore.MediaColumns.MIME_TYPE, "application/pdf");
                     contentValues.put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DOWNLOADS);
+                    contentValues.put(MediaStore.MediaColumns.IS_PENDING, 1);
 
                     Uri uri = resolver.insert(MediaStore.Downloads.EXTERNAL_CONTENT_URI, contentValues);
 
@@ -203,18 +287,31 @@ public class MainActivity extends AppCompatActivity {
                             outputStream.write(pdfAsBytes);
                             isSaved = true;
                         } catch (IOException e) {
-                            e.printStackTrace();
+                            Log.e("WEBVIEW", "Error writing PDF to MediaStore: " + safeFilename, e);
+                            resolver.delete(uri, null, null);
+                        }
+
+                        if (isSaved) {
+                            ContentValues completedValues = new ContentValues();
+                            completedValues.put(MediaStore.MediaColumns.IS_PENDING, 0);
+                            resolver.update(uri, completedValues, null, null);
                         }
                     }
                 } else {
                     File path = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
-                    File file = new File(path, filename);
 
-                    try (FileOutputStream os = new FileOutputStream(file)) {
+                    if (!path.exists() && !path.mkdirs()) {
-                        os.write(pdfAsBytes);
+                        Log.e("WEBVIEW", "Could not create Downloads directory: " + path.getAbsolutePath());
-                        isSaved = true;
+                    } else {
-                    } catch (IOException e) {
+                        File file = new File(path, safeFilename);
-                        e.printStackTrace();
+
+                        try (FileOutputStream os = new FileOutputStream(file)) {
+                            os.write(pdfAsBytes);
+                            isSaved = true;
+                            MediaScannerConnection.scanFile(MainActivity.this, new String[]{file.getAbsolutePath()}, new String[]{"application/pdf"}, null);
+                        } catch (IOException e) {
+                            Log.e("WEBVIEW", "Error writing PDF to Downloads: " + safeFilename, e);
+                        }
                     }
                 }
 
@@ -225,7 +322,7 @@ public class MainActivity extends AppCompatActivity {
                 }
 
             } catch (Exception e) {
-                e.printStackTrace();
+                Log.e("WEBVIEW", "Error saving PDF: " + safeFilename, e);
                 runOnUiThread(() -> Toast.makeText(MainActivity.this, "Error: " + e.getMessage(), Toast.LENGTH_LONG).show());
             }
         }

notification-sender/Dockerfile

@@ -29,14 +29,8 @@ COPY --from=builder /app/dist ./dist
 # Copiar archivos de entorno a la raíz /app
 COPY --from=builder /app/.env* ./
 
-# Instalar bash y cron
-RUN apk add --no-cache bash curl
-
 # Crear carpeta de logs
 RUN mkdir -p /app/logs
 
-# Agregar tarea de cron: todos los días a las (9-3)UTF = 6AM GMT-3
+# Ejecutar el worker continuo de jobs de notificaciones
-RUN echo "0 9 * * * cd /app && NODE_ENV=production NODE_NO_WARNINGS=1 DOTENV_DISABLE_TELEMETRY=1 node dist/index.js >> /app/logs/cron.log 2>&1" > /etc/crontabs/root
+CMD ["node", "dist/index.js"]
-
-# Mantener cron en primer plano
-CMD ["crond", "-f", "-L", "/app/logs/cron.log"]

notification-sender/jest.config.cjs

@@ -0,0 +1,20 @@
+module.exports = {
+    preset: "ts-jest",
+    testEnvironment: "node",
+    testMatch: ["**/__tests__/**/*.ts", "**/?(*.)+(spec|test).ts"],
+    moduleNameMapper: {
+        "^(\\.{1,2}/.*)\\.js$": "$1",
+    },
+    transform: {
+        "^.+\\.tsx?$": [
+            "ts-jest",
+            {
+                useESM: false,
+                tsconfig: {
+                    module: "CommonJS",
+                    moduleResolution: "node",
+                },
+            },
+        ],
+    },
+};

notification-sender/package.json

@@ -4,9 +4,10 @@
     "type": "module",
     "main": "index.js",
     "scripts": {
-        "dev": "NODE_NO_WARNINGS=1 DOTENV_DISABLE_TELEMETRY=1 node --loader ts-node/esm src/index.ts",
+        "dev": "cross-env NODE_NO_WARNINGS=1 DOTENV_DISABLE_TELEMETRY=1 node --loader ts-node/esm src/index.ts",
         "build": "tsc",
-        "start": "node dist/index.js"
+        "start": "node dist/index.js",
+        "test": "jest --config jest.config.cjs"
     },
     "keywords": [],
     "author": "",
@@ -14,8 +15,12 @@
     "description": "",
     "devDependencies": {
         "@types/axios": "^0.9.36",
+        "@types/jest": "^30.0.0",
         "@types/mongoose": "^5.11.96",
         "@types/node": "^24.3.3",
+        "cross-env": "^10.1.0",
+        "jest": "^30.4.2",
+        "ts-jest": "^29.4.11",
         "ts-node": "^10.9.2",
         "typescript": "^5.9.2"
     },

notification-sender/src/Models/Jobs/ChannelDispatchers.ts

@@ -0,0 +1,192 @@
+import { logDone, logError, logIntent } from "../../config/logger.js";
+
+export interface DispatchResult {
+    success: boolean;
+    providerResponse?: string;
+    error?: string;
+}
+
+function formatResponseFailure(endpoint: string, data: unknown): string {
+    const serialized = JSON.stringify(data);
+    return `${endpoint} returned success=false${serialized && serialized !== "{}" ? ` data=${serialized}` : " without error details"}`;
+}
+
+function getApiBaseUrl(): string {
+    const raw = process.env.API_URL || "";
+
+    if (!raw.trim()) {
+        return "";
+    }
+
+    try {
+        return new URL(raw).origin;
+    } catch {
+        return raw.replace(/\/$/, "");
+    }
+}
+
+function buildApiUrl(path: string): string {
+    return `${getApiBaseUrl()}${path}`;
+}
+
+function formatDispatchError(error: unknown): string {
+    if (typeof error === "object" && error !== null && "isAxiosError" in error) {
+        const axiosError = error as {
+            message?: string;
+            response?: { status?: number; data?: unknown };
+        };
+        const details = [
+            axiosError.response?.status ? `status=${axiosError.response.status}` : undefined,
+            axiosError.response?.data !== undefined ? `data=${JSON.stringify(axiosError.response.data)}` : undefined,
+            axiosError.message ? `message=${axiosError.message}` : undefined,
+        ].filter(Boolean);
+
+        return details.join(" ") || "Axios request failed without details";
+    }
+
+    return error instanceof Error ? error.message : String(error);
+}
+
+export async function dispatchWhatsApp(params: {
+    companyId: string;
+    appointmentId: string;
+    type: string;
+    systemToken: string;
+    phoneNumber: string;
+    message: string;
+    companyOwnerId: string;
+}): Promise<DispatchResult> {
+    try {
+        if (!params.phoneNumber.trim() || !params.message.trim() || !params.companyOwnerId.trim()) {
+            return { success: false, error: "WhatsApp dispatch requires phoneNumber, message, and companyOwnerId" };
+        }
+
+        // Send worker-rendered content directly so cancellation jobs survive appointment deletion.
+        const axios = (await import("axios")).default;
+        const response = await axios.post(
+            buildApiUrl("/notifications/send-wap"),
+            {
+                systemToken: params.systemToken,
+                phoneNumber: params.phoneNumber,
+                message: params.message,
+                companyId: params.companyId,
+                sessionUser: params.companyOwnerId,
+            },
+            {
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+
+        logDone(`WhatsApp dispatched for company ${params.companyId}`);
+        return { success: true, providerResponse: JSON.stringify(response.data) };
+    } catch (error) {
+        const msg = formatDispatchError(error);
+        logError(`WhatsApp dispatch failed for company ${params.companyId}:`, msg);
+        return { success: false, error: msg };
+    }
+}
+
+export async function dispatchEmail(params: {
+    appointmentId: string;
+    systemToken: string;
+    type: string;
+    email: string;
+    subject?: string;
+    message?: string;
+    templateId?: string;
+    context?: Record<string, unknown>;
+}): Promise<DispatchResult> {
+    try {
+        const hasContent = Boolean(params.subject?.trim() && params.message?.trim());
+        const hasTemplate = Boolean(params.templateId?.trim() && params.context);
+
+        if (!params.email.trim() || (!hasContent && !hasTemplate)) {
+            return { success: false, error: "Email dispatch requires email and either subject/message or templateId/context" };
+        }
+
+        // Send worker-rendered content directly so cancellation jobs survive appointment deletion.
+        const axios = (await import("axios")).default;
+        const response = await axios.post(
+            buildApiUrl("/notifications/send-email"),
+            {
+                systemToken: params.systemToken,
+                email: params.email,
+                ...(params.subject ? { subject: params.subject } : {}),
+                ...(params.message ? { message: params.message } : {}),
+                ...(params.templateId ? { templateId: params.templateId } : {}),
+                ...(params.context ? { context: params.context } : {}),
+            },
+            {
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+
+        const responseData = response.data as { success?: boolean };
+        if (responseData.success === false) {
+            return {
+                success: false,
+                error: formatResponseFailure("notifications/send-email", response.data),
+            };
+        }
+
+        logDone(`Email dispatched to ${params.email}`);
+        return { success: true, providerResponse: JSON.stringify(response.data) };
+    } catch (error) {
+        const msg = formatDispatchError(error);
+        logError(`Email dispatch failed for ${params.email}:`, msg);
+        return { success: false, error: msg };
+    }
+}
+
+export async function dispatchSystem(params: {
+    systemToken: string;
+    userId: string;
+    subject: string;
+    message: string;
+    companyId?: string;
+    serviceId?: number;
+    conversationId?: string;
+    type?: string;
+    code?: string;
+}): Promise<DispatchResult> {
+    try {
+        if (!params.userId.trim() || !params.subject.trim() || !params.message.trim()) {
+            return { success: false, error: "System dispatch requires userId, subject, and message" };
+        }
+
+        // Delegate to the server API for system notification
+        const axios = (await import("axios")).default;
+        const response = await axios.post(
+            buildApiUrl("/systemnotifications/create"),
+            {
+                userId: params.userId,
+                subject: params.subject,
+                message: params.message,
+                companyId: params.companyId,
+                serviceId: params.serviceId,
+                conversationId: params.conversationId,
+                type: params.type,
+                code: params.code,
+                systemToken: params.systemToken,
+            },
+            {
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+
+        const responseData = response.data as { success?: boolean };
+        if (responseData.success === false) {
+            return {
+                success: false,
+                error: formatResponseFailure("systemnotifications/create", response.data),
+            };
+        }
+
+        logDone(`System notification dispatched to user ${params.userId}`);
+        return { success: true, providerResponse: JSON.stringify(response.data) };
+    } catch (error) {
+        const msg = formatDispatchError(error);
+        logError(`System notification dispatch failed for user ${params.userId}:`, msg);
+        return { success: false, error: msg };
+    }
+}

notification-sender/src/Models/Jobs/JobProcessor.ts

@@ -0,0 +1,279 @@
+import { logDone, logError, logIntent } from "../../config/logger.js";
+import { NotificationJobModel, INotificationJob } from "./NotificationJob.Adapter.Mongoose.js";
+import { WhatsAppThrottleClass } from "./WhatsAppThrottle.js";
+import { dispatchWhatsApp, dispatchEmail, dispatchSystem } from "./ChannelDispatchers.js";
+import { resolveNotificationContent } from "./NotificationContentResolver.js";
+
+const POLL_INTERVAL_MS = 5000;
+const BASE_RETRY_DELAY_MS = 5000;
+const MAX_JITTER_MS = 3000;
+const THROTTLE_RETRY_DELAY_MS = 8000;
+const DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+const CLEANUP_RETENTION_DAYS = 7;
+const SUPPORTED_APPOINTMENT_NOTIFICATION_TYPES = new Set(["creation", "reminder", "cancellation"]);
+
+function resolveCleanupIntervalMs(): number {
+    const raw = process.env.NOTIFICATION_JOB_CLEANUP_INTERVAL_MS;
+    if (!raw) return DEFAULT_CLEANUP_INTERVAL_MS;
+
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_CLEANUP_INTERVAL_MS;
+}
+
+function resolveAppointmentNotificationType(type: unknown): string {
+    return typeof type === "string" && SUPPORTED_APPOINTMENT_NOTIFICATION_TYPES.has(type) ? type : "reminder";
+}
+
+export function buildPendingJobQuery(now: Date) {
+    return {
+        status: "pending",
+        scheduledAt: { $lte: now },
+        $or: [{ nextRetryAt: { $exists: false } }, { nextRetryAt: null }, { nextRetryAt: { $lte: now } }],
+    };
+}
+
+export function calculateNextRetryAt(attempt: number, now: Date): Date {
+    const delay = BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+    const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+    return new Date(now.getTime() + delay + jitter);
+}
+
+export function buildStartOfDay(date: Date): Date {
+    return new Date(date.getFullYear(), date.getMonth(), date.getDate());
+}
+
+export function buildCleanupCutoff(now: Date): Date {
+    const cutoff = buildStartOfDay(now);
+    cutoff.setDate(cutoff.getDate() - CLEANUP_RETENTION_DAYS);
+    return cutoff;
+}
+
+function getJobId(job: { id?: unknown; _id?: unknown; appointmentId?: unknown; channel?: unknown; get?: (path: string) => unknown }): string {
+    const value = job.id || job._id || job.get?.("_id");
+    if (value) return String(value);
+
+    const appointmentId = job.appointmentId || job.get?.("appointmentId");
+    const channel = job.channel || job.get?.("channel");
+    return appointmentId || channel ? `unknown appointment=${String(appointmentId || "n/a")} channel=${String(channel || "n/a")}` : "unknown";
+}
+
+export class JobProcessor {
+    private jobModel: NotificationJobModel;
+    private throttle: WhatsAppThrottleClass;
+    private polling = false;
+    private cleanupTimeout?: NodeJS.Timeout;
+    private cleanupIntervalMs: number;
+
+    constructor() {
+        this.jobModel = new NotificationJobModel();
+        this.throttle = new WhatsAppThrottleClass();
+        this.cleanupIntervalMs = resolveCleanupIntervalMs();
+    }
+
+    public async startPolling(): Promise<void> {
+        if (this.polling) return;
+        this.polling = true;
+        logIntent("JobProcessor: starting poll loop");
+        await this.cleanupOldJobs();
+        this.scheduleCleanup();
+        this.poll();
+    }
+
+    public stopPolling(): void {
+        this.polling = false;
+        if (this.cleanupTimeout) {
+            clearTimeout(this.cleanupTimeout);
+            this.cleanupTimeout = undefined;
+        }
+        logIntent("JobProcessor: stopping poll loop");
+    }
+
+    private scheduleCleanup(): void {
+        if (!this.polling || this.cleanupIntervalMs <= 0) return;
+
+        this.cleanupTimeout = setTimeout(async () => {
+            await this.cleanupOldJobs();
+            this.scheduleCleanup();
+        }, this.cleanupIntervalMs);
+    }
+
+    private async cleanupOldJobs(now = new Date()): Promise<void> {
+        const cutoff = buildCleanupCutoff(now);
+
+        try {
+            const deletedCount = await this.jobModel.deleteBeforeScheduledAt(cutoff);
+            logDone(`JobProcessor: cleaned ${deletedCount} old notification jobs before ${cutoff.toISOString()}`);
+        } catch (error) {
+            logError(`JobProcessor: cleanup error before ${cutoff.toISOString()}`, error);
+        }
+    }
+
+    private async poll(): Promise<void> {
+        if (!this.polling) return;
+
+        try {
+            const now = new Date();
+            const pendingJobs = await this.jobModel.notificationJobList
+                .find(buildPendingJobQuery(now))
+                .sort({ scheduledAt: 1 })
+                .exec();
+
+            if (pendingJobs.length > 0) {
+                logIntent(`JobProcessor: found ${pendingJobs.length} pending jobs`);
+                await this.processJobs(pendingJobs);
+            }
+        } catch (error) {
+            logError("JobProcessor: poll error", error);
+        }
+
+        setTimeout(() => this.poll(), POLL_INTERVAL_MS);
+    }
+
+    private async processJobs(jobs: any[]): Promise<void> {
+        // Group by companyId
+        const grouped = new Map<string, any[]>();
+        for (const job of jobs) {
+            const companyId = String(job.companyId);
+            if (!grouped.has(companyId)) {
+                grouped.set(companyId, []);
+            }
+            grouped.get(companyId)!.push(job);
+        }
+
+        for (const [companyId, companyJobs] of grouped) {
+            for (const job of companyJobs) {
+                await this.processJob(job, companyId);
+            }
+        }
+    }
+
+    private async processJob(job: any, companyId: string): Promise<void> {
+        const now = new Date();
+        const jobId = getJobId(job);
+
+        try {
+            // Check throttle for WhatsApp
+            if (job.channel === "whatsapp") {
+                if (!this.throttle.canSend(companyId)) {
+                    const nextRetryAt = new Date(now.getTime() + THROTTLE_RETRY_DELAY_MS);
+                    await this.jobModel.notificationJobList.updateOne(
+                        { _id: job._id },
+                        { $set: { status: "pending", nextRetryAt } }
+                    ).exec();
+                    logIntent(`JobProcessor: job ${jobId} throttled WhatsApp for company ${companyId}; retry at ${nextRetryAt.toISOString()}`);
+                    return;
+                }
+            }
+
+            const nextAttempt = job.attempts + 1;
+            await this.jobModel.notificationJobList.updateOne(
+                { _id: job._id },
+                { $set: { status: "processing", attempts: nextAttempt } }
+            ).exec();
+
+            const dispatchJob = {
+                ...job,
+                _id: job._id || job.get?.("_id"),
+                appointmentId: job.appointmentId || job.get?.("appointmentId"),
+                channel: job.channel || job.get?.("channel"),
+                attempts: nextAttempt,
+            };
+            const content = await resolveNotificationContent(job);
+            const appointmentNotificationType = resolveAppointmentNotificationType(job.type);
+
+            let result;
+            switch (job.channel) {
+                case "whatsapp":
+                    result = await dispatchWhatsApp({
+                        companyId,
+                        appointmentId: String(job.appointmentId),
+                        type: appointmentNotificationType,
+                        systemToken: `${process.env.API_KEY}`,
+                        phoneNumber: content.phoneNumber || "",
+                        message: content.message,
+                        companyOwnerId: content.companyOwnerId || "",
+                    });
+                    break;
+                case "email":
+                    result = await dispatchEmail({
+                        appointmentId: String(job.appointmentId),
+                        systemToken: `${process.env.API_KEY}`,
+                        type: appointmentNotificationType,
+                        email: content.email || "",
+                        subject: content.subject,
+                        message: content.message,
+                        templateId: content.emailTemplateId,
+                        context: content.emailContext,
+                    });
+                    break;
+                case "system":
+                    result = await dispatchSystem({
+                        systemToken: `${process.env.API_KEY}`,
+                        userId: content.userId || "",
+                        subject: content.subject,
+                        message: content.message,
+                        companyId: String(job.companyId),
+                        type: job.type,
+                        code: String(job.appointmentId),
+                    });
+                    break;
+                default:
+                    result = { success: false, error: `Unknown channel: ${job.channel}` };
+            }
+
+            if (result.success) {
+                if (job.channel === "whatsapp") {
+                    this.throttle.recordSent(companyId);
+                }
+
+                await this.jobModel.notificationJobList.updateOne(
+                    { _id: job._id },
+                    {
+                        $set: {
+                            status: "sent",
+                            sentAt: new Date(),
+                            providerResponse: result.providerResponse,
+                        },
+                    }
+                ).exec();
+                logDone(`JobProcessor: job ${jobId} sent via ${job.channel}`);
+            } else {
+                await this.handleFailure(dispatchJob, result.error || "Unknown error");
+            }
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            await this.handleFailure({ ...job, attempts: job.attempts + 1 }, msg);
+        }
+    }
+
+    private async handleFailure(job: any, errorMessage: string): Promise<void> {
+        const now = new Date();
+        const jobId = getJobId(job);
+
+        if (job.attempts >= job.maxAttempts) {
+            await this.jobModel.notificationJobList.updateOne(
+                { _id: job._id },
+                {
+                    $set: {
+                        status: "failed",
+                        lastError: errorMessage,
+                    },
+                }
+            ).exec();
+            logError(`JobProcessor: job ${jobId} failed permanently after ${job.attempts} attempts`, errorMessage);
+        } else {
+            const nextRetryAt = calculateNextRetryAt(job.attempts, now);
+            await this.jobModel.notificationJobList.updateOne(
+                { _id: job._id },
+                {
+                    $set: {
+                        status: "pending",
+                        lastError: errorMessage,
+                        nextRetryAt,
+                    },
+                }
+            ).exec();
+            logError(`JobProcessor: job ${jobId} failed attempt ${job.attempts}/${job.maxAttempts}; retry at ${nextRetryAt.toISOString()}`, errorMessage);
+        }
+    }
+}

notification-sender/src/Models/Jobs/NotificationContentResolver.ts

@@ -0,0 +1,195 @@
+import mongoose, { Model } from "mongoose";
+import { INotificationJobDocument, NotificationJobType } from "./NotificationJob.Adapter.Mongoose.js";
+
+const { Schema, model, models } = mongoose;
+
+interface AppointmentDocument {
+    _id: unknown;
+    companyId: unknown;
+    serviceId?: unknown;
+    clientId?: unknown;
+    userId?: unknown;
+    start: Date;
+}
+
+interface ClientDocument {
+    _id: unknown;
+    userId?: unknown;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+}
+
+interface UserDocument {
+    _id: unknown;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+}
+
+interface ServiceDocument {
+    _id: unknown;
+    name?: string;
+}
+
+interface CompanyDocument {
+    _id: unknown;
+    name?: string;
+    ownerId?: unknown;
+}
+
+export interface ResolvedNotificationContent {
+    email?: string;
+    phoneNumber?: string;
+    userId?: string;
+    companyOwnerId?: string;
+    subject: string;
+    message: string;
+    emailTemplateId?: string;
+    emailContext?: Record<string, unknown>;
+}
+
+const appointmentSchema = new Schema(
+    {
+        companyId: { type: Schema.Types.ObjectId, required: true, ref: "Companie" },
+        serviceId: { type: Schema.Types.ObjectId, required: false, ref: "Service" },
+        clientId: { type: Schema.Types.ObjectId, required: false, ref: "Client" },
+        userId: { type: Schema.Types.ObjectId, required: false, ref: "User" },
+        start: { type: Date, required: true },
+    },
+    { strict: false }
+);
+
+const clientSchema = new Schema(
+    {
+        userId: { type: Schema.Types.ObjectId, required: false, ref: "User" },
+        firstName: { type: String, required: false },
+        lastName: { type: String, required: false },
+        email: { type: String, required: false },
+    },
+    { strict: false }
+);
+
+const userSchema = new Schema(
+    {
+        email: { type: String, required: false },
+        firstName: { type: String, required: false },
+        lastName: { type: String, required: false },
+    },
+    { strict: false }
+);
+
+const serviceSchema = new Schema(
+    {
+        name: { type: String, required: false },
+    },
+    { strict: false }
+);
+
+const companySchema = new Schema(
+    {
+        name: { type: String, required: false },
+        ownerId: { type: Schema.Types.ObjectId, required: false, ref: "User" },
+    },
+    { strict: false }
+);
+
+const Appointment = (models.Appointment || model<AppointmentDocument>("Appointment", appointmentSchema)) as Model<AppointmentDocument>;
+const Client = (models.Client || model<ClientDocument>("Client", clientSchema)) as Model<ClientDocument>;
+const User = (models.User || model<UserDocument>("User", userSchema)) as Model<UserDocument>;
+const Service = (models.Service || model<ServiceDocument>("Service", serviceSchema)) as Model<ServiceDocument>;
+const Company = (models.Company || model<CompanyDocument>("Company", companySchema)) as Model<CompanyDocument>;
+
+function compactName(...parts: Array<string | undefined>): string {
+    return parts.filter(Boolean).join(" ").trim();
+}
+
+function formatDateTime(value?: Date): string {
+    if (!value) return "fecha pendiente";
+    return new Intl.DateTimeFormat("es-AR", {
+        dateStyle: "short",
+        timeStyle: "short",
+        timeZone: "America/Argentina/Buenos_Aires",
+    }).format(value);
+}
+
+export function buildNotificationText(params: {
+    type: NotificationJobType;
+    appointment?: AppointmentDocument | null;
+    client?: ClientDocument | null;
+    service?: ServiceDocument | null;
+    company?: CompanyDocument | null;
+}): Pick<ResolvedNotificationContent, "subject" | "message"> {
+    const companyName = params.company?.name || "TurnosXpress";
+    const serviceName = params.service?.name || "tu turno";
+    const appointmentDate = formatDateTime(params.appointment?.start);
+
+    switch (params.type) {
+        case "creation":
+            return {
+                subject: `Alta de turno en ${companyName}`,
+                message: `Tu turno para ${serviceName} en ${companyName} fue confirmado para el ${appointmentDate}.`,
+            };
+        case "reminder":
+            return {
+                subject: `Recordatorio de turno en ${companyName}`,
+                message: `Te recordamos tu turno para ${serviceName} en ${companyName} el ${appointmentDate}.`,
+            };
+        case "update":
+            return {
+                subject: `Turno actualizado en ${companyName}`,
+                message: `Tu turno para ${serviceName} en ${companyName} fue actualizado. Nueva fecha: ${appointmentDate}.`,
+            };
+        case "cancellation":
+            return {
+                subject: `Turno cancelado en ${companyName}`,
+                message: `Tu turno para ${serviceName} en ${companyName} del ${appointmentDate} fue cancelado.`,
+            };
+    }
+}
+
+export async function resolveNotificationContent(job: INotificationJobDocument): Promise<ResolvedNotificationContent> {
+    if ((job.type === "creation" || job.type === "reminder" || job.type === "update" || job.type === "cancellation") && job.payload) {
+        const { email, phoneNumber, userId, companyOwnerId } = job.payload;
+        const subject = job.channel === "email"
+            ? job.payload.emailSubject
+            : job.channel === "system"
+                ? job.payload.systemSubject
+                : job.payload.subject;
+        const message = job.channel === "whatsapp"
+            ? job.payload.wapMessage
+            : job.channel === "email"
+                ? job.payload.emailMessage
+                : job.payload.systemMessage;
+        const fallbackSubject = subject || job.payload.subject;
+        const fallbackMessage = message || job.payload.message;
+        if (fallbackSubject?.trim() && fallbackMessage?.trim()) {
+            return {
+                email: email?.trim(),
+                phoneNumber: phoneNumber?.trim(),
+                userId: userId ? String(userId) : undefined,
+                companyOwnerId: companyOwnerId ? String(companyOwnerId) : undefined,
+                subject: fallbackSubject.trim(),
+                message: fallbackMessage.trim(),
+                emailTemplateId: job.payload.emailTemplateId?.trim(),
+                emailContext: job.payload.emailContext,
+            };
+        }
+    }
+
+    const appointment = await Appointment.findOne({ _id: job.appointmentId }).lean().exec();
+    const client = await Client.findOne({ _id: job.clientId }).lean().exec();
+    const company = await Company.findOne({ _id: job.companyId }).lean().exec();
+    const service = appointment?.serviceId ? await Service.findOne({ _id: appointment.serviceId }).lean().exec() : null;
+    const userId = client?.userId || appointment?.userId || company?.ownerId;
+    const user = userId ? await User.findOne({ _id: userId }).lean().exec() : null;
+    const text = buildNotificationText({ type: job.type, appointment, client, service, company });
+    const email = client?.email || user?.email;
+
+    return {
+        email: email?.trim(),
+        userId: userId ? String(userId) : undefined,
+        subject: text.subject.trim(),
+        message: text.message.trim(),
+    };
+}

notification-sender/src/Models/Jobs/NotificationJob.Adapter.Mongoose.ts

@@ -0,0 +1,118 @@
+import mongoose, { Document, Model, Schema, model } from "mongoose";
+
+export type NotificationChannel = "whatsapp" | "email" | "system";
+export type NotificationJobStatus = "pending" | "processing" | "sent" | "failed" | "cancelled";
+export type NotificationJobType = "creation" | "reminder" | "update" | "cancellation";
+
+export const DELETABLE_NOTIFICATION_JOB_STATUSES: NotificationJobStatus[] = ["sent", "failed", "cancelled"];
+
+export interface NotificationJobPayload {
+    email?: string;
+    phoneNumber?: string;
+    userId?: string;
+    companyOwnerId?: string;
+    subject?: string;
+    message?: string;
+    emailSubject?: string;
+    emailMessage?: string;
+    emailTemplateId?: string;
+    emailContext?: Record<string, unknown>;
+    wapMessage?: string;
+    systemSubject?: string;
+    systemMessage?: string;
+}
+
+export interface INotificationJob {
+    _id: string;
+    companyId: string;
+    appointmentId: string;
+    clientId: string;
+    channel: NotificationChannel;
+    type: NotificationJobType;
+    scheduledAt: Date;
+    status: NotificationJobStatus;
+    attempts: number;
+    maxAttempts: number;
+    lastError?: string;
+    nextRetryAt?: Date;
+    providerResponse?: string;
+    payload?: NotificationJobPayload;
+    createdAt: Date;
+    updatedAt: Date;
+    sentAt?: Date;
+}
+
+export interface INotificationJobDocument extends Omit<INotificationJob, "_id">, Document {}
+
+export class NotificationJobModel {
+    schema: Schema;
+    notificationJobList: Model<INotificationJobDocument>;
+
+    constructor() {
+        this.schema = new Schema(
+            {
+                companyId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    ref: "Companie",
+                },
+                appointmentId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    ref: "Appointment",
+                },
+                clientId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    ref: "Client",
+                },
+                channel: {
+                    type: String,
+                    required: true,
+                    enum: ["whatsapp", "email", "system"],
+                },
+                type: {
+                    type: String,
+                    required: true,
+                    enum: ["creation", "reminder", "update", "cancellation"],
+                },
+                scheduledAt: { type: Date, required: true },
+                status: {
+                    type: String,
+                    required: true,
+                    enum: ["pending", "processing", "sent", "failed", "cancelled"],
+                    default: "pending",
+                },
+                attempts: { type: Number, required: true, default: 0 },
+                maxAttempts: { type: Number, required: true, default: 3 },
+                lastError: { type: String, required: false },
+                nextRetryAt: { type: Date, required: false },
+                providerResponse: { type: String, required: false },
+                payload: { type: Schema.Types.Mixed, required: false },
+                sentAt: { type: Date, required: false },
+            },
+            {
+                timestamps: true,
+            }
+        );
+
+        this.schema.index({ status: 1, scheduledAt: 1 });
+        this.schema.index({ status: 1, scheduledAt: 1, nextRetryAt: 1 });
+        this.schema.index({ companyId: 1, status: 1 });
+        this.schema.index({ appointmentId: 1 });
+
+        this.notificationJobList = model<INotificationJobDocument>(
+            "NotificationJob",
+            this.schema
+        );
+    }
+
+    async deleteBeforeScheduledAt(cutoff: Date): Promise<number> {
+        const result = await this.notificationJobList.deleteMany({
+            scheduledAt: { $lt: cutoff },
+            status: { $in: DELETABLE_NOTIFICATION_JOB_STATUSES },
+        }).exec();
+
+        return result.deletedCount || 0;
+    }
+}

notification-sender/src/Models/Jobs/WhatsAppThrottle.ts

@@ -0,0 +1,28 @@
+const DEFAULT_MIN_INTERVAL_MS = 8000;
+const JITTER_MAX_MS = 8000;
+
+export class WhatsAppThrottleClass {
+    private lastSentAt: Map<string, number> = new Map();
+    private minIntervalMs: number;
+
+    constructor(minIntervalMs: number = DEFAULT_MIN_INTERVAL_MS) {
+        this.minIntervalMs = minIntervalMs;
+    }
+
+    canSend(companyId: string): boolean {
+        const lastSent = this.lastSentAt.get(companyId);
+        if (!lastSent) {
+            return true;
+        }
+
+        const elapsed = Date.now() - lastSent;
+        const jitter = Math.floor(Math.random() * JITTER_MAX_MS);
+        const requiredInterval = this.minIntervalMs + jitter;
+
+        return elapsed >= requiredInterval;
+    }
+
+    recordSent(companyId: string): void {
+        this.lastSentAt.set(companyId, Date.now());
+    }
+}

notification-sender/src/Models/Jobs/__tests__/ChannelDispatchers.test.ts

@@ -0,0 +1,95 @@
+import axios from "axios";
+import { dispatchEmail, dispatchWhatsApp } from "../ChannelDispatchers.js";
+
+jest.mock("axios");
+
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe("ChannelDispatchers", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.API_URL = "https://api.example.com/base";
+        process.env.API_KEY = "system-token";
+        mockedAxios.post.mockResolvedValue({
+            data: { success: true },
+            status: 200,
+            statusText: "OK",
+            headers: {},
+            config: { url: "" },
+        });
+    });
+
+    it("sends the job type in the email notification payload", async () => {
+        await dispatchEmail({
+            appointmentId: "appointment-1",
+            systemToken: "system-token",
+            type: "creation",
+            email: "client@example.com",
+            subject: "Appointment created",
+            message: "Creation message",
+        });
+
+        expect(mockedAxios.post).toHaveBeenCalledWith(
+            "https://api.example.com/notifications/send-email",
+            {
+                systemToken: "system-token",
+                email: "client@example.com",
+                subject: "Appointment created",
+                message: "Creation message",
+            },
+            {
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    });
+
+    it("sends email template data when provided", async () => {
+        await dispatchEmail({
+            appointmentId: "appointment-1",
+            systemToken: "system-token",
+            type: "reminder",
+            email: "client@example.com",
+            templateId: "template-1",
+            context: { username: "Client Name" },
+        });
+
+        expect(mockedAxios.post).toHaveBeenCalledWith(
+            "https://api.example.com/notifications/send-email",
+            {
+                systemToken: "system-token",
+                email: "client@example.com",
+                templateId: "template-1",
+                context: { username: "Client Name" },
+            },
+            {
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    });
+
+    it("sends the job type in the WhatsApp system notification payload", async () => {
+        await dispatchWhatsApp({
+            companyId: "company-1",
+            appointmentId: "appointment-1",
+            type: "creation",
+            systemToken: "system-token",
+            phoneNumber: "5491112345678",
+            message: "Creation message",
+            companyOwnerId: "owner-1",
+        });
+
+        expect(mockedAxios.post).toHaveBeenCalledWith(
+            "https://api.example.com/notifications/send-wap",
+            {
+                systemToken: "system-token",
+                phoneNumber: "5491112345678",
+                message: "Creation message",
+                companyId: "company-1",
+                sessionUser: "owner-1",
+            },
+            {
+                headers: { "Content-Type": "application/json" },
+            }
+        );
+    });
+});

notification-sender/src/Models/Jobs/__tests__/JobProcessor.test.ts

@@ -0,0 +1,298 @@
+import { dispatchEmail, dispatchWhatsApp } from "../ChannelDispatchers.js";
+import { buildCleanupCutoff, buildPendingJobQuery, buildStartOfDay, calculateNextRetryAt, JobProcessor } from "../JobProcessor.js";
+import { DELETABLE_NOTIFICATION_JOB_STATUSES, NotificationJobModel } from "../NotificationJob.Adapter.Mongoose.js";
+import { resolveNotificationContent } from "../NotificationContentResolver.js";
+
+jest.mock("../ChannelDispatchers.js", () => ({
+    dispatchWhatsApp: jest.fn(),
+    dispatchEmail: jest.fn(),
+    dispatchSystem: jest.fn(),
+}));
+
+jest.mock("../NotificationContentResolver.js", () => ({
+    resolveNotificationContent: jest.fn(),
+}));
+
+describe("JobProcessor", () => {
+    describe("calculateNextRetryAt", () => {
+        it("calculates exponential backoff for attempt 1", () => {
+            const now = new Date("2026-07-21T12:00:00.000Z");
+            const result = calculateNextRetryAt(1, now);
+
+            const minExpected = now.getTime() + 5000;
+            const maxExpected = now.getTime() + 5000 + 3000;
+
+            expect(result.getTime()).toBeGreaterThanOrEqual(minExpected);
+            expect(result.getTime()).toBeLessThanOrEqual(maxExpected);
+        });
+
+        it("calculates exponential backoff for attempt 2", () => {
+            const now = new Date("2026-07-21T12:00:00.000Z");
+            const result = calculateNextRetryAt(2, now);
+
+            const minExpected = now.getTime() + 10000;
+            const maxExpected = now.getTime() + 10000 + 3000;
+
+            expect(result.getTime()).toBeGreaterThanOrEqual(minExpected);
+            expect(result.getTime()).toBeLessThanOrEqual(maxExpected);
+        });
+
+        it("calculates exponential backoff for attempt 3", () => {
+            const now = new Date("2026-07-21T12:00:00.000Z");
+            const result = calculateNextRetryAt(3, now);
+
+            const minExpected = now.getTime() + 20000;
+            const maxExpected = now.getTime() + 20000 + 3000;
+
+            expect(result.getTime()).toBeGreaterThanOrEqual(minExpected);
+            expect(result.getTime()).toBeLessThanOrEqual(maxExpected);
+        });
+
+        it("returns a Date in the future", () => {
+            const now = new Date("2026-07-21T12:00:00.000Z");
+            const result = calculateNextRetryAt(1, now);
+            expect(result.getTime()).toBeGreaterThan(now.getTime());
+        });
+
+        it("uses base delay for attempt 0 as fallback", () => {
+            const now = new Date("2026-07-21T12:00:00.000Z");
+            const result = calculateNextRetryAt(1, now);
+
+            expect(result).toBeInstanceOf(Date);
+        });
+    });
+
+    describe("backoff math correctness", () => {
+        it("exponential growth doubles each attempt", () => {
+            const now = new Date("2026-07-21T12:00:00.000Z");
+
+            const r1 = calculateNextRetryAt(1, now).getTime() - now.getTime();
+            const r2 = calculateNextRetryAt(2, now).getTime() - now.getTime();
+            const r3 = calculateNextRetryAt(3, now).getTime() - now.getTime();
+
+            // Without jitter: 5000, 10000, 20000
+            // With jitter up to 3000ms, the growth pattern should still hold
+            // Min possible: 5000, 10000, 20000
+            expect(r1).toBeGreaterThanOrEqual(5000);
+            expect(r2).toBeGreaterThanOrEqual(10000);
+            expect(r3).toBeGreaterThanOrEqual(20000);
+        });
+    });
+
+    describe("buildPendingJobQuery", () => {
+        it("only selects due jobs whose retry window is missing, null, or due", () => {
+            const now = new Date("2026-07-21T12:00:00.000Z");
+
+            expect(buildPendingJobQuery(now)).toEqual({
+                status: "pending",
+                scheduledAt: { $lte: now },
+                $or: [
+                    { nextRetryAt: { $exists: false } },
+                    { nextRetryAt: null },
+                    { nextRetryAt: { $lte: now } },
+                ],
+            });
+        });
+    });
+
+    describe("buildStartOfDay", () => {
+        it("returns the start of the local day", () => {
+            const result = buildStartOfDay(new Date(2026, 6, 21, 15, 30, 45, 123));
+
+            expect(result).toEqual(new Date(2026, 6, 21, 0, 0, 0, 0));
+        });
+    });
+
+    describe("old job cleanup", () => {
+        it("deletes jobs scheduled before the 7-day retention cutoff", async () => {
+            const deleteBeforeScheduledAt = jest.fn().mockResolvedValue(3);
+            const now = new Date(2026, 6, 21, 15, 30, 0, 0);
+
+            await (JobProcessor.prototype as any).cleanupOldJobs.call(
+                { jobModel: { deleteBeforeScheduledAt } },
+                now
+            );
+
+            expect(deleteBeforeScheduledAt).toHaveBeenCalledWith(new Date(2026, 6, 14, 0, 0, 0, 0));
+        });
+
+        it("builds the 7-day retention cutoff from the start of the local day", () => {
+            expect(buildCleanupCutoff(new Date(2026, 6, 21, 15, 30, 0, 0))).toEqual(
+                new Date(2026, 6, 14, 0, 0, 0, 0)
+            );
+        });
+
+        it("deletes only terminal statuses and never pending or processing jobs", async () => {
+            const exec = jest.fn().mockResolvedValue({ deletedCount: 3 });
+            const deleteMany = jest.fn(() => ({ exec }));
+            const model = Object.create(NotificationJobModel.prototype) as NotificationJobModel;
+            (model as any).notificationJobList = { deleteMany };
+            const cutoff = new Date("2026-07-14T00:00:00.000Z");
+
+            await model.deleteBeforeScheduledAt(cutoff);
+
+            expect(deleteMany).toHaveBeenCalledWith({
+                scheduledAt: { $lt: cutoff },
+                status: { $in: ["sent", "failed", "cancelled"] },
+            });
+            expect(DELETABLE_NOTIFICATION_JOB_STATUSES).not.toContain("pending");
+            expect(DELETABLE_NOTIFICATION_JOB_STATUSES).not.toContain("processing");
+        });
+    });
+
+    describe("WhatsApp dispatch", () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            (resolveNotificationContent as jest.Mock).mockResolvedValue({
+                subject: "Appointment reminder",
+                message: "Reminder message",
+                phoneNumber: "5491112345678",
+                companyOwnerId: "owner-1",
+            });
+        });
+
+        it("passes the job appointmentId and type to the WhatsApp dispatcher", async () => {
+            const exec = jest.fn().mockResolvedValue({});
+            const updateOne = jest.fn(() => ({ exec }));
+            const recordSent = jest.fn();
+
+            (dispatchWhatsApp as jest.Mock).mockResolvedValue({ success: true, providerResponse: "{}" });
+
+            await (JobProcessor.prototype as any).processJob.call(
+                {
+                    jobModel: { notificationJobList: { updateOne } },
+                    throttle: { canSend: jest.fn(() => true), recordSent },
+                    handleFailure: jest.fn(),
+                },
+                {
+                    _id: "job-1",
+                    companyId: "company-1",
+                    appointmentId: "appointment-1",
+                    channel: "whatsapp",
+                    type: "creation",
+                    attempts: 0,
+                    maxAttempts: 3,
+                },
+                "company-1"
+            );
+
+            expect(dispatchWhatsApp).toHaveBeenCalledWith({
+                companyId: "company-1",
+                appointmentId: "appointment-1",
+                type: "creation",
+                systemToken: `${process.env.API_KEY}`,
+                phoneNumber: "5491112345678",
+                message: "Reminder message",
+                companyOwnerId: "owner-1",
+            });
+            expect(recordSent).toHaveBeenCalledWith("company-1");
+        });
+
+        it("preserves cancellation WhatsApp job types", async () => {
+            const exec = jest.fn().mockResolvedValue({});
+            const updateOne = jest.fn(() => ({ exec }));
+
+            (dispatchWhatsApp as jest.Mock).mockResolvedValue({ success: true, providerResponse: "{}" });
+
+            await (JobProcessor.prototype as any).processJob.call(
+                {
+                    jobModel: { notificationJobList: { updateOne } },
+                    throttle: { canSend: jest.fn(() => true), recordSent: jest.fn() },
+                    handleFailure: jest.fn(),
+                },
+                {
+                    _id: "job-1",
+                    companyId: "company-1",
+                    appointmentId: "appointment-1",
+                    channel: "whatsapp",
+                    type: "cancellation",
+                    attempts: 0,
+                    maxAttempts: 3,
+                },
+                "company-1"
+            );
+
+            expect(dispatchWhatsApp).toHaveBeenCalledWith({
+                companyId: "company-1",
+                appointmentId: "appointment-1",
+                type: "cancellation",
+                systemToken: `${process.env.API_KEY}`,
+                phoneNumber: "5491112345678",
+                message: "Reminder message",
+                companyOwnerId: "owner-1",
+            });
+        });
+
+        it("does not record a WhatsApp send when dispatch fails", async () => {
+            const exec = jest.fn().mockResolvedValue({});
+            const updateOne = jest.fn(() => ({ exec }));
+            const recordSent = jest.fn();
+
+            (dispatchWhatsApp as jest.Mock).mockResolvedValue({ success: false, error: "provider failed" });
+
+            await (JobProcessor.prototype as any).processJob.call(
+                {
+                    jobModel: { notificationJobList: { updateOne } },
+                    throttle: { canSend: jest.fn(() => true), recordSent },
+                    handleFailure: jest.fn(),
+                },
+                {
+                    _id: "job-1",
+                    companyId: "company-1",
+                    appointmentId: "appointment-1",
+                    channel: "whatsapp",
+                    type: "reminder",
+                    attempts: 0,
+                    maxAttempts: 3,
+                },
+                "company-1"
+            );
+
+            expect(recordSent).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("Email dispatch", () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+            (resolveNotificationContent as jest.Mock).mockResolvedValue({
+                email: "client@example.com",
+                subject: "Appointment created",
+                message: "Creation message",
+            });
+            (dispatchEmail as jest.Mock).mockResolvedValue({ success: true, providerResponse: "{}" });
+        });
+
+        it("passes creation job type to the email dispatcher", async () => {
+            const exec = jest.fn().mockResolvedValue({});
+            const updateOne = jest.fn(() => ({ exec }));
+
+            await (JobProcessor.prototype as any).processJob.call(
+                {
+                    jobModel: { notificationJobList: { updateOne } },
+                    throttle: { canSend: jest.fn(() => true), recordSent: jest.fn() },
+                    handleFailure: jest.fn(),
+                },
+                {
+                    _id: "job-1",
+                    companyId: "company-1",
+                    appointmentId: "appointment-1",
+                    channel: "email",
+                    type: "creation",
+                    attempts: 0,
+                    maxAttempts: 3,
+                },
+                "company-1"
+            );
+
+            expect(dispatchEmail).toHaveBeenCalledWith({
+                appointmentId: "appointment-1",
+                systemToken: `${process.env.API_KEY}`,
+                type: "creation",
+                email: "client@example.com",
+                subject: "Appointment created",
+                message: "Creation message",
+            });
+        });
+    });
+});

notification-sender/src/Models/Jobs/__tests__/NotificationContentResolver.test.ts

@@ -0,0 +1,305 @@
+import mongoose from "mongoose";
+import { buildNotificationText, resolveNotificationContent } from "../NotificationContentResolver.js";
+
+describe("NotificationContentResolver", () => {
+    it("builds appointment creation subject and message as Alta de turno", () => {
+        const result = buildNotificationText({
+            type: "creation",
+            appointment: {
+                _id: "appointment-1",
+                companyId: "company-1",
+                start: new Date("2026-07-22T15:30:00.000Z"),
+            },
+            service: { _id: "service-1", name: "Corte" },
+            company: { _id: "company-1", name: "Barber Shop" },
+        });
+
+        expect(result.subject).toContain("Alta de turno");
+        expect(result.subject).toContain("Barber Shop");
+        expect(result.message).toContain("Corte");
+        expect(result.message).toContain("confirmado");
+    });
+
+    it("builds meaningful appointment reminder subject and message", () => {
+        const result = buildNotificationText({
+            type: "reminder",
+            appointment: {
+                _id: "appointment-1",
+                companyId: "company-1",
+                start: new Date("2026-07-22T15:30:00.000Z"),
+            },
+            service: { _id: "service-1", name: "Corte" },
+            company: { _id: "company-1", name: "Barber Shop" },
+        });
+
+        expect(result.subject).toContain("Recordatorio");
+        expect(result.subject).toContain("Barber Shop");
+        expect(result.message).toContain("Corte");
+        expect(result.message).toContain("Barber Shop");
+        expect(result.subject.trim()).not.toBe("");
+        expect(result.message.trim()).not.toBe("");
+    });
+
+    it("uses cancellation snapshot payload without requiring appointment lookup", async () => {
+        const result = await resolveNotificationContent({
+            appointmentId: "deleted-appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "email",
+            type: "cancellation",
+            payload: {
+                email: "client@example.com",
+                phoneNumber: "5491112345678",
+                userId: "user-1",
+                companyOwnerId: "owner-1",
+                subject: "Turno cancelado en Barber Shop",
+                message: "Tu turno para Corte fue cancelado.",
+                emailSubject: "Email cancellation subject",
+                emailMessage: "Email cancellation body.",
+                wapMessage: "WAP cancellation body.",
+                systemSubject: "System cancellation subject",
+                systemMessage: "System cancellation body.",
+            },
+        } as any);
+
+        expect(result).toEqual({
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            userId: "user-1",
+            companyOwnerId: "owner-1",
+            subject: "Email cancellation subject",
+            message: "Email cancellation body.",
+        });
+    });
+
+    it("uses creation snapshot payload content for email jobs", async () => {
+        const result = await resolveNotificationContent({
+            appointmentId: "appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "email",
+            type: "creation",
+            payload: {
+                email: "client@example.com",
+                phoneNumber: "5491112345678",
+                userId: "user-1",
+                companyOwnerId: "owner-1",
+                subject: "Turno reservado en Barber Shop",
+                message: "Generic creation body.",
+                emailSubject: "Email Alta subject",
+                emailMessage: "Email Alta body.",
+                wapMessage: "WAP Alta body.",
+                systemSubject: "System Alta subject",
+                systemMessage: "System Alta body.",
+            },
+        } as any);
+
+        expect(result).toEqual({
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            userId: "user-1",
+            companyOwnerId: "owner-1",
+            subject: "Email Alta subject",
+            message: "Email Alta body.",
+        });
+    });
+
+    it("uses creation snapshot payload content for WhatsApp jobs", async () => {
+        const result = await resolveNotificationContent({
+            appointmentId: "appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "whatsapp",
+            type: "creation",
+            payload: {
+                phoneNumber: "5491112345678",
+                subject: "Generic subject",
+                message: "Generic message.",
+                emailMessage: "Email Alta body.",
+                wapMessage: "WAP Alta body.",
+            },
+        } as any);
+
+        expect(result.message).toBe("WAP Alta body.");
+    });
+
+    it("uses reminder payload content without requiring appointment lookup", async () => {
+        const appointmentLookup = jest.spyOn(mongoose.models.Appointment, "findOne");
+
+        const result = await resolveNotificationContent({
+            appointmentId: "appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "whatsapp",
+            type: "reminder",
+            payload: {
+                email: "client@example.com",
+                phoneNumber: "5491112345678",
+                userId: "user-1",
+                companyOwnerId: "owner-1",
+                subject: "Generic reminder subject",
+                message: "Generic reminder body.",
+                emailSubject: "Email reminder subject",
+                emailMessage: "Email reminder body.",
+                wapMessage: "WAP reminder body.",
+                systemSubject: "System reminder subject",
+                systemMessage: "System reminder body.",
+            },
+        } as any);
+
+        expect(appointmentLookup).not.toHaveBeenCalled();
+        expect(result).toEqual({
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            userId: "user-1",
+            companyOwnerId: "owner-1",
+            subject: "Generic reminder subject",
+            message: "WAP reminder body.",
+        });
+    });
+
+    it("uses update payload content for email jobs without requiring appointment lookup", async () => {
+        const appointmentLookup = jest.spyOn(mongoose.models.Appointment, "findOne");
+
+        const result = await resolveNotificationContent({
+            appointmentId: "appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "email",
+            type: "update",
+            payload: {
+                email: "client@example.com",
+                phoneNumber: "5491112345678",
+                userId: "user-1",
+                companyOwnerId: "owner-1",
+                subject: "Generic update subject",
+                message: "Generic update body.",
+                emailSubject: "Email update subject",
+                emailMessage: "Email update body.",
+                wapMessage: "WAP update body.",
+                systemSubject: "System update subject",
+                systemMessage: "System update body.",
+            },
+        } as any);
+
+        expect(appointmentLookup).not.toHaveBeenCalled();
+        expect(result).toEqual({
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            userId: "user-1",
+            companyOwnerId: "owner-1",
+            subject: "Email update subject",
+            message: "Email update body.",
+        });
+    });
+
+    it("uses update payload content for WhatsApp jobs without requiring appointment lookup", async () => {
+        const appointmentLookup = jest.spyOn(mongoose.models.Appointment, "findOne");
+
+        const result = await resolveNotificationContent({
+            appointmentId: "appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "whatsapp",
+            type: "update",
+            payload: {
+                email: "client@example.com",
+                phoneNumber: "5491112345678",
+                userId: "user-1",
+                companyOwnerId: "owner-1",
+                subject: "Generic update subject",
+                message: "Generic update body.",
+                emailSubject: "Email update subject",
+                emailMessage: "Email update body.",
+                wapMessage: "WAP update body.",
+                systemSubject: "System update subject",
+                systemMessage: "System update body.",
+            },
+        } as any);
+
+        expect(appointmentLookup).not.toHaveBeenCalled();
+        expect(result).toEqual({
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            userId: "user-1",
+            companyOwnerId: "owner-1",
+            subject: "Generic update subject",
+            message: "WAP update body.",
+        });
+    });
+
+    it("uses update payload content for system jobs without requiring appointment lookup", async () => {
+        const appointmentLookup = jest.spyOn(mongoose.models.Appointment, "findOne");
+
+        const result = await resolveNotificationContent({
+            appointmentId: "appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "system",
+            type: "update",
+            payload: {
+                email: "client@example.com",
+                phoneNumber: "5491112345678",
+                userId: "user-1",
+                companyOwnerId: "owner-1",
+                subject: "Generic update subject",
+                message: "Generic update body.",
+                emailSubject: "Email update subject",
+                emailMessage: "Email update body.",
+                wapMessage: "WAP update body.",
+                systemSubject: "System update subject",
+                systemMessage: "System update body.",
+            },
+        } as any);
+
+        expect(appointmentLookup).not.toHaveBeenCalled();
+        expect(result).toEqual({
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            userId: "user-1",
+            companyOwnerId: "owner-1",
+            subject: "System update subject",
+            message: "System update body.",
+        });
+    });
+
+    it("uses WhatsApp cancellation payload content for WhatsApp jobs", async () => {
+        const result = await resolveNotificationContent({
+            appointmentId: "deleted-appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "whatsapp",
+            type: "cancellation",
+            payload: {
+                phoneNumber: "5491112345678",
+                companyOwnerId: "owner-1",
+                subject: "Generic subject",
+                message: "Generic message.",
+                emailMessage: "Email cancellation body.",
+                wapMessage: "WAP cancellation body.",
+            },
+        } as any);
+
+        expect(result.message).toBe("WAP cancellation body.");
+    });
+
+    it("uses system cancellation payload content for system jobs", async () => {
+        const result = await resolveNotificationContent({
+            appointmentId: "deleted-appointment-1",
+            clientId: "client-1",
+            companyId: "company-1",
+            channel: "system",
+            type: "cancellation",
+            payload: {
+                userId: "user-1",
+                subject: "Generic subject",
+                message: "Generic message.",
+                systemSubject: "System cancellation subject",
+                systemMessage: "System cancellation body.",
+            },
+        } as any);
+
+        expect(result.subject).toBe("System cancellation subject");
+        expect(result.message).toBe("System cancellation body.");
+    });
+});

notification-sender/src/Models/Jobs/__tests__/WhatsAppThrottle.test.ts

@@ -0,0 +1,93 @@
+describe("WhatsAppThrottle", () => {
+    let WhatsAppThrottle: typeof import("../WhatsAppThrottle.js").WhatsAppThrottleClass;
+
+    beforeAll(async () => {
+        const mod = await import("../WhatsAppThrottle.js");
+        WhatsAppThrottle = mod.WhatsAppThrottleClass;
+    });
+
+    beforeEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it("allows first send for a company immediately", () => {
+        const throttle = new WhatsAppThrottle(8000);
+        expect(throttle.canSend("company-1")).toBe(true);
+    });
+
+    it("blocks send within minimum interval", () => {
+        const throttle = new WhatsAppThrottle(8000);
+        throttle.recordSent("company-1");
+
+        jest.useFakeTimers();
+        jest.setSystemTime(new Date("2026-07-21T12:00:03.000Z")); // 3s later
+
+        expect(throttle.canSend("company-1")).toBe(false);
+
+        jest.useRealTimers();
+    });
+
+    it("allows send after maximum possible interval (base + jitter)", () => {
+        const throttle = new WhatsAppThrottle(8000);
+        const now = new Date("2026-07-21T12:00:00.000Z");
+        jest.useFakeTimers();
+        jest.setSystemTime(now);
+
+        throttle.recordSent("company-1");
+
+        // After 16s (max = 8s base + 8s jitter), should always be allowed
+        jest.setSystemTime(new Date("2026-07-21T12:00:16.000Z"));
+
+        expect(throttle.canSend("company-1")).toBe(true);
+
+        jest.useRealTimers();
+    });
+
+    it("tracks companies independently", () => {
+        const throttle = new WhatsAppThrottle(8000);
+        const now = new Date("2026-07-21T12:00:00.000Z");
+        jest.useFakeTimers();
+        jest.setSystemTime(now);
+
+        throttle.recordSent("company-1");
+
+        // company-2 should still be allowed
+        expect(throttle.canSend("company-2")).toBe(true);
+
+        jest.useRealTimers();
+    });
+
+    it("applies jitter to minimum interval", () => {
+        const throttle = new WhatsAppThrottle(8000);
+        const now = new Date("2026-07-21T12:00:00.000Z");
+        jest.useFakeTimers();
+        jest.setSystemTime(now);
+
+        throttle.recordSent("company-1");
+
+        // At exactly 8s (base interval), it should still be blocked due to jitter
+        jest.setSystemTime(new Date("2026-07-21T12:00:08.000Z"));
+        expect(throttle.canSend("company-1")).toBe(false);
+
+        // At 16s (max interval = base + jitter), it should be allowed
+        jest.setSystemTime(new Date("2026-07-21T12:00:16.000Z"));
+        expect(throttle.canSend("company-1")).toBe(true);
+
+        jest.useRealTimers();
+    });
+
+    it("uses default interval of 8000ms when not specified", () => {
+        const throttle = new WhatsAppThrottle();
+        const now = new Date("2026-07-21T12:00:00.000Z");
+        jest.useFakeTimers();
+        jest.setSystemTime(now);
+
+        throttle.recordSent("company-1");
+
+        // 7s should be blocked
+        jest.setSystemTime(new Date("2026-07-21T12:00:07.000Z"));
+        expect(throttle.canSend("company-1")).toBe(false);
+
+        jest.useRealTimers();
+    });
+});

notification-sender/src/config/logger.ts

@@ -42,7 +42,8 @@ export const logDone = (message: string) => {
 };
 
 export const logError = (message: string, error: any) => {
-    logger.info(`❌ ${bold}${message}${reset}\n\r`, error);
+    const details = error instanceof Error ? error.stack || error.message : String(error || "Unknown error");
+    logger.error(`❌ ${bold}${message}${reset}\n${details}`);
 };
 
 export const logWarn = (message: string) => {

notification-sender/src/index.ts

@@ -1,7 +1,7 @@
 import dotenv from "dotenv";
 import logger, { logDone, logError, logIntent } from "./config/logger.js";
 import mongoose from "mongoose";
-import { Notifications } from "./Models/Notifications/Notifications.js";
+import { JobProcessor } from "./Models/Jobs/JobProcessor.js";
 
 logIntent("Iniciando Notification Sender.");
 
@@ -28,10 +28,10 @@ mongoose
     .then(() => {
         const start = async () => {
             logDone("Conexión a MongoDB establecida correctamente.");
-            logger.info("🚀 Notification Sender running");
+            logger.info("🚀 Notification Sender running (job-based polling)");
 
-            const worker = new Notifications();
+            const processor = new JobProcessor();
-            await worker.start();
+            await processor.startPolling();
         };
 
         start();

openspec/changes/notification-preferences-ui/tasks.md

@@ -0,0 +1,62 @@
+# Tasks: Notification Preferences UI
+
+## Review Workload Forecast
+
+| Field | Value |
+|-------|-------|
+| Estimated changed lines | 1000-1200 |
+| 400-line budget risk | High |
+| Chained PRs recommended | Yes |
+| Suggested split | PR 1 → PR 2 → PR 3 → PR 4 |
+| Delivery strategy | ask-on-risk |
+| Chain strategy | pending |
+
+Decision needed before apply: Yes
+Chained PRs recommended: Yes
+Chain strategy: pending
+400-line budget risk: High
+
+### Suggested Work Units
+
+| Unit | Goal | Likely PR | Focused test command | Runtime harness | Rollback boundary |
+|------|------|-----------|----------------------|-----------------|-------------------|
+| 1 | Foundation: models, API service, store, validation | PR 1 | `npm run typecheck` | N/A — types only | Remove service, store, model files |
+| 2 | Org policy page + navigation | PR 2 | Navigate to `/admin/org/profile/[id]/notifications` | Org profile page loads, toggles render | Remove org notifications page and layout |
+| 3 | Client override page + navigation | PR 3 | Navigate to `/admin/org/[oid]/client/[clientId]/notifications` | Client profile page loads, toggles render | Remove client notifications page and layout |
+| 4 | Client-facing page + tests | PR 4 | Navigate to `/user/profile/notifications` | Landing profile page loads, toggles render | Remove landing notifications page and tests |
+
+## Phase 1: Foundation
+
+- [x] 1.1 Create `txclient/src/Models/NotificationPreferences.model.ts` — TypeScript interfaces: NotificationChannel, QuietHours, ReminderRule, CompanyNotificationPolicy, ClientNotificationPreferences, ClientCompanyNotificationOverride, upsert params
+- [x] 1.2 Create `txclient/src/services/Notifications.Service.ts` — 6 API functions using `ApiRequest.post<T>()`: getCompanyPolicy, upsertCompanyPolicy, getClientPreferences, upsertClientPreferences, getClientCompanyOverride, upsertClientCompanyOverride
+- [x] 1.3 Create `txclient/src/Store/NotificationPreferences.Store.ts` — Zustand store with mode, form data, dirty flag; actions: setMode, updateFormData, resetForm
+- [x] 1.4 Create `txclient/src/Models/NotificationPreferences.validation.ts` — Yup schemas: companyPolicySchema (channels min 1, timezone required, quietHours optional HH:mm, reminderRules max 5), clientPrefsSchema (preferredChannels, mutedChannels)
+
+## Phase 2: Org Policy Page
+
+- [x] 2.1 Create `txclient/src/app/admin/(organization-profile)/org/profile/[id]/notifications/layout.tsx` — Saveable wrapper loading company policy on mount, dispatching NEED_SAVE/SAVE events
+- [x] 2.2 Create `txclient/src/app/admin/(organization-profile)/org/profile/[id]/notifications/page.tsx` — Org policy form: channel toggles (3x Switch), quiet hours (2x input time), timezone Textbox, reminder rules dynamic list (max 5) with add/remove buttons
+- [x] 2.3 Modify `txclient/src/app/components/OrganizationHeader/OrganizationHeader.tsx` — Add "Notificaciones" menu item linking to `/admin/org/profile/[id]/notifications` with NotificationsIcon
+
+## Phase 3: Client Override Page
+
+- [x] 3.1 Create `txclient/src/app/admin/(client-profile)/org/[oid]/client/[clientId]/notifications/layout.tsx` — Saveable wrapper loading client company override on mount
+- [x] 3.2 Create `txclient/src/app/admin/(client-profile)/org/[oid]/client/[clientId]/notifications/page.tsx` — Client override form: preferred channels (3x Switch), muted channels (3x Switch)
+- [x] 3.3 Modify `txclient/src/app/admin/(client-profile)/org/[oid]/client/[clientId]/layout.tsx` — Add "Notificaciones" navigation link to client profile menu
+
+## Phase 4: Client-Facing Page
+
+- [x] 4.1 Create `txclient/src/app/user/profile/notifications-preferences/page.tsx` — Client preferences form: preferred channels (3x Switch), muted channels (3x Switch); wrapped in Secure component for auth gate
+- [x] 4.2 Modify `txclient/src/app/user/profile/page.tsx` — Add "Preferencias de notificación" navigation link to user profile menu
+
+## Phase 5: Testing
+
+- [ ] 5.1 Create `txclient/src/Models/__tests__/NotificationPreferences.validation.test.ts` — Test Yup schemas: valid inputs pass, invalid channels rejected, timezone required, quietHours format validated, reminderRules max 5 enforced (BLOCKED: no test runner in txclient)
+- [ ] 5.2 Create `txclient/src/services/__tests__/Notifications.Service.test.ts` — Mock ApiRequest.post, verify 6 functions call correct endpoints with correct params (BLOCKED: no test runner in txclient)
+- [ ] 5.3 Create `txclient/src/Store/__tests__/NotificationPreferences.Store.test.ts` — Test store actions: setMode, updateFormData, resetForm, dirty flag transitions (BLOCKED: no test runner in txclient)
+
+## Phase 6: Cleanup (if needed)
+
+- [x] 6.1 Remove any temporary console.log statements added during development
+- [x] 6.2 Verify all TypeScript types compile without errors
+- [x] 6.3 Confirm navigation links work in all three contexts (org, client, landing)

openspec/changes/notification-redesign/proposal.md

@@ -0,0 +1,90 @@
+# Proposal: Notification System Redesign
+
+## Intent
+
+The current notification system has three critical limitations: (1) notifications are sent synchronously during appointment lifecycle operations, blocking the API response; (2) the notification-sender worker only handles today's appointments with a global delay (no per-company throttling for WhatsApp rate limits); and (3) there are no per-company or per-client notification preferences — notifications are either on or off for the entire company. This redesign decouples notification delivery from business operations into a job-based, multi-channel, policy-driven system.
+
+## Scope
+
+### In Scope
+- New `NotificationJob` model: per-notification job records with status, channel, payload, retry state
+- New `CompanyNotificationPolicy` model: org-level defaults for channels, scheduling windows, WhatsApp throttle config
+- New `ClientNotificationPreferences` model: per-client opt-in/out per channel
+- New `ClientCompanyNotificationOverride` model: per-client per-org overrides
+- Policy resolution engine: Plan limits → Org override → Client prefs → Org default → System default
+- Redesigned notification-sender worker: MongoDB polling, per-company WhatsApp throttle (8–16s), multi-channel dispatch
+- Server integration: replace inline notification calls in `Appointments` with job creation
+- Multi-channel support: WhatsApp (Baileys), Email (DonWeb), System (in-app + Socket.IO)
+
+### Out of Scope
+- SMS channel (plan feature exists but not implemented today)
+- Notification templates / content builder
+- Client-facing notification preferences UI
+- Notification analytics / delivery reports
+- Push notifications (mobile)
+- Batch notification operations (e.g., "notify all clients about holiday")
+
+## Capabilities
+
+### New Capabilities
+- `notification-jobs`: Job creation, status tracking, retry logic, and lifecycle management for notification delivery
+- `notification-policies`: Company and client notification preferences, policy resolution hierarchy, channel configuration
+- `notification-worker`: Multi-channel job processor with per-company throttling and MongoDB polling
+- `notification-integration`: Server-side hooks that create notification jobs from appointment lifecycle events
+
+### Modified Capabilities
+None — no existing specs in `openspec/specs/`.
+
+## Approach
+
+**Server (job creation):** Replace inline `NotificationsManager.send*()` calls in `Appointments.ts` with `NotificationJobService.createJob()`. The service resolves the effective policy, checks plan limits, and persists a `NotificationJob` document. This makes API calls non-blocking.
+
+**notification-sender (worker):** Poll MongoDB for `status: "pending"` jobs. Process per-company with configurable WhatsApp throttle (default 8–16s between messages for same company). Email and System channels have no throttle. Failed jobs retry up to 3x with exponential backoff.
+
+**Policy resolution:** Resolve in order: Plan feature flags → `ClientCompanyNotificationOverride` (per-client per-org) → `ClientNotificationPreferences` (client global) → `CompanyNotificationPolicy` (org default) → System defaults (all channels on).
+
+**Migration:** No data migration needed — no pending notifications exist. New models are additive.
+
+## Affected Areas
+
+| Area | Impact | Description |
+|------|--------|-------------|
+| `notification-sender/src/` | New | Complete rewrite: job polling, multi-channel dispatch, throttle |
+| `server/src/Models/Notifications/` | Modified | Add job creation service; existing adapters remain for direct sends |
+| `server/src/Models/Appointments/Appointments.ts` | Modified | Replace inline sends with job creation calls |
+| `server/src/Models/Plans/Plans.interface.ts` | Unchanged | Plan features already define channel support |
+| New: `server/src/Models/NotificationJobs/` | New | NotificationJob model + adapter |
+| New: `server/src/Models/NotificationPolicies/` | New | Company/Client policy models + resolution engine |
+| New: `notification-sender/src/Models/Jobs/` | New | Job polling model for worker |
+
+## Risks
+
+| Risk | Likelihood | Mitigation |
+|------|------------|------------|
+| WhatsApp rate limit hit during high-volume periods | High | Per-company throttle (8–16s), exponential backoff on failures |
+| Job queue grows faster than worker processes | Medium | Monitor queue depth; add alerting on backlog threshold |
+| Policy resolution adds latency to appointment creation | Low | Resolution is a simple DB query cascade; cache per-request |
+| Breaking existing notification behavior during transition | Medium | Feature flag: keep inline sends as fallback during rollout |
+
+## Rollback Plan
+
+1. Disable job creation in server via feature flag (reverts to inline sends)
+2. Stop notification-sender worker
+3. Existing inline notification paths remain unchanged — no code removal needed until stable
+4. Job collection can be truncated without data loss (jobs are ephemeral)
+
+## Dependencies
+
+- MongoDB (shared across all modules) — already available
+- Baileys (txbot) — existing WhatsApp integration, no changes needed
+- DonWeb email API — existing integration, no changes needed
+- Socket.IO — existing in server, no changes needed
+
+## Success Criteria
+
+- [ ] Appointment creation/update/delete returns within normal latency (< 200ms)
+- [ ] WhatsApp messages for same company spaced ≥ 8s apart
+- [ ] Failed notifications retry up to 3x with exponential backoff
+- [ ] Policy resolution correctly cascades through hierarchy
+- [ ] Zero missed notifications during 24h soak test
+- [ ] notification-sender processes backlog within 5 minutes under normal load

openspec/config.yaml

@@ -0,0 +1,34 @@
+# SDD Configuration — turnosxpress
+# Generated: 2026-07-21
+
+context: |
+  Multi-module monorepo: Express+TypeScript server (tsoa, Mongoose, JWT),
+  Next.js 15 client (MUI, Zustand), WhatsApp bot (Baileys),
+  admin/sysadmin microservices, Android companion app.
+  MongoDB (Mongoose 8.x), OCI cloud storage, multi-region Docker deployment.
+  No workspace manager — independent modules.
+
+strict_tdd: true
+
+testing:
+  runner: jest
+  framework: Jest 30.x + ts-jest 29.x
+  command: "cd server && npx jest"
+  coverage: false
+  layers:
+    unit: true
+    integration: false
+    e2e: false
+  quality:
+    linter: "next lint (txclient), oxlint (sysadmin-cli)"
+    type_checker: tsc
+    formatter: none
+
+phases:
+  proposal: mandatory
+  spec: mandatory
+  design: mandatory
+  tasks: mandatory
+  apply: mandatory
+  verify: mandatory
+  archive: mandatory

resources/MEGA-CLAVEDERECUPERACION-hdrdevs.txt

@@ -0,0 +1 @@
+mO9PXuuYR05od8cMVCIXEw

resources/donweb/nginx-file.txt

@@ -0,0 +1,67 @@
+server {
+    server_name turnosxpress.com.ar www.turnosxpress.com.ar;
+
+    root /var/www/turnosxpress.com.ar;
+
+    location ^~ /.well-known/acme-challenge/ {
+        root /var/www/certbot;
+    }
+
+    #Sirvo el favicon desde la pagina de working
+    location = /favicon.ico {
+        root /var/www/working-web;
+        access_log off;
+        log_not_found off;
+    }
+
+    # Sitio web de Produccion
+    location / {
+        proxy_pass http://localhost:3021;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        client_max_body_size 5M;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    # Sitio web de Mantenimiento
+    #location / {
+    #    root /var/www/working-web;
+    #    index index.html;
+    #    try_files $uri $uri/ /index.html;
+    #    #Desactivar caché en los navegadores
+    #    add_header Cache-Control "no-store, no-cache, must-revalidate, max-age=0";
+    #    add_header Pragma "no-cache" always;
+    #    add_header Expires 0 always;
+    #}
+
+
+    listen 443 ssl; # managed by Certbot
+    ssl_certificate /etc/letsencrypt/live/turnosxpress.com.ar/fullchain.pem; # managed by Certbot
+    ssl_certificate_key /etc/letsencrypt/live/turnosxpress.com.ar/privkey.pem; # managed by Certbot
+    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
+    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
+
+
+}
+
+server {
+    if ($host = www.turnosxpress.com.ar) {
+        return 301 https://$host$request_uri;
+    } # managed by Certbot
+
+
+    if ($host = turnosxpress.com.ar) {
+        return 301 https://$host$request_uri;
+    } # managed by Certbot
+
+
+    listen 80;
+    server_name turnosxpress.com.ar www.turnosxpress.com.ar;
+    return 404; # managed by Certbot
+
+
+
+
+}

resources/firma-android/clave.txt

@@ -0,0 +1 @@
+Frx8us2W@

resources/ngrok.txt

@@ -0,0 +1,3 @@
+ngrok config add-authtoken 3I94dMHXyh3wjRjGBu0oGQ8D8h4_2yBusck6ZWHJBx7WcbBFf
+
+ngrok http 3000

resources/triptico-content.md

@@ -0,0 +1,274 @@
+# TurnosXpress — contenido actualizado para tríptico
+
+## 1. Mensaje principal
+
+**TurnosXpress es una plataforma para gestionar turnos, clientes, servicios, pagos y comunicación desde un solo lugar.**
+
+Pensada para profesionales, equipos y negocios que trabajan con reservas, permite ordenar la agenda diaria, publicar servicios online y facilitar que los clientes soliciten turnos desde cualquier dispositivo.
+
+### Frases sugeridas
+
+- **Tu agenda online, simple y organizada.**
+- **Reservá, administrá y comunicá mejor tus turnos.**
+- **Menos mensajes sueltos. Más control sobre tu agenda.**
+- **Turnos online para negocios que quieren trabajar mejor.**
+
+## 2. Qué es TurnosXpress
+
+TurnosXpress ayuda a negocios y profesionales a administrar sus reservas sin depender todo el tiempo del teléfono, los mensajes manuales o una agenda en papel.
+
+Con la plataforma, el negocio puede:
+
+- Crear su perfil público.
+- Publicar servicios.
+- Configurar días y horarios disponibles.
+- Administrar turnos por fecha, servicio, cliente y profesional.
+- Organizar clientes, pagos, caja y cuenta corriente.
+- Configurar notificaciones y comunicación por WhatsApp según el plan disponible.
+- Trabajar con colaboradores o profesionales dentro de una misma organización.
+- Mostrar información pública, opiniones, puntajes y profesionales cuando corresponda.
+
+El objetivo es que cada negocio tenga una agenda digital clara, una presencia online más profesional y herramientas de administración que acompañen el crecimiento.
+
+## 3. Público al que está dirigido
+
+TurnosXpress está pensado para cualquier actividad que trabaje con citas, reservas o atención por horarios.
+
+Ejemplos de rubros posibles:
+
+- Centros de estética y belleza.
+- Peluquerías y barberías.
+- Consultorios y profesionales independientes.
+- Clases particulares, talleres y capacitaciones.
+- Estudios, centros de bienestar y servicios personalizados.
+- Equipos con varios colaboradores que necesitan coordinar agendas.
+
+La plataforma sirve tanto para profesionales que trabajan solos como para organizaciones que necesitan distribuir servicios, horarios y turnos entre varias personas.
+
+## 4. Propuesta de valor
+
+### Reservas online para tus clientes
+
+Tus clientes pueden encontrar tus servicios y solicitar turnos desde el celular, la computadora o cualquier dispositivo conectado.
+
+### Agenda digital siempre ordenada
+
+Centralizá los turnos del negocio en una agenda clara, consultable por fecha, cliente, servicio y profesional.
+
+### Menos coordinación manual
+
+Reducí llamadas, mensajes repetidos y cruces de horarios. El sistema muestra disponibilidad según la configuración del negocio.
+
+### Administración del negocio
+
+Además de los turnos, TurnosXpress permite gestionar clientes, pagos, caja, descuentos y cuenta corriente.
+
+### Comunicación por WhatsApp
+
+La plataforma cuenta con herramientas para conectar WhatsApp y configurar avisos o notificaciones según las funciones disponibles en cada plan.
+
+### Presencia pública configurable
+
+Cada negocio puede publicar su perfil, servicios e información visible para clientes. También puede configurar la visibilidad de opiniones, puntajes y profesionales cuando el plan y la configuración lo permiten.
+
+### Planes para distintas etapas
+
+TurnosXpress ofrece un plan gratuito/base para comenzar y planes pagos para negocios que necesitan más capacidad, más herramientas o funciones avanzadas.
+
+## 5. Funciones principales
+
+### Agenda y turnos
+
+- Agenda digital por día.
+- Creación, edición, cancelación y movimiento de turnos.
+- Turnos asociados a clientes, servicios y profesionales.
+- Consulta de turnos próximos e históricos.
+- Soporte para turnos recurrentes según el plan disponible.
+
+### Servicios
+
+- Publicación de servicios con nombre, descripción, duración y precio.
+- Servicios públicos o privados.
+- Imagen, color y datos de ubicación.
+- Configuración de cupos o límites cuando corresponde.
+
+### Horarios y disponibilidad
+
+- Configuración de días y rangos horarios.
+- Horarios por organización o por colaborador/profesional.
+- Disponibilidad por servicio.
+- Control para que los clientes reserven dentro de los horarios habilitados.
+
+### Clientes
+
+- Registro y administración de clientes.
+- Historial de turnos por cliente.
+- Datos de contacto y preferencias.
+- Cuenta corriente y movimientos asociados.
+
+### Pagos, caja y cuenta corriente
+
+- Registro de pagos vinculados a turnos.
+- Estados de pago: pendiente, aprobado o rechazado.
+- Métodos como efectivo, transferencia, crédito, débito, cuenta corriente u otros.
+- Caja con movimientos, filtros y balance.
+- Cuenta corriente para controlar saldos y movimientos de clientes.
+
+### Colaboradores y profesionales
+
+- Administración de colaboradores dentro de una organización.
+- Roles y permisos.
+- Horarios y servicios asignados por profesional.
+- Visibilidad pública de profesionales cuando corresponde.
+
+### Notificaciones y WhatsApp
+
+- Configuración de notificaciones del negocio.
+- Preferencias generales y por cliente.
+- WhatsApp como canal principal para automatizar avisos según el plan y la configuración.
+- Asistente guiado para conectar y administrar WhatsApp.
+
+> Nota comercial: conviene comunicar WhatsApp como herramienta de conexión y avisos de la plataforma, no como integración oficial de WhatsApp Business API.
+
+### Opiniones y reputación
+
+- Opiniones verificadas vinculadas a organización, servicio o profesional.
+- Configuración para mostrar u ocultar opiniones y puntajes.
+- Herramientas para fortalecer la presencia pública del negocio.
+
+### Planes y MercadoPago
+
+- Plan gratuito/base para comenzar.
+- Planes pagos con mayor capacidad y funciones avanzadas.
+- Gestión de contratación o actualización de plan.
+- Pagos de planes procesados con MercadoPago.
+
+> Nota comercial: MercadoPago está confirmado para pagos de planes/suscripciones. No prometer cobro online de turnos a clientes salvo que se verifique esa funcionalidad para la campaña específica.
+
+## 6. Cómo empezar
+
+### Paso 1 — Registrate
+
+Creá tu cuenta en TurnosXpress y accedé al panel para comenzar a configurar tu negocio.
+
+URL sugerida:
+
+`https://turnosxpress.com.ar/landing/signup`
+
+### Paso 2 — Elegí tu plan
+
+Podés comenzar con el plan gratuito/base o elegir un plan pago según el tamaño y las necesidades de tu negocio.
+
+URL sugerida:
+
+`https://turnosxpress.com.ar/landing/pricing`
+
+### Paso 3 — Configurá tu negocio
+
+Creá el perfil de tu organización, cargá tus servicios, definí horarios y configurá colaboradores si trabajás con un equipo.
+
+### Paso 4 — Compartí tu enlace
+
+Publicá tu perfil o compartí el enlace de reserva para que tus clientes puedan solicitar turnos online.
+
+### Paso 5 — Administrá todo desde el panel
+
+Consultá la agenda, gestioná clientes, registrá pagos, revisá caja, configurá notificaciones y mantené el negocio organizado.
+
+## 7. Flujo de uso resumido
+
+1. El profesional o negocio se registra.
+2. Selecciona un plan.
+3. Crea el perfil de la organización.
+4. Carga servicios, horarios y colaboradores.
+5. Comparte su enlace o publica su perfil.
+6. El cliente elige servicio, día y horario disponible.
+7. El turno queda registrado en la agenda.
+8. El negocio administra la atención, los pagos y la comunicación desde el panel.
+
+## 8. Contenido sugerido para cara exterior del tríptico
+
+### Portada
+
+**TurnosXpress**
+
+**Tu agenda online, simple y organizada.**
+
+Gestioná turnos, clientes, servicios, pagos y comunicación desde una plataforma pensada para negocios que trabajan con reservas.
+
+**Probá TurnosXpress y empezá a ordenar tu agenda hoy.**
+
+### Panel de beneficios
+
+**Reservas online**  
+Tus clientes pueden solicitar turnos desde cualquier dispositivo.
+
+**Agenda digital**  
+Visualizá y administrá tus turnos de forma clara.
+
+**Clientes y pagos**  
+Centralizá información, movimientos, caja y cuenta corriente.
+
+**WhatsApp y notificaciones**  
+Configurá avisos y comunicación según tu plan.
+
+**Perfil público**  
+Mostrá tus servicios, profesionales, opiniones y puntajes cuando corresponda.
+
+### Llamado a la acción
+
+**Empezá gratis y configurá tu negocio en pocos pasos.**
+
+Sitio web: `https://turnosxpress.com.ar`  
+Email: `info@turnosxpress.com.ar`  
+Teléfono: `11-2390-2059`
+
+## 9. Contenido sugerido para cara interior del tríptico
+
+### Título interior
+
+**Todo lo que necesitás para administrar tus turnos en un solo lugar**
+
+### Bloque 1 — Configurá tu negocio
+
+Creá tu organización, cargá los servicios que ofrecés, definí duración, precio, ubicación y horarios disponibles.
+
+### Bloque 2 — Publicá y recibí reservas
+
+Compartí tu perfil o enlace de reserva para que tus clientes puedan elegir un servicio y solicitar un turno online.
+
+### Bloque 3 — Administrá tu día a día
+
+Consultá la agenda, gestioná clientes, registrá pagos, revisá caja y mantené el historial del negocio ordenado.
+
+### Bloque 4 — Sumá comunicación y visibilidad
+
+Configurá WhatsApp, notificaciones, opiniones, puntajes y profesionales visibles según el plan y la configuración de tu organización.
+
+### Bloque 5 — Crecé con planes flexibles
+
+Comenzá con el plan gratuito/base y pasá a un plan superior cuando necesites más capacidad o funciones avanzadas.
+
+## 10. Llamados a la acción recomendados
+
+- **Probá TurnosXpress gratis.**
+- **Creá tu agenda online hoy.**
+- **Compartí tus servicios y empezá a recibir reservas.**
+- **Ordená turnos, clientes y pagos desde un solo panel.**
+- **Digitalizá tu negocio sin complicarte.**
+
+## 11. Mensajes que conviene evitar o matizar
+
+- Evitar prometer SMS como función disponible actualmente.
+- Evitar decir “automatización multicanal completa” sin aclarar alcance por plan y configuración.
+- Evitar presentar WhatsApp como integración oficial de WhatsApp Business API.
+- Evitar prometer cobro online de turnos con MercadoPago si la campaña no verifica esa función específica.
+- Evitar enfocar el folleto en herramientas internas de sysadmin; no son beneficios directos para el negocio final.
+
+## 12. Resumen comercial
+
+TurnosXpress ya no es solamente una agenda online. Es una plataforma de gestión para negocios con turnos: permite publicar servicios, organizar disponibilidad, recibir reservas, administrar clientes, registrar pagos, controlar caja, trabajar con colaboradores y mejorar la comunicación con herramientas como WhatsApp y notificaciones configurables.
+
+El mensaje actualizado debe transmitir una idea central:
+
+**TurnosXpress ayuda a que el negocio trabaje más ordenado, atienda mejor y dependa menos de la coordinación manual.**

server/.env

@@ -45,7 +45,7 @@ MP_SUBSCRIPTION_FIND_URL = https://api.mercadopago.com/preapproval/
 MP_ACCESS_TOKEN = APP_USR-8753424836448507-121412-731599daea1ffa0b278b5dcc78aa1ec8-1611134648
 MP_BACK_URL = https://turnosxpress.com.ar/landing/dashboard
 MP_CHECK_PAYMENT_MINUTES = 1
-MP_WEBHOOK_URL = https://9300-186-132-200-176.ngrok-free.app/mercadopago/webhook
+MP_WEBHOOK_URL = https://5f09-186-58-32-217.ngrok-free.app/mercadopago/webhook
 
 DEFAULT_BOT_ADMIN_PORT = 3005
 
@@ -54,6 +54,7 @@ DONWEB_MAIL_API_KEY = eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpYXQiOjE3NDYxMTc3N
 WAP_TIME_LIMIT = 5000
 WAP_REMINDER = 🔔Hola <---CLIENTE---> <---BR---> 📌Te recuerdo que el <---FECHA---> te esperamos a las <---HORARIO---> ⏰ <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR--->Precio: <---PRECIO---> <---BR---> *<---ORGANIZACION--->*
 WAP_ALTA = 🔔Hola <---CLIENTE---> <---BR---> 📌Has realizado una reserva para el día <---FECHA--->  a las <---HORARIO---> ⏰ <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR--->Precio: <---PRECIO---> <---BR---> *<---ORGANIZACION--->*
+WAP_CANCELACION = 🔔Hola <---CLIENTE---> <---BR---> 📌Tu reserva para el día <---FECHA---> a las <---HORARIO---> fue cancelada. <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR---> *<---ORGANIZACION--->*
 
 GOOGLE_CLIENT_ID = 252287289364-bu8mquhttsaa282egh8su2sumvkjqe58.apps.googleusercontent.com
 
@@ -68,3 +69,8 @@ FILE_SERVER_URL = http://localhost:4000/
 FILE_SERVER_URL_prod = https://files.turnosxpress.com.ar/
 
 SYS_ADMIN_API_PUBLIC_KEY = keys/tx-sysadmin-public.key
+ARCA_ENVIRONMENT=homologation
+ARCA_WSAA_URL=https://wsaahomo.afip.gov.ar/ws/services/LoginCms
+ARCA_WSFE_URL=https://wswhomo.afip.gov.ar/wsfev1/service.asmx
+
+ARCA_CREDENTIALS_MASTER_KEY=ZmFrZS1kZXYtYXJjYS1tYXN0ZXIta2V5LTEyMzQ1Njc=

server/.env.android

@@ -53,6 +53,7 @@ DONWEB_MAIL_API_KEY = eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpYXQiOjE3NDYxMTc3N
 WAP_TIME_LIMIT = 5000
 WAP_REMINDER = 🔔Hola <---CLIENTE---> <---BR---> 📌Te recuerdo que el <---FECHA---> te esperamos a las <---HORARIO---> ⏰ <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR--->Precio: <---PRECIO---> <---BR---> *<---ORGANIZACION--->*
 WAP_ALTA = 🔔Hola <---CLIENTE---> <---BR---> 📌Has realizado una reserva para el día <---FECHA--->  a las <---HORARIO---> ⏰ <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR--->Precio: <---PRECIO---> <---BR---> *<---ORGANIZACION--->*
+WAP_CANCELACION = 🔔Hola <---CLIENTE---> <---BR---> 📌Tu reserva para el día <---FECHA---> a las <---HORARIO---> fue cancelada. <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR---> *<---ORGANIZACION--->*
 
 GOOGLE_CLIENT_ID = 252287289364-bu8mquhttsaa282egh8su2sumvkjqe58.apps.googleusercontent.com
 

server/.env.dev

@@ -53,6 +53,7 @@ DONWEB_MAIL_API_KEY = eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpYXQiOjE3NDYxMTc3N
 WAP_TIME_LIMIT = 5000
 WAP_REMINDER = 🔔Hola <---CLIENTE---> <---BR---> 📌Te recuerdo que el <---FECHA---> te esperamos a las <---HORARIO---> ⏰ <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR--->Precio: <---PRECIO---> <---BR---> *<---ORGANIZACION--->*
 WAP_ALTA = 🔔Hola <---CLIENTE---> <---BR---> 📌Has realizado una reserva para el día <---FECHA--->  a las <---HORARIO---> ⏰ <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR--->Precio: <---PRECIO---> <---BR---> *<---ORGANIZACION--->*
+WAP_CANCELACION = 🔔Hola <---CLIENTE---> <---BR---> 📌Tu reserva para el día <---FECHA---> a las <---HORARIO---> fue cancelada. <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR---> *<---ORGANIZACION--->*
 
 GOOGLE_CLIENT_ID = 252287289364-bu8mquhttsaa282egh8su2sumvkjqe58.apps.googleusercontent.com
 

server/.env.prod

@@ -53,6 +53,7 @@ WAP_TIME_LIMIT = 5000
 
 WAP_REMINDER = 🔔Hola <---CLIENTE---> <---BR---> 📌Te recuerdo que el <---FECHA---> te esperamos a las <---HORARIO---> ⏰ <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR--->Precio: <---PRECIO---> <---BR---> *<---ORGANIZACION--->*
 WAP_ALTA = 🔔Hola <---CLIENTE---> <---BR---> 📌Has realizado una reserva para el día <---FECHA--->  a las <---HORARIO---> ⏰ <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR--->Precio: <---PRECIO---> <---BR---> *<---ORGANIZACION--->*
+WAP_CANCELACION = 🔔Hola <---CLIENTE---> <---BR---> 📌Tu reserva para el día <---FECHA---> a las <---HORARIO---> fue cancelada. <---BR---> 🏫 En <---DIRECCION---> <---BR--->Con <---PROFESIONAL---> para <---SERVICIO---> <---BR---> *<---ORGANIZACION--->*
 
 GOOGLE_CLIENT_ID = 252287289364-bu8mquhttsaa282egh8su2sumvkjqe58.apps.googleusercontent.com
 
@@ -66,3 +67,8 @@ SYSTEM_KEY = ad7c956a-76bf-45hdr60-8a50-2ca7b2180997
 FILE_SERVER_URL = https://files.turnosxpress.com.ar/
 
 SYS_ADMIN_API_PUBLIC_KEY = keys/tx-sysadmin-public.key
+ARCA_ENVIRONMENT=production
+ARCA_WSAA_URL=https://wsaa.afip.gov.ar/ws/services/LoginCms
+ARCA_WSFE_URL=https://servicios1.afip.gov.ar/wsfev1/service.asmx
+
+ARCA_CREDENTIALS_MASTER_KEY=ZmFrZS1kZXYtYXJjYS1tYXN0ZXIta2V5LTEyMzQ1Njc=

server/package-lock.json

@@ -20,6 +20,7 @@
                 "jsonwebtoken": "^9.0.3",
                 "mongoose": "8.8.3",
                 "multer": "^1.4.5-lts.2",
+                "node-forge": "^1.4.0",
                 "nodemailer": "^6.10.1",
                 "sanitize-html": "^2.17.6",
                 "sharp": "^0.33.5",
@@ -33,6 +34,7 @@
                 "@types/express": "^4.17.25",
                 "@types/jest": "^30.0.0",
                 "@types/jsonwebtoken": "^9.0.10",
+                "@types/node-forge": "^1.3.14",
                 "@types/nodemailer": "^6.4.24",
                 "@types/sanitize-html": "^2.16.1",
                 "@types/socket.io": "^3.0.2",
@@ -775,9 +777,6 @@
             "cpu": [
                 "arm"
             ],
-            "libc": [
-                "glibc"
-            ],
             "license": "LGPL-3.0-or-later",
             "optional": true,
             "os": [
@@ -794,9 +793,6 @@
             "cpu": [
                 "arm64"
             ],
-            "libc": [
-                "glibc"
-            ],
             "license": "LGPL-3.0-or-later",
             "optional": true,
             "os": [
@@ -813,9 +809,6 @@
             "cpu": [
                 "s390x"
             ],
-            "libc": [
-                "glibc"
-            ],
             "license": "LGPL-3.0-or-later",
             "optional": true,
             "os": [
@@ -832,9 +825,6 @@
             "cpu": [
                 "x64"
             ],
-            "libc": [
-                "glibc"
-            ],
             "license": "LGPL-3.0-or-later",
             "optional": true,
             "os": [
@@ -851,9 +841,6 @@
             "cpu": [
                 "arm64"
             ],
-            "libc": [
-                "musl"
-            ],
             "license": "LGPL-3.0-or-later",
             "optional": true,
             "os": [
@@ -870,9 +857,6 @@
             "cpu": [
                 "x64"
             ],
-            "libc": [
-                "musl"
-            ],
             "license": "LGPL-3.0-or-later",
             "optional": true,
             "os": [
@@ -889,9 +873,6 @@
             "cpu": [
                 "arm"
             ],
-            "libc": [
-                "glibc"
-            ],
             "license": "Apache-2.0",
             "optional": true,
             "os": [
@@ -914,9 +895,6 @@
             "cpu": [
                 "arm64"
             ],
-            "libc": [
-                "glibc"
-            ],
             "license": "Apache-2.0",
             "optional": true,
             "os": [
@@ -939,9 +917,6 @@
             "cpu": [
                 "s390x"
             ],
-            "libc": [
-                "glibc"
-            ],
             "license": "Apache-2.0",
             "optional": true,
             "os": [
@@ -964,9 +939,6 @@
             "cpu": [
                 "x64"
             ],
-            "libc": [
-                "glibc"
-            ],
             "license": "Apache-2.0",
             "optional": true,
             "os": [
@@ -989,9 +961,6 @@
             "cpu": [
                 "arm64"
             ],
-            "libc": [
-                "musl"
-            ],
             "license": "Apache-2.0",
             "optional": true,
             "os": [
@@ -1014,9 +983,6 @@
             "cpu": [
                 "x64"
             ],
-            "libc": [
-                "musl"
-            ],
             "license": "Apache-2.0",
             "optional": true,
             "os": [
@@ -2119,6 +2085,16 @@
             "resolved": "https://registry.npmjs.org/@types/node/-/node-20.4.2.tgz",
             "integrity": "sha512-Dd0BYtWgnWJKwO1jkmTrzofjK2QXXcai0dmtzvIBhcA+RsG5h8R3xlyta0kGOZRNfL9GuRtb1knmPEhQrePCEw=="
         },
+        "node_modules/@types/node-forge": {
+            "version": "1.3.14",
+            "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.14.tgz",
+            "integrity": "sha512-mhVF2BnD4BO+jtOp7z1CdzaK4mbuK0LLQYAvdOLqHTavxFNq4zA1EmYkpnFjP8HOUzedfQkRnp0E2ulSAYSzAw==",
+            "dev": true,
+            "license": "MIT",
+            "dependencies": {
+                "@types/node": "*"
+            }
+        },
         "node_modules/@types/nodemailer": {
             "version": "6.4.24",
             "resolved": "https://registry.npmjs.org/@types/nodemailer/-/nodemailer-6.4.24.tgz",
@@ -6892,6 +6868,15 @@
                 "url": "https://opencollective.com/node-fetch"
             }
         },
+        "node_modules/node-forge": {
+            "version": "1.4.0",
+            "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.4.0.tgz",
+            "integrity": "sha512-LarFH0+6VfriEhqMMcLX2F7SwSXeWwnEAJEsYm5QKWchiVYVvJyV9v7UDvUv+w5HO23ZpQTXDv/GxdDdMyOuoQ==",
+            "license": "(BSD-3-Clause OR GPL-2.0)",
+            "engines": {
+                "node": ">= 6.13.0"
+            }
+        },
         "node_modules/node-int64": {
             "version": "0.4.0",
             "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",

server/package.json

@@ -19,6 +19,7 @@
         "@types/express": "^4.17.25",
         "@types/jest": "^30.0.0",
         "@types/jsonwebtoken": "^9.0.10",
+        "@types/node-forge": "^1.3.14",
         "@types/nodemailer": "^6.4.24",
         "@types/sanitize-html": "^2.16.1",
         "@types/socket.io": "^3.0.2",
@@ -42,6 +43,7 @@
         "jsonwebtoken": "^9.0.3",
         "mongoose": "8.8.3",
         "multer": "^1.4.5-lts.2",
+        "node-forge": "^1.4.0",
         "nodemailer": "^6.10.1",
         "sanitize-html": "^2.17.6",
         "sharp": "^0.33.5",

server/src/Models/AdminAssistant/AdminAssistant.Interface.ts

@@ -0,0 +1,45 @@
+import { ScheduleItem } from "../Schedules/Schedules.Interface";
+import { ISchedulesDisabled } from "../SchedulesDisabled/SchedulesDisabled.Interface";
+import { ISchedulesOverrides } from "../SchedulesOverrides/SchedulesOverrides.Interface";
+
+export type CollaboratorScheduleDetailsParams = {
+    companyId: string;
+    employeeId: string;
+    sessionUser: string;
+    fromDate?: Date;
+};
+
+export type CollaboratorScheduleDetailsCollaborator = {
+    employeeId: string;
+    fullName: string;
+    email: string;
+    avatar: string;
+    userId: string;
+};
+
+export type CollaboratorWeeklySchedule = {
+    companyId: string;
+    employeeId: string;
+    weekDay: number;
+    scheduleId: string;
+    schedules: ScheduleItem[];
+};
+
+export type CollaboratorScheduleServiceSummary = {
+    id: string;
+    name: string;
+};
+
+export type CollaboratorScheduleDetailsView = {
+    collaborator: CollaboratorScheduleDetailsCollaborator;
+    servicesById: Record<string, CollaboratorScheduleServiceSummary>;
+    weeklySchedules: CollaboratorWeeklySchedule[];
+    futureDisabledSchedules: ISchedulesDisabled[];
+    futureOverrides: ISchedulesOverrides[];
+};
+
+export interface IAdminAssistantManager {
+    getCollaboratorScheduleDetails(
+        data: CollaboratorScheduleDetailsParams
+    ): Promise<CollaboratorScheduleDetailsView>;
+}

server/src/Models/AdminAssistant/AdminAssistant.ts

@@ -0,0 +1,98 @@
+import dayjs from "dayjs";
+import EmployeesList from "../Employees/Employee";
+import ServicesList from "../Services/Service";
+import SchedulesList from "../Schedules/Schedules";
+import SchedulesDisabledList from "../SchedulesDisabled/SchedulesDisabled";
+import SchedulesOverridesList from "../SchedulesOverrides/SchedulesOverrides";
+import UsersManager from "../Users/Users";
+import getAvatar from "../../helpers/getAvatar";
+import { joinStrings } from "../../helpers/String";
+import { validatePermissionsByCompany, validateSessionUser } from "../../helpers/check";
+import {
+    CollaboratorScheduleDetailsParams,
+    CollaboratorScheduleDetailsView,
+    IAdminAssistantManager,
+} from "./AdminAssistant.Interface";
+
+class AdminAssistantManager implements IAdminAssistantManager {
+    public async getCollaboratorScheduleDetails(
+        data: CollaboratorScheduleDetailsParams
+    ): Promise<CollaboratorScheduleDetailsView> {
+        await validateSessionUser({ sessionUser: data.sessionUser });
+        await validatePermissionsByCompany({ companyId: data.companyId, sessionUser: data.sessionUser });
+
+        const employee = await EmployeesList.employees.findOne({
+            _id: data.employeeId,
+            companyId: data.companyId,
+        });
+
+        if (!employee) {
+            throw new Error("El colaborador no existe o no pertenece a la organización.");
+        }
+
+        const user = await UsersManager.users.findOne({ _id: String(employee.userId) });
+        const snapshot = employee.profileSnapshot || {};
+        const fullName = user
+            ? joinStrings([user.firstName, user.lastName], " ")
+            : joinStrings([snapshot.firstName, snapshot.lastName], " ");
+        const email = user?.email || snapshot.email || "";
+        const avatar = user
+            ? getAvatar(String(user.id), user.avatar, fullName)
+            : getAvatar(String(employee.userId), snapshot.avatar || "", fullName);
+        const fromDate = data.fromDate ? dayjs(data.fromDate).startOf("day").toDate() : dayjs().startOf("day").toDate();
+
+        const weeklySchedules = await SchedulesList.find({
+            companyId: data.companyId,
+            employeeId: data.employeeId,
+        });
+        const futureDisabledSchedules = await SchedulesDisabledList.find({
+            companyId: data.companyId,
+            employeeId: data.employeeId,
+            endDate: { $gte: fromDate } as any,
+            sessionUser: data.sessionUser,
+        });
+        const futureOverrides = await SchedulesOverridesList.find({
+            companyId: data.companyId,
+            employeeId: data.employeeId,
+            date: { $gte: fromDate } as any,
+        });
+        const companyServices = await ServicesList.findByCompanyId({ companyId: data.companyId });
+        const servicesById = companyServices.reduce((index, service) => {
+            index[service.id] = {
+                id: service.id,
+                name: service.name,
+            };
+            return index;
+        }, {} as CollaboratorScheduleDetailsView["servicesById"]);
+
+        return {
+            collaborator: {
+                employeeId: String(employee.id || employee._id),
+                fullName: fullName || email || "Colaborador",
+                email,
+                avatar,
+                userId: String(employee.userId),
+            },
+            servicesById,
+            weeklySchedules: weeklySchedules
+                .sort((a, b) => a.weekDay - b.weekDay)
+                .map((schedule) => ({
+                    companyId: String(schedule.companyId),
+                    employeeId: String(schedule.employeeId),
+                    scheduleId: String(schedule.id || (schedule as any)._id || ""),
+                    weekDay: schedule.weekDay,
+                    schedules: schedule.schedules || [],
+                })),
+            futureDisabledSchedules: futureDisabledSchedules.sort((a, b) =>
+                new Date(a.startDate).getTime() - new Date(b.startDate).getTime()
+            ),
+            futureOverrides: futureOverrides.sort((a, b) =>
+                new Date(a.date).getTime() - new Date(b.date).getTime()
+            ),
+        };
+    }
+}
+
+const AdminAssistantList = new AdminAssistantManager();
+
+export default AdminAssistantList;

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

@@ -36,14 +36,34 @@ export type FindAppointmentsByCollaboratorPaginatedParams = FindAppointmentsByCo
 export enum APPOINTMENT_NOTIFICATION_TYPE {
     "CREATION" = "creation",
     "REMINDER" = "reminder",
+    "UPDATE" = "update",
+    "CANCELLATION" = "cancellation",
 }
 
 export type SendAppointmentNotificationParams = {
+    appointmentId: string;
+    sessionUser?: string;
+    systemToken?: string;
+    type: APPOINTMENT_NOTIFICATION_TYPE;
+    channel?: "whatsapp" | "email";
+    allowClientCancellation?: boolean;
+};
+
+export type CreateImmediateAppointmentNotificationJobsParams = {
     appointmentId: string;
     sessionUser: string;
     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;
@@ -63,6 +83,7 @@ export type ChangeServiceParams = {
 export type SendWapSystemNotificationParams = {
     appointmentId: string;
     systemToken: string;
+    type: APPOINTMENT_NOTIFICATION_TYPE;
 };
 
 export type HeatMapConfig = {
@@ -121,6 +142,7 @@ export type UpdateAppointmentParams = {
 export type DeleteAppointmentParams = {
     id: string;
     validation?: boolean;
+    notification?: boolean;
     sessionUser: string;
 };
 
@@ -182,6 +204,8 @@ export interface AppointmentNotificationIntent {
     message: string;
     checkClient: IClientDocument;
     companyCheck: ICompanyDocument;
+    emailTemplateId?: string;
+    emailContext?: Record<string, unknown>;
 }
 
 export interface IAppointment {
@@ -315,6 +339,8 @@ export interface IAppointmentsManager {
     getAvailableDates(data: GetAvailableDatesParams): Promise<GetAvailableDatesResult>;
     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,9 +7,11 @@ import {
     AppointmentEvent,
     AppointmentEventByClient,
     AppointmentNotificationIntent,
+    AppointmentNotificationPreviewResult,
     ChangeEmployeeToOwnerParams,
     CountAppointmentsByMonthParams,
     CreateAppointmentParams,
+    CreateImmediateAppointmentNotificationJobsParams,
     DeleteAppointmentDiscountParams,
     DeleteAppointmentParams,
     DeleteAppointmentsByCompanyParams,
@@ -76,6 +78,7 @@ import SchedulesDisabledList from "../SchedulesDisabled/SchedulesDisabled";
 import DiscountsEmail from "../DiscountsEmail/DiscountsEmail";
 import SchedulesOverridesList from "../SchedulesOverrides/SchedulesOverrides";
 import { NotificationType } from "../../Models/SystemNotifications/SystemNotification.Interface";
+import { NotificationJobService } from "../NotificationPolicies/NotificationJobService";
 
 dayjs.locale("es");
 dayjs.extend(isSameOrAfter);
@@ -84,9 +87,11 @@ dayjs.extend(weekday);
 
 class AppointmentManager implements IAppointmentsManager {
     Appointments: AppointmentsAdapterMongoose;
+    private jobService: NotificationJobService;
 
     constructor() {
         this.Appointments = new AppointmentsAdapterMongoose();
+        this.jobService = new NotificationJobService();
     }
 
     private isScheduleAvailableForService(schedule: ScheduleItem, serviceId?: string): boolean {
@@ -282,6 +287,23 @@ class AppointmentManager implements IAppointmentsManager {
         return parseInt(`${process.env.CANCELLATION_TIME}`) || 24;
     }
 
+    private formatAppointmentDuration(startHour: number, endHour: number): string {
+        const durationHours = endHour >= startHour ? endHour - startHour : endHour + 24 - startHour;
+        const durationMinutes = Math.round(durationHours * 60);
+        const hours = Math.floor(durationMinutes / 60);
+        const minutes = durationMinutes % 60;
+
+        if (hours > 0 && minutes > 0) {
+            return `${hours} ${hours === 1 ? "hora" : "horas"} y ${minutes} minutos`;
+        }
+
+        if (hours > 0) {
+            return `${hours} ${hours === 1 ? "hora" : "horas"}`;
+        }
+
+        return `${minutes} minutos`;
+    }
+
     private validateCancellationTime(aTime: number | undefined, start: string | Date): boolean {
         let cancellationTime = this.getCancellationTime(aTime);
 
@@ -512,7 +534,7 @@ class AppointmentManager implements IAppointmentsManager {
 
             await this.updateHeatMap(availabilityConfig);
 
-            await this.tryApplyDiscounts(newAppointment);
+            await this.tryApplyDiscounts(newAppointment, String(companyCheck.ownerId));
 
             if (notification && checkClient.userId) {
                 //Envio la notificacion al cliente.
@@ -525,38 +547,22 @@ class AppointmentManager implements IAppointmentsManager {
                 type: NotificationType.APPOINTMENT,
                 code: String((newAppointment as any)._id)
             });
+            }
 
-                //Intento enviar notificacion al cliente por Email
+            //Create jobs for email and whatsapp notifications
-                try {
+            if (this.shouldCreateCustomerNotificationJobs(notification, data.repeatId) && newAppointment.id) {
-                    if (newAppointment.id) {
+                await this.createAppointmentNotificationJobs({
-                        await this.sendEmailNotification({
+                    appointmentId: String(newAppointment.id),
-                            appointmentId: String(newAppointment.id),
+                    companyId: String(companyCheck._id),
-                            type: APPOINTMENT_NOTIFICATION_TYPE.CREATION,
+                    clientId: String(checkClient._id),
-                            sessionUser: String(companyCheck.ownerId),
+                    clientUserId: checkClient.userId ? String(checkClient.userId) : undefined,
-                        });
+                    clientEmail: checkClient.email,
-                    }
+                    client: checkClient,
-                } catch (err) {
+                    companyOwnerId: String(companyCheck.ownerId),
-                    console.log(
+                    companyName: companyCheck.name,
-                        `Error al enviar la notificacion por Email para  ${companyCheck.name}(${companyCheck._id}):`,
+                    appointmentStart: new Date(data.start),
-                        err
+                    notification,
-                    );
+                });
-                }
-
-                //Intento enviar notificacion al cliente por Whatsapp
-                try {
-                    if (newAppointment.id) {
-                        await this.sendWapNotification({
-                            appointmentId: String(newAppointment.id),
-                            type: APPOINTMENT_NOTIFICATION_TYPE.CREATION,
-                            sessionUser: String(companyCheck.ownerId),
-                        });
-                    }
-                } catch (err) {
-                    console.log(
-                        `Error al enviar la notificacion por Whatsapp para  ${companyCheck.name}(${companyCheck._id}):`,
-                        err
-                    );
-                }
             }
 
             //Envio la notificacion al profesional.
@@ -586,7 +592,7 @@ class AppointmentManager implements IAppointmentsManager {
         }
     }
 
-    private async tryApplyDiscounts(appointment: IAppointment) {
+    private async tryApplyDiscounts(appointment: IAppointment, sessionUser: string) {
         //Intenta aplicar un descuento al turno si esta especificado en DiscountsEmail
         // y la fecha coincide con el rango especificado.
 
@@ -626,7 +632,7 @@ class AppointmentManager implements IAppointmentsManager {
                 appointmentId: String(appointment.id),
                 discountId: String(existDiscount.discountId),
                 companyId: String(appointment.companyId),
-                sessionUser: String(appointment.userId),
+                sessionUser: sessionUser,
             });
         } catch (err) {
             console.log(err);
@@ -681,6 +687,47 @@ class AppointmentManager implements IAppointmentsManager {
         // Update both heatmaps
         await this.updateHeatMap(originalConfig);
         await this.updateHeatMap(newConfig);
+
+        // Reprogram pending notification jobs for the new date/time. The appointment
+        // was already saved, so tryToSendNotification reads the new start date and
+        // builds the reminder content (email template included) from it.
+        try {
+            // Cancel the jobs scheduled for the original date/time so they don't fire late.
+            await this.jobService.cancelByAppointment(String(appointment._id));
+
+            const reminderEmailContent = await this.tryToSendNotification({
+                appointmentId: String(appointment._id),
+                sessionUser: data.sessionUser || "",
+                type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
+                channel: "email",
+            });
+            const reminderWapContent = await this.tryToSendNotification({
+                appointmentId: String(appointment._id),
+                sessionUser: data.sessionUser || "",
+                type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
+                channel: "whatsapp",
+            });
+
+            await this.createReminderNotificationJobs({
+                appointmentId: String(appointment._id),
+                companyId: String(appointment.companyId),
+                clientId: String(appointment.clientId),
+                clientUserId: reminderEmailContent.checkClient.userId
+                    ? String(reminderEmailContent.checkClient.userId)
+                    : undefined,
+                clientEmail: reminderEmailContent.checkClient.email,
+                clientPhoneNumber: await this.getOptionalClientWapNumber(reminderEmailContent.checkClient),
+                companyOwnerId: String(reminderEmailContent.companyCheck.ownerId),
+                companyName: reminderEmailContent.companyCheck.name,
+                appointmentStart: appointment.start,
+                reminderEmailMessage: reminderEmailContent.message,
+                reminderWapMessage: reminderWapContent.message,
+                reminderEmailTemplateId: reminderEmailContent.emailTemplateId,
+                reminderEmailContext: reminderEmailContent.emailContext,
+            });
+        } catch (error) {
+            console.log("Error reprogramming notification jobs after move:", error);
+        }
     }
 
     public async changeServiceForce(data: ChangeServiceParams): Promise<void> {
@@ -2070,36 +2117,50 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
                 code: String(checkAppointment._id)
             });
 
-                //Intento enviar notificacion al cliente por Email
+                //Cancel existing pending jobs before creating new ones for the rescheduled appointment
-                try {
+                if (checkAppointment.id) {
-                    if (checkAppointment.id) {
+                    await this.jobService.cancelByAppointment(String(checkAppointment.id));
-                        await this.sendEmailNotification({
-                            appointmentId: String(checkAppointment.id),
-                            type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
-                            sessionUser: String(companyCheck.ownerId),
-                        });
-                    }
-                } catch (err) {
-                    console.log(
-                        `Error al enviar la notificacion por Email para  ${companyCheck.name}(${companyCheck._id}):`,
-                        err
-                    );
-                }
 
-                //Intento enviar notificacion al cliente por Whatsapp
+                    const emailContent = await this.tryToSendNotification({
-                try {
+                        appointmentId: String(checkAppointment.id),
-                    if (checkAppointment.id) {
+                        sessionUser: String(companyCheck.ownerId),
-                        await this.sendWapNotification({
+                        type: APPOINTMENT_NOTIFICATION_TYPE.UPDATE,
-                            appointmentId: String(checkAppointment.id),
+                        channel: "email",
-                            type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
+                    });
-                            sessionUser: String(companyCheck.ownerId),
+                    const wapContent = await this.tryToSendNotification({
-                        });
+                        appointmentId: String(checkAppointment.id),
-                    }
+                        sessionUser: String(companyCheck.ownerId),
-                } catch (err) {
+                        type: APPOINTMENT_NOTIFICATION_TYPE.UPDATE,
-                    console.log(
+                        channel: "whatsapp",
-                        `Error al enviar la notificacion por Whatsapp para  ${companyCheck.name}(${companyCheck._id}):`,
+                    });
-                        err
+                    const reminderEmailContent = await this.tryToSendNotification({
-                    );
+                        appointmentId: String(checkAppointment.id),
+                        sessionUser: String(companyCheck.ownerId),
+                        type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
+                        channel: "email",
+                    });
+                    const reminderWapContent = await this.tryToSendNotification({
+                        appointmentId: String(checkAppointment.id),
+                        sessionUser: String(companyCheck.ownerId),
+                        type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
+                        channel: "whatsapp",
+                    });
+
+                    await this.createUpdateNotificationJobs({
+                        appointmentId: String(checkAppointment.id),
+                        companyId: String(companyCheck._id),
+                        clientId: String(checkClient._id),
+                        clientUserId: checkClient.userId ? String(checkClient.userId) : undefined,
+                        clientEmail: checkClient.email,
+                        clientPhoneNumber: await this.getOptionalClientWapNumber(checkClient),
+                        companyOwnerId: String(companyCheck.ownerId),
+                        companyName: companyCheck.name,
+                        appointmentStart: new Date(data.start),
+                        emailMessage: emailContent.message,
+                        wapMessage: wapContent.message,
+                        reminderEmailMessage: reminderEmailContent.message,
+                        reminderWapMessage: reminderWapContent.message,
+                    });
                 }
             }
 
@@ -2155,8 +2216,271 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
         return config;
     }
 
+    private async createCancellationNotificationJobs(data: {
+        appointmentId: string;
+        companyId: string;
+        clientId: string;
+        clientUserId?: string;
+        clientEmail?: string;
+        clientPhoneNumber?: string;
+        companyOwnerId: string;
+        companyName: string;
+        emailMessage: string;
+        emailTemplateId?: string;
+        emailContext?: Record<string, unknown>;
+        wapMessage: string;
+    }): Promise<void> {
+        const systemSubject = `Turno cancelado en ${data.companyName}`;
+
+        await this.jobService.createJob({
+            companyId: data.companyId,
+            clientId: data.clientId,
+            appointmentId: data.appointmentId,
+            type: "cancellation",
+            scheduledAt: new Date(),
+            payload: {
+                email: data.clientEmail,
+                phoneNumber: data.clientPhoneNumber,
+                userId: data.clientUserId,
+                companyOwnerId: data.companyOwnerId,
+                subject: systemSubject,
+                message: data.emailMessage,
+                emailSubject: "TurnosXpress :: Turno cancelado",
+                emailMessage: data.emailMessage,
+                emailTemplateId: data.emailTemplateId,
+                emailContext: data.emailContext,
+                wapMessage: data.wapMessage,
+                systemSubject,
+                systemMessage: data.emailMessage,
+            },
+        });
+    }
+
+    private async createCreationNotificationJobs(data: {
+        appointmentId: string;
+        companyId: string;
+        clientId: string;
+        clientUserId?: string;
+        clientEmail?: string;
+        clientPhoneNumber?: string;
+        companyOwnerId: string;
+        companyName: string;
+        appointmentStart: Date;
+        emailMessage: string;
+        wapMessage: string;
+        emailTemplateId?: string;
+        emailContext?: Record<string, unknown>;
+        reminderEmailMessage: string;
+        reminderWapMessage: string;
+        reminderEmailTemplateId?: string;
+        reminderEmailContext?: Record<string, unknown>;
+    }): Promise<void> {
+        const systemSubject = `Turno reservado en ${data.companyName}`;
+
+        const payload = {
+            email: data.clientEmail,
+            phoneNumber: data.clientPhoneNumber,
+            userId: data.clientUserId,
+            companyOwnerId: data.companyOwnerId,
+            subject: systemSubject,
+            message: data.emailMessage,
+            emailSubject: "TurnosXpress :: Alta de turno",
+            emailMessage: data.emailMessage,
+            emailTemplateId: data.emailTemplateId,
+            emailContext: data.emailContext,
+            wapMessage: data.wapMessage,
+            systemSubject,
+            systemMessage: data.emailMessage,
+        };
+
+        await this.jobService.createMandatoryCreationJob({
+            companyId: data.companyId,
+            clientId: data.clientId,
+            appointmentId: data.appointmentId,
+            type: "creation",
+            payload,
+        });
+
+        await this.createReminderNotificationJobs(data);
+    }
+
+    private shouldCreateCustomerNotificationJobs(notification: boolean, repeatId?: string): boolean {
+        return notification || Boolean(repeatId);
+    }
+
+    private async createAppointmentNotificationJobs(data: {
+        appointmentId: string;
+        companyId: string;
+        clientId: string;
+        clientUserId?: string;
+        clientEmail?: string;
+        client: IClientDocument;
+        companyOwnerId: string;
+        companyName: string;
+        appointmentStart: Date;
+        notification: boolean;
+    }): Promise<void> {
+        const clientPhoneNumber = await this.getOptionalClientWapNumber(data.client);
+        const reminderEmailContent = await this.tryToSendNotification({
+            appointmentId: data.appointmentId,
+            sessionUser: data.companyOwnerId,
+            type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
+            channel: "email",
+        });
+        const reminderWapContent = await this.tryToSendNotification({
+            appointmentId: data.appointmentId,
+            sessionUser: data.companyOwnerId,
+            type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
+            channel: "whatsapp",
+        });
+
+        const notificationJobData = {
+            appointmentId: data.appointmentId,
+            companyId: data.companyId,
+            clientId: data.clientId,
+            clientUserId: data.clientUserId,
+            clientEmail: data.clientEmail,
+            clientPhoneNumber,
+            companyOwnerId: data.companyOwnerId,
+            companyName: data.companyName,
+            appointmentStart: data.appointmentStart,
+            reminderEmailMessage: reminderEmailContent.message,
+            reminderEmailTemplateId: reminderEmailContent.emailTemplateId,
+            reminderEmailContext: reminderEmailContent.emailContext,
+            reminderWapMessage: reminderWapContent.message,
+        };
+
+        if (!data.notification) {
+            await this.createReminderNotificationJobs(notificationJobData);
+            return;
+        }
+
+        const emailContent = await this.tryToSendNotification({
+            appointmentId: data.appointmentId,
+            sessionUser: data.companyOwnerId,
+            type: APPOINTMENT_NOTIFICATION_TYPE.CREATION,
+            channel: "email",
+        });
+        const wapContent = await this.tryToSendNotification({
+            appointmentId: data.appointmentId,
+            sessionUser: data.companyOwnerId,
+            type: APPOINTMENT_NOTIFICATION_TYPE.CREATION,
+            channel: "whatsapp",
+        });
+
+        await this.createCreationNotificationJobs({
+            ...notificationJobData,
+            emailMessage: emailContent.message,
+            emailTemplateId: emailContent.emailTemplateId,
+            emailContext: emailContent.emailContext,
+            wapMessage: wapContent.message,
+        });
+    }
+
+    private async createReminderNotificationJobs(data: {
+        appointmentId: string;
+        companyId: string;
+        clientId: string;
+        clientUserId?: string;
+        clientEmail?: string;
+        clientPhoneNumber?: string;
+        companyOwnerId: string;
+        companyName: string;
+        appointmentStart: Date;
+        reminderEmailMessage: string;
+        reminderWapMessage: string;
+        reminderEmailTemplateId?: string;
+        reminderEmailContext?: Record<string, unknown>;
+    }): Promise<void> {
+        const reminderSystemSubject = `Recordatorio de turno en ${data.companyName}`;
+
+        await this.jobService.createReminderJobs({
+            companyId: data.companyId,
+            clientId: data.clientId,
+            appointmentId: data.appointmentId,
+            type: "reminder",
+            appointmentStart: data.appointmentStart,
+            reminderPayload: {
+                email: data.clientEmail,
+                phoneNumber: data.clientPhoneNumber,
+                userId: data.clientUserId,
+                companyOwnerId: data.companyOwnerId,
+                subject: reminderSystemSubject,
+                message: data.reminderEmailMessage,
+                emailSubject: "TurnosXpress :: Recordatorio",
+                emailMessage: data.reminderEmailMessage,
+                emailTemplateId: data.reminderEmailTemplateId,
+                emailContext: data.reminderEmailContext,
+                wapMessage: data.reminderWapMessage,
+                systemSubject: reminderSystemSubject,
+                systemMessage: data.reminderEmailMessage,
+            },
+        });
+    }
+
+    private async createUpdateNotificationJobs(data: {
+        appointmentId: string;
+        companyId: string;
+        clientId: string;
+        clientUserId?: string;
+        clientEmail?: string;
+        clientPhoneNumber?: string;
+        companyOwnerId: string;
+        companyName: string;
+        appointmentStart: Date;
+        emailMessage: string;
+        wapMessage: string;
+        reminderEmailMessage: string;
+        reminderWapMessage: string;
+    }): Promise<void> {
+        const systemSubject = `Turno actualizado en ${data.companyName}`;
+        const reminderSystemSubject = `Recordatorio de turno en ${data.companyName}`;
+
+        await this.jobService.createJob({
+            companyId: data.companyId,
+            clientId: data.clientId,
+            appointmentId: data.appointmentId,
+            type: "update",
+            appointmentStart: data.appointmentStart,
+            payload: {
+                email: data.clientEmail,
+                phoneNumber: data.clientPhoneNumber,
+                userId: data.clientUserId,
+                companyOwnerId: data.companyOwnerId,
+                subject: systemSubject,
+                message: data.emailMessage,
+                emailSubject: "TurnosXpress :: Turno actualizado",
+                emailMessage: data.emailMessage,
+                wapMessage: data.wapMessage,
+                systemSubject,
+                systemMessage: data.emailMessage,
+            },
+            reminderPayload: {
+                email: data.clientEmail,
+                phoneNumber: data.clientPhoneNumber,
+                userId: data.clientUserId,
+                companyOwnerId: data.companyOwnerId,
+                subject: reminderSystemSubject,
+                message: data.reminderEmailMessage,
+                emailSubject: "TurnosXpress :: Recordatorio",
+                emailMessage: data.reminderEmailMessage,
+                wapMessage: data.reminderWapMessage,
+                systemSubject: reminderSystemSubject,
+                systemMessage: data.reminderEmailMessage,
+            },
+        });
+    }
+
+    private async getOptionalClientWapNumber(client: IClientDocument): Promise<string | undefined> {
+        try {
+            return await ClientsManager.getClientWapNumber(client);
+        } catch {
+            return undefined;
+        }
+    }
+
     public async deleteAppointment(data: DeleteAppointmentParams): Promise<void> {
-        const { validation = false } = data;
+        const { validation = false, notification = false } = data;
         const sessionUser = await UsersManager.users.findOne({
             _id: data.sessionUser,
         });
@@ -2234,23 +2558,45 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
         try {
             const config = this.getHeatMapConfig(checkAppointment, serviceCheck.length);
 
+            // Cancel pending notification jobs for this appointment before deleting it
+            await this.jobService.cancelByAppointment(String(checkAppointment._id));
+
+            if (notification) {
+                const emailContent = await this.tryToSendNotification({
+                    appointmentId: String(checkAppointment._id),
+                    sessionUser: data.sessionUser,
+                    type: APPOINTMENT_NOTIFICATION_TYPE.CANCELLATION,
+                    channel: "email",
+                    allowClientCancellation: true,
+                });
+                const wapContent = await this.tryToSendNotification({
+                    appointmentId: String(checkAppointment._id),
+                    sessionUser: data.sessionUser,
+                    type: APPOINTMENT_NOTIFICATION_TYPE.CANCELLATION,
+                    channel: "whatsapp",
+                    allowClientCancellation: true,
+                });
+
+                await this.createCancellationNotificationJobs({
+                    companyId: String(checkAppointment.companyId),
+                    clientId: String(checkAppointment.clientId),
+                    appointmentId: String(checkAppointment._id),
+                    clientUserId: checkClient.userId ? String(checkClient.userId) : undefined,
+                    clientEmail: checkClient.email,
+                    clientPhoneNumber: await this.getOptionalClientWapNumber(checkClient),
+                    companyOwnerId: String(companyCheck.ownerId),
+                    companyName: companyCheck.name,
+                    emailMessage: emailContent.message,
+                    emailTemplateId: emailContent.emailTemplateId,
+                    emailContext: emailContent.emailContext,
+                    wapMessage: wapContent.message,
+                });
+            }
+
             await this.Appointments.AppointmentList.deleteOne({ _id: data.id });
             //Actualizar el heatmap.
             await this.updateHeatMap(config);
 
-            if (checkClient.userId) {
-                //Enviamos la notificacion de cancelacion al cliente
-                await NotificationsManager.sendSystemNotification({
-                userId: String(checkClient.userId),
-                subject: "Turno Cancelado",
-                message: `Se ha cancelado el turno para el día ${dayjs(checkAppointment.start).format(
-                        "DD/MM/YYYY"
-                    )} a las ${dayjs(checkAppointment.start).format("HH:mm")}`,
-                type: NotificationType.APPOINTMENT,
-                code: String(checkAppointment._id)
-            });
-            }
-
             //Enviamos la notificacion de cancelacion al profesional
             await NotificationsManager.sendSystemNotification({
                 userId: String(employeeCheck.userId),
@@ -2384,10 +2730,6 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
             throw new Error("La compañia no existe");
         }
 
-        if (!(await EmployeesList.checkPermission(companyCheck, data.sessionUser, EmployeeRoles.ADMIN))) {
-            throw new Error(NoPermissionMessage());
-        }
-
         const checkClient = await ClientsManager.clients.findOne({
             _id: String(checkAppointment.clientId),
         });
@@ -2396,6 +2738,26 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
             throw new Error("El cliente no existe");
         }
 
+        const hasSystemToken = this.hasValidSystemToken(data.systemToken);
+
+        if (!hasSystemToken) {
+            if (!data.sessionUser) {
+                throw new Error("No se ha encontrado el usuario o no tiene permisos para realizar esta acción");
+            }
+
+            const isAuthorizedClientCancellation =
+                data.allowClientCancellation === true &&
+                data.type === APPOINTMENT_NOTIFICATION_TYPE.CANCELLATION &&
+                String(checkClient.userId) === data.sessionUser;
+
+            if (
+                !isAuthorizedClientCancellation &&
+                !(await EmployeesList.checkPermission(companyCheck, data.sessionUser, EmployeeRoles.ADMIN))
+            ) {
+                throw new Error(NoPermissionMessage());
+            }
+        }
+
         const checkEmployee = await EmployeesList.employees.findOne({
             _id: String(checkAppointment.employeeId),
         });
@@ -2421,6 +2783,8 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
         }
 
         let wapMessage = "";
+        let emailTemplateId: string | undefined;
+        let emailContext: Record<string, unknown> | undefined;
 
         if (data.type == APPOINTMENT_NOTIFICATION_TYPE.REMINDER) {
             if (companyCheck.templateWapNotifId) {
@@ -2464,10 +2828,27 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
 
             wapMessage = wapMessage.replaceAll("<---ORGANIZACION--->", companyCheck.name);
             wapMessage = wapMessage.replaceAll("<---BR--->", "\r\n");
+
+            emailTemplateId = "6a86ef631898c6948d0f5308";
+            emailContext = {
+                username: ClientsManager.getClientFullName(checkClient),
+                nombre_organizacion: companyCheck.name,
+                fecha_turno: dayjs(checkAppointment.start).format("DD/MM/YYYY"),
+                hora_turno: dayjs(checkAppointment.start).format("HH:mm") + "hs.",
+                nombre_servicio: checkService.name,
+                nombre_profesional: UsersManager.getUserFullName(checkEmployeeUser),
+                duracion: this.formatAppointmentDuration(checkAppointment.startHour, checkAppointment.endHour),
+                precio: formatCurrency(checkAppointment.price),
+                direccion: CompaniesManager.getCompanyAddress(companyCheck),
+            };
         } else if (data.type == APPOINTMENT_NOTIFICATION_TYPE.CREATION) {
-            if (companyCheck.templateWapAltaId) {
+            const templateId = data.channel === "email"
+                ? companyCheck.templateEmailAltaId || companyCheck.templateWapAltaId
+                : companyCheck.templateWapAltaId;
+
+            if (templateId) {
                 const template = await Templates.templates.findOne({
-                    id: String(companyCheck.templateWapAltaId),
+                    id: String(templateId),
                     companyId: String(companyCheck._id),
                 });
 
@@ -2477,7 +2858,9 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
             }
 
             if (!wapMessage) {
-                wapMessage = process.env.WAP_ALTA ? process.env.WAP_ALTA : "";
+                wapMessage = data.channel === "email"
+                    ? process.env.EMAIL_NEW_APPOINTMENT || process.env.EMAIL_ALTA || process.env.WAP_ALTA || ""
+                    : process.env.WAP_ALTA || "";
             }
 
             wapMessage = wapMessage.replaceAll(
@@ -2507,25 +2890,119 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
 
             wapMessage = wapMessage.replaceAll("<---ORGANIZACION--->", companyCheck.name);
             wapMessage = wapMessage.replaceAll("<---BR--->", "\r\n");
+
+            emailTemplateId = "6a86f55e3edd051e8a04c711";
+            emailContext = {
+                username: ClientsManager.getClientFullName(checkClient),
+                nombre_organizacion: companyCheck.name,
+                fecha_turno: dayjs(checkAppointment.start).format("DD/MM/YYYY"),
+                hora_turno: dayjs(checkAppointment.start).format("HH:mm") + "hs.",
+                nombre_servicio: checkService.name,
+                nombre_profesional: UsersManager.getUserFullName(checkEmployeeUser),
+                duracion: this.formatAppointmentDuration(checkAppointment.startHour, checkAppointment.endHour),
+                precio: formatCurrency(checkAppointment.price),
+                direccion: CompaniesManager.getCompanyAddress(companyCheck),
+            };
+        } else if (data.type == APPOINTMENT_NOTIFICATION_TYPE.CANCELLATION || data.type == APPOINTMENT_NOTIFICATION_TYPE.UPDATE) {
+            const isUpdate = data.type == APPOINTMENT_NOTIFICATION_TYPE.UPDATE;
+            const templateId = data.channel === "email"
+                ? isUpdate
+                    ? companyCheck.templateEmailAltaId || companyCheck.templateWapAltaId
+                    : companyCheck.templateEmailCancellationId || companyCheck.templateWapCancellationId
+                : isUpdate
+                    ? companyCheck.templateWapAltaId
+                    : companyCheck.templateWapCancellationId;
+
+            if (templateId) {
+                const template = await Templates.templates.findOne({
+                    id: String(templateId),
+                    companyId: String(companyCheck._id),
+                });
+
+                if (template) {
+                    wapMessage = template.template;
+                }
+            }
+
+            if (!wapMessage) {
+                wapMessage = data.channel === "email"
+                    ? isUpdate
+                        ? process.env.EMAIL_NEW_APPOINTMENT || process.env.EMAIL_ALTA || process.env.WAP_ALTA || ""
+                        : process.env.EMAIL_CANCELLATION || process.env.EMAIL_CANCELACION || process.env.WAP_CANCELLATION || process.env.WAP_CANCELACION || ""
+                    : isUpdate
+                        ? process.env.WAP_ALTA || ""
+                        : process.env.WAP_CANCELLATION || process.env.WAP_CANCELACION || "";
+            }
+
+            wapMessage = wapMessage.replaceAll(
+                "<---CLIENTE--->",
+                ClientsManager.getClientFullName(checkClient)
+            );
+            wapMessage = wapMessage.replaceAll(
+                "<---FECHA--->",
+                dayjs(checkAppointment.start).format("DD/MM/YYYY")
+            );
+            wapMessage = wapMessage.replaceAll(
+                "<---HORARIO--->",
+                dayjs(checkAppointment.start).format("HH:mm") + "hs."
+            );
+            wapMessage = wapMessage.replaceAll(
+                "<---DIRECCION--->",
+                CompaniesManager.getCompanyAddress(companyCheck)
+            );
+            wapMessage = wapMessage.replaceAll(
+                "<---PROFESIONAL--->",
+                UsersManager.getUserFullName(checkEmployeeUser)
+            );
+            wapMessage = wapMessage.replaceAll("<---SERVICIO--->", checkService.name);
+            wapMessage = wapMessage.replaceAll("<---PRECIO--->", formatCurrency(checkAppointment.price));
+            wapMessage = wapMessage.replaceAll("<---ORGANIZACION--->", companyCheck.name);
+            wapMessage = wapMessage.replaceAll("<---BR--->", "\r\n");
+
+            emailTemplateId = isUpdate
+                ? "6a86febf6713e0bdd104c7ca"
+                : "6a86f77d376a7371170b21c5";
+            emailContext = {
+                username: ClientsManager.getClientFullName(checkClient),
+                nombre_organizacion: companyCheck.name,
+                fecha_turno: dayjs(checkAppointment.start).format("DD/MM/YYYY"),
+                hora_turno: dayjs(checkAppointment.start).format("HH:mm") + "hs.",
+                nombre_servicio: checkService.name,
+                nombre_profesional: UsersManager.getUserFullName(checkEmployeeUser),
+                    duracion: this.formatAppointmentDuration(checkAppointment.startHour, checkAppointment.endHour),
+                precio: formatCurrency(checkAppointment.price),
+                direccion: CompaniesManager.getCompanyAddress(companyCheck),
+            };
         }
 
         return {
             message: wapMessage,
             checkClient: checkClient,
             companyCheck: companyCheck,
+            emailTemplateId,
+            emailContext,
         };
     }
 
     public async sendEmailNotification(data: SendAppointmentNotificationParams): Promise<void> {
-        const sessionUser = await UsersManager.users.findOne({
+        if (!this.hasValidSystemToken(data.systemToken)) {
-            _id: data.sessionUser,
+            if (!data.sessionUser) {
-        });
+                throw new Error("No se ha encontrado el usuario o no tiene permisos para realizar esta acción");
+            }
 
-        if (!sessionUser) {
+            const sessionUser = await UsersManager.users.findOne({
-            throw new Error("No se ha encontrado el usuario o no tiene permisos para realizar esta acción");
+                _id: data.sessionUser,
+            });
+
+            if (!sessionUser) {
+                throw new Error("No se ha encontrado el usuario o no tiene permisos para realizar esta acción");
+            }
         }
 
-        const { message, checkClient, companyCheck } = await this.tryToSendNotification(data);
+        const { message, checkClient, companyCheck, emailTemplateId, emailContext } = await this.tryToSendNotification({
+            ...data,
+            channel: "email",
+        });
 
         const canSend = await PlanSubscriptionsList.checkFeature({
             userId: String(companyCheck.ownerId),
@@ -2548,6 +3025,10 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
             subjectEmail = "TurnosXpress :: Recordatorio";
         } else if (data.type == APPOINTMENT_NOTIFICATION_TYPE.CREATION) {
             subjectEmail = "TurnosXpress :: Alta de turno";
+        } else if (data.type == APPOINTMENT_NOTIFICATION_TYPE.CANCELLATION) {
+            subjectEmail = "TurnosXpress :: Turno cancelado";
+        } else if (data.type == APPOINTMENT_NOTIFICATION_TYPE.UPDATE) {
+            subjectEmail = "TurnosXpress :: Turno actualizado";
         }
 
         //Enviar email...
@@ -2555,10 +3036,119 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
             email: clientEmail,
             subject: subjectEmail,
             message: message,
+            templateId: emailTemplateId,
+            context: emailContext,
         });
     }
 
+    public async createImmediateNotificationJobs(data: CreateImmediateAppointmentNotificationJobsParams): Promise<void> {
+        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 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 checkAppointment = await this.Appointments.findOne({
+            _id: data.appointmentId,
+        });
+
+        if (!checkAppointment) {
+            throw new Error("El turno no existe");
+        }
+
+        const checkClient = emailContent.checkClient;
+        const companyCheck = emailContent.companyCheck;
+        const isCreation = data.type === APPOINTMENT_NOTIFICATION_TYPE.CREATION;
+        const systemSubject = isCreation
+            ? `Turno reservado en ${companyCheck.name}`
+            : `Recordatorio de turno en ${companyCheck.name}`;
+
+        await this.jobService.createImmediateJob({
+            companyId: String(checkAppointment.companyId),
+            clientId: String(checkAppointment.clientId),
+            appointmentId: String(checkAppointment._id),
+            type: data.type,
+            scheduledAt: new Date(),
+            payload: {
+                email: checkClient.email,
+                phoneNumber: await this.getOptionalClientWapNumber(checkClient),
+                userId: checkClient.userId ? String(checkClient.userId) : undefined,
+                companyOwnerId: String(companyCheck.ownerId),
+                subject: systemSubject,
+                message: emailContent.message,
+                emailSubject: isCreation ? "TurnosXpress :: Alta de turno" : "TurnosXpress :: Recordatorio",
+                emailMessage: emailContent.message,
+                emailTemplateId: emailContent.emailTemplateId,
+                emailContext: emailContent.emailContext,
+                wapMessage: wapContent.message,
+                systemSubject,
+                systemMessage: emailContent.message,
+            },
+        });
+    }
+
+    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");
+        }
+
         const sessionUser = await UsersManager.users.findOne({
             _id: data.sessionUser,
         });
@@ -2567,7 +3157,10 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
             throw new Error("No se ha encontrado el usuario o no tiene permisos para realizar esta acción");
         }
 
-        const { message, checkClient, companyCheck } = await this.tryToSendNotification(data);
+        const { message, checkClient, companyCheck } = await this.tryToSendNotification({
+            ...data,
+            channel: "whatsapp",
+        });
 
         const canSend = await PlanSubscriptionsList.checkFeature({
             userId: String(companyCheck.ownerId),
@@ -2593,13 +3186,7 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
     }
 
     public async sendWapSystemNotification(data: SendWapSystemNotificationParams): Promise<void> {
-        if (!data.systemToken || data.systemToken == "") {
+        if (!this.hasValidSystemToken(data.systemToken)) {
-            throw new Error("No tiene permisos para realizar esta acción");
-        }
-
-        const systemToken = `${process.env.SYSTEM_KEY}`;
-
-        if (systemToken != data.systemToken) {
             throw new Error("No tiene permisos para realizar esta acción");
         }
 
@@ -2622,7 +3209,8 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
         const { message, checkClient, companyCheck } = await this.tryToSendNotification({
             appointmentId: data.appointmentId,
             sessionUser: String(company.ownerId),
-            type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER,
+            systemToken: data.systemToken,
+            type: data.type,
         });
 
         const canSend = await PlanSubscriptionsList.checkFeature({
@@ -2838,6 +3426,11 @@ public async updateAppointment(data: UpdateAppointmentParams): Promise<void> {
             inRangeDates: [],
         } as GetAvailableDatesResult;
     }
+
+    private hasValidSystemToken(systemToken?: string): boolean {
+        const expectedSystemToken = process.env.SYSTEM_KEY || process.env.API_KEY;
+        return Boolean(systemToken && expectedSystemToken && systemToken === expectedSystemToken);
+    }
 }
 
 const AppointmentList = new AppointmentManager();

server/src/Models/Appointments/__tests__/Appointments.snapshotFallback.test.ts

@@ -32,6 +32,7 @@ jest.mock("../../Companies/Companies", () => ({
         companies: {
             findOne: jest.fn(),
         },
+        getCompanyAddress: jest.fn(),
     },
 }));
 
@@ -41,6 +42,7 @@ jest.mock("../../Employees/Employee", () => ({
         employees: {
             findOne: jest.fn(),
         },
+        checkPermission: jest.fn(),
     },
 }));
 
@@ -103,6 +105,7 @@ jest.mock("../../Notifications/Notifications", () => ({
     NotificationsManager: {
         sendSystemNotification: jest.fn(),
         sendPushNotification: jest.fn(),
+        sendEmail: jest.fn(),
     },
 }));
 
@@ -117,6 +120,7 @@ jest.mock("../../PlanSubscriptions/PlanSubscriptons", () => ({
     __esModule: true,
     default: {
         findOne: jest.fn(),
+        checkFeature: jest.fn(),
     },
 }));
 
@@ -151,6 +155,9 @@ jest.mock("../../../helpers/check", () => ({
 jest.mock("../../Templates/Templates", () => ({
     __esModule: true,
     default: {
+        templates: {
+            findOne: jest.fn(),
+        },
         sendEmail: jest.fn(),
     },
 }));
@@ -180,6 +187,11 @@ import UsersManager from "../../Users/Users";
 import EmployeesList from "../../Employees/Employee";
 import ClientsManager from "../../Clients/Clients";
 import ServiceList from "../../Services/Service";
+import CompaniesManager from "../../Companies/Companies";
+import Templates from "../../Templates/Templates";
+import PlanSubscriptionsList from "../../PlanSubscriptions/PlanSubscriptons";
+import { NotificationsManager } from "../../Notifications/Notifications";
+import { APPOINTMENT_NOTIFICATION_TYPE } from "../Appointments.Interface";
 
 describe("getAppointmentEvent — historical read snapshot fallback", () => {
     let originalAdapter: any;
@@ -385,3 +397,431 @@ describe("getAppointmentEvent — historical read snapshot fallback", () => {
         expect(result.collaboratorName).toBe("Jane Roe");
     });
 });
+
+describe("cancellation notification jobs", () => {
+    let originalAdapter: any;
+    let originalJobService: any;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        originalAdapter = AppointmentsList.Appointments;
+        originalJobService = (AppointmentsList as any).jobService;
+
+        (AppointmentsList as any).Appointments = {
+            findOne: jest.fn().mockResolvedValue({
+                _id: "appt-001",
+                companyId: "company-001",
+                clientId: "client-001",
+                employeeId: "employee-001",
+                serviceId: "service-001",
+                start: new Date("2026-07-22T11:00:00.000Z"),
+                price: 1500,
+            }),
+        };
+        (AppointmentsList as any).jobService = {
+            createJob: jest.fn().mockResolvedValue([]),
+            createMandatoryCreationJob: jest.fn().mockResolvedValue([]),
+            createReminderJobs: jest.fn().mockResolvedValue([]),
+        };
+
+        (CompaniesManager.companies.findOne as jest.Mock).mockResolvedValue({
+            _id: "company-001",
+            name: "clases llavallol",
+            ownerId: "owner-001",
+            templateEmailCancellationId: "email-template-001",
+            templateWapCancellationId: "wap-template-001",
+            address: "Av. Siempre Viva 123",
+        });
+        (CompaniesManager.getCompanyAddress as jest.Mock).mockReturnValue("Av. Siempre Viva 123");
+        (ClientsManager.clients.findOne as jest.Mock).mockResolvedValue({
+            _id: "client-001",
+            userId: "client-user-001",
+            firstName: "Ada",
+            lastName: "Lovelace",
+            email: "ada@example.com",
+        });
+        (ClientsManager.getClientFullName as jest.Mock).mockReturnValue("Ada Lovelace");
+        (EmployeesList.employees.findOne as jest.Mock).mockResolvedValue({
+            _id: "employee-001",
+            userId: "employee-user-001",
+        });
+        (EmployeesList.checkPermission as jest.Mock | undefined)?.mockResolvedValue?.(true);
+        (UsersManager.users.findOne as jest.Mock).mockResolvedValue({
+            _id: "employee-user-001",
+            firstName: "Grace",
+            lastName: "Hopper",
+        });
+        (UsersManager.getUserFullName as jest.Mock).mockReturnValue("Grace Hopper");
+        (ServiceList.services.findOne as jest.Mock).mockResolvedValue({
+            _id: "service-001",
+            name: "Contabilidad",
+        });
+        (Templates.templates.findOne as jest.Mock).mockImplementation(({ id }) => {
+            if (id === "email-template-001") {
+                return Promise.resolve({
+                    template: "EMAIL CANCEL <---CLIENTE---> <---SERVICIO---> <---ORGANIZACION---> <---FECHA---> <---HORARIO--->",
+                });
+            }
+
+            if (id === "wap-template-001") {
+                return Promise.resolve({
+                    template: "WAP CANCEL <---CLIENTE---> <---SERVICIO---> <---ORGANIZACION---> <---FECHA---> <---HORARIO--->",
+                });
+            }
+
+            return Promise.resolve(null);
+        });
+    });
+
+    afterEach(() => {
+        (AppointmentsList as any).Appointments = originalAdapter;
+        (AppointmentsList as any).jobService = originalJobService;
+    });
+
+    it("stores organization-rendered cancellation template content per channel", async () => {
+        const emailContent = await (AppointmentsList as any).tryToSendNotification({
+            appointmentId: "appt-001",
+            sessionUser: "owner-001",
+            type: "cancellation",
+            channel: "email",
+        });
+        const wapContent = await (AppointmentsList as any).tryToSendNotification({
+            appointmentId: "appt-001",
+            sessionUser: "owner-001",
+            type: "cancellation",
+            channel: "whatsapp",
+        });
+
+        await (AppointmentsList as any).createCancellationNotificationJobs({
+            appointmentId: "appt-001",
+            companyId: "company-001",
+            clientId: "client-001",
+            clientUserId: "client-user-001",
+            clientEmail: "ada@example.com",
+            clientPhoneNumber: "5491112345678",
+            companyOwnerId: "owner-001",
+            companyName: "clases llavallol",
+            emailMessage: emailContent.message,
+            wapMessage: wapContent.message,
+        });
+
+        expect((AppointmentsList as any).jobService.createJob).toHaveBeenCalledWith(
+            expect.objectContaining({
+                type: "cancellation",
+                payload: expect.objectContaining({
+                    email: "ada@example.com",
+                    phoneNumber: "5491112345678",
+                    userId: "client-user-001",
+                    companyOwnerId: "owner-001",
+                    emailSubject: "TurnosXpress :: Turno cancelado",
+                    emailMessage: "EMAIL CANCEL Ada Lovelace Contabilidad clases llavallol 22/07/2026 08:00hs.",
+                    wapMessage: "WAP CANCEL Ada Lovelace Contabilidad clases llavallol 22/07/2026 08:00hs.",
+                    systemSubject: "Turno cancelado en clases llavallol",
+                    systemMessage: "EMAIL CANCEL Ada Lovelace Contabilidad clases llavallol 22/07/2026 08:00hs.",
+                }),
+            })
+        );
+    });
+
+    it("sends update email notifications with a non-empty subject", async () => {
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        await (AppointmentsList as any).sendEmailNotification({
+            appointmentId: "appt-001",
+            sessionUser: "owner-001",
+            type: APPOINTMENT_NOTIFICATION_TYPE.UPDATE,
+        });
+
+        expect(NotificationsManager.sendEmail).toHaveBeenCalledWith(
+            expect.objectContaining({
+                email: "ada@example.com",
+                subject: "TurnosXpress :: Turno actualizado",
+            })
+        );
+    });
+});
+
+describe("creation notification jobs", () => {
+    let originalAdapter: any;
+    let originalJobService: any;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        originalAdapter = AppointmentsList.Appointments;
+        originalJobService = (AppointmentsList as any).jobService;
+
+        (AppointmentsList as any).Appointments = {
+            findOne: jest.fn().mockResolvedValue({
+                _id: "appt-001",
+                companyId: "company-001",
+                clientId: "client-001",
+                employeeId: "employee-001",
+                serviceId: "service-001",
+                start: new Date("2026-07-22T11:00:00.000Z"),
+                price: 1500,
+            }),
+        };
+        (AppointmentsList as any).jobService = {
+            createJob: jest.fn().mockResolvedValue([]),
+            createMandatoryCreationJob: jest.fn().mockResolvedValue([]),
+            createReminderJobs: jest.fn().mockResolvedValue([]),
+        };
+
+        (CompaniesManager.companies.findOne as jest.Mock).mockResolvedValue({
+            _id: "company-001",
+            name: "clases llavallol",
+            ownerId: "owner-001",
+            templateEmailAltaId: "email-alta-template-001",
+            templateWapAltaId: "wap-alta-template-001",
+            address: "Av. Siempre Viva 123",
+        });
+        (CompaniesManager.getCompanyAddress as jest.Mock).mockReturnValue("Av. Siempre Viva 123");
+        (ClientsManager.clients.findOne as jest.Mock).mockResolvedValue({
+            _id: "client-001",
+            userId: "client-user-001",
+            firstName: "Ada",
+            lastName: "Lovelace",
+            email: "ada@example.com",
+        });
+        (ClientsManager.getClientFullName as jest.Mock).mockReturnValue("Ada Lovelace");
+        (EmployeesList.employees.findOne as jest.Mock).mockResolvedValue({
+            _id: "employee-001",
+            userId: "employee-user-001",
+        });
+        (EmployeesList.checkPermission as jest.Mock | undefined)?.mockResolvedValue?.(true);
+        (UsersManager.users.findOne as jest.Mock).mockResolvedValue({
+            _id: "employee-user-001",
+            firstName: "Grace",
+            lastName: "Hopper",
+        });
+        (UsersManager.getUserFullName as jest.Mock).mockReturnValue("Grace Hopper");
+        (ServiceList.services.findOne as jest.Mock).mockResolvedValue({
+            _id: "service-001",
+            name: "Historia",
+        });
+        (Templates.templates.findOne as jest.Mock).mockImplementation(({ id }) => {
+            if (id === "email-alta-template-001") {
+                return Promise.resolve({
+                    template: "EMAIL ALTA <---CLIENTE---> <---SERVICIO---> <---ORGANIZACION---> <---FECHA---> <---HORARIO--->",
+                });
+            }
+
+            if (id === "wap-alta-template-001") {
+                return Promise.resolve({
+                    template: "WAP ALTA <---CLIENTE---> <---SERVICIO---> <---ORGANIZACION---> <---FECHA---> <---HORARIO--->",
+                });
+            }
+
+            return Promise.resolve(null);
+        });
+    });
+
+    afterEach(() => {
+        (AppointmentsList as any).Appointments = originalAdapter;
+        (AppointmentsList as any).jobService = originalJobService;
+    });
+
+    it("stores organization-rendered Alta template content per channel", async () => {
+        const emailContent = await (AppointmentsList as any).tryToSendNotification({
+            appointmentId: "appt-001",
+            sessionUser: "owner-001",
+            type: "creation",
+            channel: "email",
+        });
+        const wapContent = await (AppointmentsList as any).tryToSendNotification({
+            appointmentId: "appt-001",
+            sessionUser: "owner-001",
+            type: "creation",
+            channel: "whatsapp",
+        });
+
+        await (AppointmentsList as any).createCreationNotificationJobs({
+            appointmentId: "appt-001",
+            companyId: "company-001",
+            clientId: "client-001",
+            clientUserId: "client-user-001",
+            clientEmail: "ada@example.com",
+            clientPhoneNumber: "5491112345678",
+            companyOwnerId: "owner-001",
+            companyName: "clases llavallol",
+            appointmentStart: new Date("2026-07-22T11:00:00.000Z"),
+            emailMessage: emailContent.message,
+            wapMessage: wapContent.message,
+            reminderEmailMessage: "EMAIL REMINDER Ada Lovelace",
+            reminderWapMessage: "WAP REMINDER Ada Lovelace",
+        });
+
+        expect((AppointmentsList as any).jobService.createMandatoryCreationJob).toHaveBeenCalledWith(
+            expect.objectContaining({
+                type: "creation",
+                payload: expect.objectContaining({
+                    emailSubject: "TurnosXpress :: Alta de turno",
+                    emailMessage: "EMAIL ALTA Ada Lovelace Historia clases llavallol 22/07/2026 08:00hs.",
+                    wapMessage: "WAP ALTA Ada Lovelace Historia clases llavallol 22/07/2026 08:00hs.",
+                    systemSubject: "Turno reservado en clases llavallol",
+                    systemMessage: "EMAIL ALTA Ada Lovelace Historia clases llavallol 22/07/2026 08:00hs.",
+                }),
+            })
+        );
+        expect((AppointmentsList as any).jobService.createReminderJobs).toHaveBeenCalledWith(
+            expect.objectContaining({
+                type: "reminder",
+                reminderPayload: expect.objectContaining({
+                    email: "ada@example.com",
+                    phoneNumber: "5491112345678",
+                    userId: "client-user-001",
+                    companyOwnerId: "owner-001",
+                    emailSubject: "TurnosXpress :: Recordatorio",
+                    emailMessage: "EMAIL REMINDER Ada Lovelace",
+                    wapMessage: "WAP REMINDER Ada Lovelace",
+                }),
+            })
+        );
+    });
+
+    it("routes customer notification jobs for creation, repeat reminder-only, and disabled notifications", () => {
+        expect((AppointmentsList as any).shouldCreateCustomerNotificationJobs(true, undefined)).toBe(true);
+        expect((AppointmentsList as any).shouldCreateCustomerNotificationJobs(false, "repeat-001")).toBe(true);
+        expect((AppointmentsList as any).shouldCreateCustomerNotificationJobs(false, undefined)).toBe(false);
+    });
+
+    it("creates reminder-only jobs without rendering Alta content for repeat-created appointments", async () => {
+        const tryToSendNotificationSpy = jest
+            .spyOn(AppointmentsList as any, "tryToSendNotification")
+            .mockImplementation(({ type, channel }: any) => {
+                if (type === APPOINTMENT_NOTIFICATION_TYPE.CREATION) {
+                    throw new Error("Creation content should not be rendered");
+                }
+
+                return Promise.resolve({
+                    message: channel === "email" ? "EMAIL REMINDER Ada Lovelace" : "WAP REMINDER Ada Lovelace",
+                });
+            });
+        const getOptionalClientWapNumberSpy = jest
+            .spyOn(AppointmentsList as any, "getOptionalClientWapNumber")
+            .mockResolvedValue("5491112345678");
+
+        try {
+            await (AppointmentsList as any).createAppointmentNotificationJobs({
+                appointmentId: "appt-001",
+                companyId: "company-001",
+                clientId: "client-001",
+                clientUserId: "client-user-001",
+                clientEmail: "ada@example.com",
+                client: { _id: "client-001" },
+                companyOwnerId: "owner-001",
+                companyName: "clases llavallol",
+                appointmentStart: new Date("2026-07-22T11:00:00.000Z"),
+                notification: false,
+            });
+
+            expect(tryToSendNotificationSpy).toHaveBeenCalledTimes(2);
+            expect(tryToSendNotificationSpy).toHaveBeenCalledWith(
+                expect.objectContaining({ type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER, channel: "email" })
+            );
+            expect(tryToSendNotificationSpy).toHaveBeenCalledWith(
+                expect.objectContaining({ type: APPOINTMENT_NOTIFICATION_TYPE.REMINDER, channel: "whatsapp" })
+            );
+            expect((AppointmentsList as any).jobService.createMandatoryCreationJob).not.toHaveBeenCalled();
+            expect((AppointmentsList as any).jobService.createReminderJobs).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: "reminder",
+                    appointmentStart: new Date("2026-07-22T11:00:00.000Z"),
+                    reminderPayload: expect.objectContaining({
+                        email: "ada@example.com",
+                        phoneNumber: "5491112345678",
+                        userId: "client-user-001",
+                        companyOwnerId: "owner-001",
+                        emailSubject: "TurnosXpress :: Recordatorio",
+                        emailMessage: "EMAIL REMINDER Ada Lovelace",
+                        wapMessage: "WAP REMINDER Ada Lovelace",
+                        systemSubject: "Recordatorio de turno en clases llavallol",
+                        systemMessage: "EMAIL REMINDER Ada Lovelace",
+                    }),
+                })
+            );
+        } finally {
+            tryToSendNotificationSpy.mockRestore();
+            getOptionalClientWapNumberSpy.mockRestore();
+        }
+    });
+
+    it("falls back to organization WAP Alta template for email when email Alta is absent", async () => {
+        (CompaniesManager.companies.findOne as jest.Mock).mockResolvedValue({
+            _id: "company-001",
+            name: "clases llavallol",
+            ownerId: "owner-001",
+            templateWapAltaId: "wap-alta-template-001",
+            address: "Av. Siempre Viva 123",
+        });
+
+        const emailContent = await (AppointmentsList as any).tryToSendNotification({
+            appointmentId: "appt-001",
+            sessionUser: "owner-001",
+            type: "creation",
+            channel: "email",
+        });
+
+        expect(emailContent.message).toBe("WAP ALTA Ada Lovelace Historia clases llavallol 22/07/2026 08:00hs.");
+    });
+
+    it("stores organization-rendered update template content with contact snapshot fields", async () => {
+        const emailContent = await (AppointmentsList as any).tryToSendNotification({
+            appointmentId: "appt-001",
+            sessionUser: "owner-001",
+            type: "update",
+            channel: "email",
+        });
+        const wapContent = await (AppointmentsList as any).tryToSendNotification({
+            appointmentId: "appt-001",
+            sessionUser: "owner-001",
+            type: "update",
+            channel: "whatsapp",
+        });
+
+        await (AppointmentsList as any).createUpdateNotificationJobs({
+            appointmentId: "appt-001",
+            companyId: "company-001",
+            clientId: "client-001",
+            clientUserId: "client-user-001",
+            clientEmail: "ada@example.com",
+            clientPhoneNumber: "5491112345678",
+            companyOwnerId: "owner-001",
+            companyName: "clases llavallol",
+            appointmentStart: new Date("2026-07-22T11:00:00.000Z"),
+            emailMessage: emailContent.message,
+            wapMessage: wapContent.message,
+            reminderEmailMessage: "EMAIL REMINDER Ada Lovelace",
+            reminderWapMessage: "WAP REMINDER Ada Lovelace",
+        });
+
+        expect((AppointmentsList as any).jobService.createJob).toHaveBeenCalledWith(
+            expect.objectContaining({
+                type: "update",
+                appointmentStart: new Date("2026-07-22T11:00:00.000Z"),
+                payload: expect.objectContaining({
+                    email: "ada@example.com",
+                    phoneNumber: "5491112345678",
+                    userId: "client-user-001",
+                    companyOwnerId: "owner-001",
+                    emailSubject: "TurnosXpress :: Turno actualizado",
+                    emailMessage: "EMAIL ALTA Ada Lovelace Historia clases llavallol 22/07/2026 08:00hs.",
+                    wapMessage: "WAP ALTA Ada Lovelace Historia clases llavallol 22/07/2026 08:00hs.",
+                    systemSubject: "Turno actualizado en clases llavallol",
+                    systemMessage: "EMAIL ALTA Ada Lovelace Historia clases llavallol 22/07/2026 08:00hs.",
+                }),
+                reminderPayload: expect.objectContaining({
+                    email: "ada@example.com",
+                    phoneNumber: "5491112345678",
+                    userId: "client-user-001",
+                    companyOwnerId: "owner-001",
+                    emailSubject: "TurnosXpress :: Recordatorio",
+                    emailMessage: "EMAIL REMINDER Ada Lovelace",
+                    wapMessage: "WAP REMINDER Ada Lovelace",
+                }),
+            })
+        );
+    });
+});

server/src/Models/ArcaActivities/ArcaActivities.Catalog.ts

@@ -0,0 +1,134 @@
+import { TextObjectFilterResult } from "../TextObjectFilter.model";
+
+export type ArcaActivity = {
+    code: string;
+    description: string;
+};
+
+export const ARCA_ACTIVITIES: ArcaActivity[] = [
+    { code: "011111", description: "Cultivo de arroz" },
+    { code: "011112", description: "Cultivo de trigo" },
+    { code: "011119", description: "Cultivo de cereales n.c.p., excepto los de uso forrajero" },
+    { code: "011121", description: "Cultivo de maíz" },
+    { code: "011129", description: "Cultivo de cereales de uso forrajero n.c.p." },
+    { code: "011130", description: "Cultivo de oleaginosas, excepto soja" },
+    { code: "011140", description: "Cultivo de pastos de uso forrajero" },
+    { code: "011211", description: "Cultivo de papa, batata y mandioca" },
+    { code: "011221", description: "Cultivo de tomate" },
+    { code: "011229", description: "Cultivo de bulbos, brotes, raíces y hortalizas de fruto n.c.p." },
+    { code: "011240", description: "Cultivo de legumbres" },
+    { code: "012110", description: "Cultivo de vid para vinificar" },
+    { code: "012121", description: "Cultivo de uva de mesa" },
+    { code: "012200", description: "Cultivo de frutas cítricas" },
+    { code: "012311", description: "Cultivo de manzana y pera" },
+    { code: "012320", description: "Cultivo de frutas de carozo" },
+    { code: "012410", description: "Cultivo de frutas tropicales y subtropicales" },
+    { code: "012510", description: "Cultivo de frutas secas" },
+    { code: "013011", description: "Producción de semillas híbridas de cereales y oleaginosas" },
+    { code: "013019", description: "Producción de semillas varietales o autofecundadas de cereales, oleaginosas, y forrajeras" },
+    { code: "014113", description: "Cría de ganado bovino, excepto la realizada en cabañas y para la producción de leche" },
+    { code: "014114", description: "Invernada de ganado bovino excepto el engorde en corrales (feed-lot)" },
+    { code: "014115", description: "Engorde en corrales (feed-lot)" },
+    { code: "014211", description: "Cría de ganado equino, excepto la realizada en haras" },
+    { code: "014300", description: "Cría de ganado camélido" },
+    { code: "014410", description: "Cría de ganado ovino, excepto en cabañas y para la producción de lana" },
+    { code: "014420", description: "Cría de ganado ovino realizada en cabañas" },
+    { code: "014430", description: "Cría de ganado ovino para la producción de lana" },
+    { code: "014510", description: "Cría de ganado porcino, excepto la realizada en cabañas" },
+    { code: "014520", description: "Cría de ganado porcino realizada en cabañas" },
+    { code: "014610", description: "Producción de leche bovina" },
+    { code: "014620", description: "Producción de leche de oveja y de cabra" },
+    { code: "014710", description: "Producción de huevos" },
+    { code: "014720", description: "Cría de aves para producción de carnes" },
+    { code: "014740", description: "Producción de pollitos BB" },
+    { code: "014810", description: "Cría de abejas" },
+    { code: "014820", description: "Producción de pelos de ganado" },
+    { code: "014910", description: "Cría de animales para la obtención de pieles y cueros" },
+    { code: "014990", description: "Cría de animales y obtención de productos de origen animal n.c.p." },
+    { code: "016111", description: "Servicios de labranza, siembra, transplante y cuidados culturales" },
+    { code: "016112", description: "Servicios de pulverización, desinfección y fumigación terrestre" },
+    { code: "016113", description: "Servicios de pulverización, desinfección y fumigación aérea" },
+    { code: "016119", description: "Servicios de maquinaria agrícola n.c.p., excepto los de cosecha mecánica" },
+    { code: "016120", description: "Servicios de cosecha mecánica" },
+    { code: "016130", description: "Servicios de contratistas de mano de obra agrícola" },
+    { code: "016140", description: "Servicios de post cosecha" },
+    { code: "016150", description: "Servicios de procesamiento de semillas para su siembra" },
+    { code: "016190", description: "Servicios de apoyo agrícolas n.c.p." },
+    { code: "016210", description: "Inseminación artificial y servicios n.c.p. para mejorar la reproducción de los animales y el rendimiento de sus productos" },
+    { code: "016220", description: "Servicios de contratistas de mano de obra pecuaria" },
+    { code: "016230", description: "Servicios de esquila de animales" },
+    { code: "016291", description: "Servicios para el control de plagas, baños parasiticidas, etc." },
+    { code: "016292", description: "Albergue y cuidado de animales de terceros" },
+    { code: "016299", description: "Servicios de apoyo pecuarios n.c.p." },
+    { code: "551010", description: "Servicios de alojamiento por hora" },
+    { code: "551021", description: "Servicios de alojamiento en pensiones" },
+    { code: "551022", description: "Servicios de alojamiento en hoteles, hosterías y residenciales similares, excepto por hora, que incluyen servicio de restaurante al público" },
+    { code: "551023", description: "Servicios de alojamiento en hoteles, hosterías y residenciales similares, excepto por hora, que no incluyen servicio de restaurante al público" },
+    { code: "561011", description: "Servicios de restaurantes y cantinas sin espectáculo" },
+    { code: "561012", description: "Servicios de restaurantes y cantinas con espectáculo" },
+    { code: "561013", description: "Servicios de fast food y locales de venta de comidas y bebidas al paso" },
+    { code: "561014", description: "Servicios de expendio de bebidas en bares" },
+    { code: "561019", description: "Servicios de expendio de comidas y bebidas en establecimientos con servicio de mesa y/o en mostrador n.c.p." },
+    { code: "620100", description: "Servicios de consultores en informática y suministros de programas de informática" },
+    { code: "620200", description: "Servicios de consultores en equipo de informática" },
+    { code: "620300", description: "Servicios de consultores en tecnología de la información" },
+    { code: "620900", description: "Servicios de informática n.c.p." },
+    { code: "681098", description: "Servicios inmobiliarios realizados por cuenta propia, con bienes urbanos propios o arrendados n.c.p." },
+    { code: "681099", description: "Servicios inmobiliarios realizados por cuenta propia, con bienes rurales propios o arrendados n.c.p." },
+    { code: "691001", description: "Servicios jurídicos" },
+    { code: "692000", description: "Servicios de contabilidad, auditoría y asesoría fiscal" },
+    { code: "702091", description: "Servicios de asesoramiento, dirección y gestión empresarial realizados por integrantes de los órganos de administración y/o fiscalización en sociedades anónimas" },
+    { code: "702092", description: "Servicios de asesoramiento, dirección y gestión empresarial realizados por integrantes de cuerpos de dirección en sociedades excepto las anónimas" },
+    { code: "702099", description: "Servicios de asesoramiento, dirección y gestión empresarial n.c.p." },
+    { code: "749009", description: "Actividades profesionales, científicas y técnicas n.c.p." },
+    { code: "851010", description: "Guarderías y jardines maternales" },
+    { code: "851020", description: "Enseñanza inicial, jardín de infantes y primaria" },
+    { code: "852100", description: "Enseñanza secundaria de formación general" },
+    { code: "852200", description: "Enseñanza secundaria de formación técnica y profesional" },
+    { code: "853100", description: "Enseñanza terciaria" },
+    { code: "853201", description: "Enseñanza universitaria excepto formación de posgrado" },
+    { code: "853300", description: "Formación de posgrado" },
+    { code: "854910", description: "Enseñanza de idiomas" },
+    { code: "854920", description: "Enseñanza de cursos relacionados con informática" },
+    { code: "854930", description: "Enseñanza para adultos, excepto discapacitados" },
+    { code: "854940", description: "Enseñanza especial y para discapacitados" },
+    { code: "854950", description: "Enseñanza de gimnasia, deportes y actividades físicas" },
+    { code: "854960", description: "Enseñanza artística" },
+    { code: "854990", description: "Servicios de enseñanza n.c.p." },
+    { code: "855000", description: "Servicios de apoyo a la educación" },
+    { code: "861010", description: "Servicios de internación" },
+    { code: "862110", description: "Servicios de consulta médica" },
+    { code: "862120", description: "Servicios de atención médica en dispensarios, salitas, vacunatorios y otros locales de atención primaria de la salud" },
+    { code: "862130", description: "Servicios de atención médica en otros establecimientos n.c.p." },
+    { code: "862200", description: "Servicios odontológicos" },
+    { code: "869010", description: "Servicios de prácticas de diagnóstico en laboratorios" },
+    { code: "869090", description: "Servicios relacionados con la salud humana n.c.p." },
+    { code: "900011", description: "Producción de espectáculos teatrales y musicales" },
+    { code: "900021", description: "Composición y representación de obras teatrales, musicales y artísticas" },
+    { code: "931010", description: "Servicios de organización, dirección y gestión de prácticas deportivas y explotación de las instalaciones" },
+    { code: "931020", description: "Servicios prestados por profesionales y técnicos para la realización de prácticas deportivas" },
+    { code: "960201", description: "Servicios de peluquería" },
+    { code: "960202", description: "Servicios de tratamiento de belleza, excepto los de peluquería" },
+    { code: "960990", description: "Servicios personales n.c.p." },
+];
+
+export const findArcaActivityByCode = (code: string): ArcaActivity | undefined => {
+    return ARCA_ACTIVITIES.find((activity) => activity.code === code.trim());
+};
+
+export const filterArcaActivities = (name?: string): TextObjectFilterResult[] => {
+    const normalizedFilter = (name || "").trim().toLowerCase();
+
+    return ARCA_ACTIVITIES.filter((activity) => {
+        if (!normalizedFilter) return true;
+
+        return (
+            activity.code.includes(normalizedFilter) ||
+            activity.description.toLowerCase().includes(normalizedFilter)
+        );
+    }).map((activity) => ({
+        id: activity.code,
+        name: activity.description,
+        description: activity.code,
+    }));
+};

server/src/Models/ArcaCredentials/ArcaCredentials.Adapter.Mongoose.ts

@@ -0,0 +1,83 @@
+import { Document, FilterQuery, Model, Schema, model } from "mongoose";
+import {
+    ARCA_CREDENTIAL_STATUS,
+    CreateArcaCredentialParams,
+    FindArcaCredentialsParams,
+    IArcaCredential,
+    IArcaCredentialsAdapter,
+    UpdateArcaCredentialParams,
+} from "./ArcaCredentials.Interface";
+
+export interface IArcaCredentialDocument extends Omit<IArcaCredential, "id">, Document {}
+
+export class ArcaCredentialsAdapterMongoose implements IArcaCredentialsAdapter {
+    schema: Schema;
+    arcaCredentialList: Model<IArcaCredentialDocument>;
+
+    constructor() {
+        this.schema = new Schema({
+            companyId: {
+                type: Schema.Types.ObjectId,
+                required: true,
+                ref: "Company",
+                unique: true,
+                index: true,
+            },
+            csrPem: { type: String, required: false },
+            certificatePem: { type: String, required: false },
+            encryptedPrivateKey: { type: String, required: true },
+            privateKeyIv: { type: String, required: true },
+            privateKeyAuthTag: { type: String, required: true },
+            encryptionKeyVersion: { type: String, required: false, default: "v1" },
+            status: {
+                type: String,
+                required: true,
+                enum: Object.values(ARCA_CREDENTIAL_STATUS),
+                index: true,
+            },
+            certificateValidFrom: { type: Date, required: false },
+            certificateValidTo: { type: Date, required: false },
+            lastValidationError: { type: String, required: false },
+            createdAt: { type: Date, required: true, default: Date.now },
+            updatedAt: { type: Date, required: true, default: Date.now },
+        });
+
+        this.arcaCredentialList = model<IArcaCredentialDocument>("ArcaCredential", this.schema);
+    }
+
+    public async create(data: CreateArcaCredentialParams): Promise<IArcaCredential> {
+        return await this.arcaCredentialList.create(data);
+    }
+
+    private buildSearchCriteria(filters: FindArcaCredentialsParams): FilterQuery<IArcaCredential> {
+        const searchCriteria: FilterQuery<IArcaCredential> = {};
+
+        if (filters.id) searchCriteria._id = filters.id;
+        if (filters.companyId) searchCriteria.companyId = filters.companyId;
+        if (filters.status) searchCriteria.status = filters.status;
+
+        return searchCriteria;
+    }
+
+    public async find(filters: FindArcaCredentialsParams): Promise<IArcaCredential[]> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+        return this.arcaCredentialList.find(searchCriteria).sort({ createdAt: -1 }).exec();
+    }
+
+    public async findOne(filters: FindArcaCredentialsParams): Promise<IArcaCredentialDocument | null> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+        return this.arcaCredentialList.findOne(searchCriteria).exec();
+    }
+
+    public async update(data: UpdateArcaCredentialParams): Promise<IArcaCredentialDocument | null> {
+        const { id, companyId, sessionUser, ...updateData } = data;
+
+        if (!id && !companyId) {
+            throw new Error("Se requiere un identificador para actualizar las credenciales ARCA");
+        }
+
+        return this.arcaCredentialList
+            .findOneAndUpdate(this.buildSearchCriteria({ id, companyId, sessionUser }), updateData, { new: true })
+            .exec();
+    }
+}

server/src/Models/ArcaCredentials/ArcaCredentials.Interface.ts

@@ -0,0 +1,198 @@
+import { IArcaCredentialDocument } from "./ArcaCredentials.Adapter.Mongoose";
+import { ARCA_WSAA_ENVIRONMENT, ARCA_WSAA_SERVICE } from "../ArcaWsaaTokens/ArcaWsaaTokens.Interface";
+
+export enum ARCA_CREDENTIAL_STATUS {
+    CSR_GENERATED = "CSR_GENERATED",
+    CERTIFICATE_UPLOADED = "CERTIFICATE_UPLOADED",
+    READY = "READY",
+    INVALID = "INVALID",
+    DISABLED = "DISABLED",
+}
+
+export type GenerateArcaCredentialCsrParams = {
+    companyId: string;
+    sessionUser: string;
+};
+
+export type UploadArcaCredentialCertificateParams = {
+    companyId: string;
+    certificatePem: string;
+    sessionUser: string;
+};
+
+export type TestArcaWsaaLoginParams = {
+    companyId: string;
+    sessionUser: string;
+};
+
+export type ArcaWsaaLoginTestResult = {
+    status: "cached" | "created";
+    environment: ARCA_WSAA_ENVIRONMENT;
+    service: ARCA_WSAA_SERVICE;
+    endpoints: ArcaEndpointMetadata;
+    expirationTime: Date;
+    cached: boolean;
+};
+
+export type ArcaWsfeLastVoucherParams = {
+    companyId: string;
+    sessionUser: string;
+};
+
+export type ArcaWsfeLastVoucherResult = {
+    environment: ARCA_WSAA_ENVIRONMENT;
+    service: ARCA_WSAA_SERVICE;
+    endpoints: ArcaEndpointMetadata;
+    pointOfSale: number;
+    voucherType: 11;
+    lastVoucherNumber: number;
+};
+
+export type ArcaWsfeIssueFacturaCParams = {
+    companyId: string;
+    amount: number;
+    billingDate: Date;
+    servicePeriodFrom: Date;
+    servicePeriodTo: Date;
+    paymentDueDate: Date;
+    receiverDocumentType?: number | string;
+    receiverDocumentNumber?: number | string;
+    sessionUser: string;
+};
+
+export type ArcaWsfeIssueFacturaCResult = {
+    environment: ARCA_WSAA_ENVIRONMENT;
+    service: ARCA_WSAA_SERVICE;
+    endpoints: ArcaEndpointMetadata;
+    pointOfSale: number;
+    voucherType: 11;
+    voucherNumber: number;
+    cae: string;
+    caeExpiresAt: Date;
+};
+
+export type ArcaWsfeIssueFacturaCAttempt = {
+    pointOfSale: number;
+    voucherType: 11;
+    voucherNumber: number;
+};
+
+export type ArcaWsfeDiagnosticsParams = {
+    companyId: string;
+    sessionUser: string;
+};
+
+export type ArcaEndpointMetadata = {
+    wsaaHost?: string;
+    wsfeHost?: string;
+};
+
+export type ArcaWsfeDiagnosticsResult = {
+    environment: ARCA_WSAA_ENVIRONMENT;
+    service: ARCA_WSAA_SERVICE;
+    endpoints: ArcaEndpointMetadata;
+    dummy: {
+        ok: boolean;
+        appServer?: string;
+        dbServer?: string;
+        authServer?: string;
+        error?: string;
+    };
+    voucherTypes: {
+        ok: boolean;
+        count?: number;
+        includesFacturaC?: boolean;
+        error?: string;
+    };
+    pointsOfSale: {
+        ok: boolean;
+        points?: number[];
+        includesConfiguredPointOfSale?: boolean;
+        configuredPointOfSale: number;
+        error?: string;
+    };
+    lastVoucher: {
+        ok: boolean;
+        pointOfSale: number;
+        voucherType: 11;
+        lastVoucherNumber?: number;
+        error?: string;
+    };
+};
+
+export type FindArcaCredentialsParams = {
+    id?: string;
+    companyId?: string;
+    status?: ARCA_CREDENTIAL_STATUS;
+    sessionUser?: string;
+};
+
+export type CreateArcaCredentialParams = {
+    companyId: string;
+    csrPem?: string;
+    certificatePem?: string;
+    encryptedPrivateKey: string;
+    privateKeyIv: string;
+    privateKeyAuthTag: string;
+    encryptionKeyVersion?: string;
+    status: ARCA_CREDENTIAL_STATUS;
+    certificateValidFrom?: Date;
+    certificateValidTo?: Date;
+    lastValidationError?: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+
+export type UpdateArcaCredentialParams = FindArcaCredentialsParams & {
+    csrPem?: string;
+    certificatePem?: string;
+    encryptedPrivateKey?: string;
+    privateKeyIv?: string;
+    privateKeyAuthTag?: string;
+    encryptionKeyVersion?: string;
+    status?: ARCA_CREDENTIAL_STATUS;
+    certificateValidFrom?: Date;
+    certificateValidTo?: Date;
+    lastValidationError?: string;
+    updatedAt: Date;
+};
+
+export interface IArcaCredential {
+    id?: string;
+    companyId: string;
+    csrPem?: string;
+    certificatePem?: string;
+    encryptedPrivateKey: string;
+    privateKeyIv: string;
+    privateKeyAuthTag: string;
+    encryptionKeyVersion?: string;
+    status: ARCA_CREDENTIAL_STATUS;
+    certificateValidFrom?: Date;
+    certificateValidTo?: Date;
+    lastValidationError?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export type ArcaCredentialView = Omit<
+    IArcaCredential,
+    "encryptedPrivateKey" | "privateKeyIv" | "privateKeyAuthTag"
+>;
+
+export interface IArcaCredentialsAdapter {
+    create(data: CreateArcaCredentialParams): Promise<IArcaCredential>;
+    find(filters: FindArcaCredentialsParams): Promise<IArcaCredential[]>;
+    findOne(filters: FindArcaCredentialsParams): Promise<IArcaCredentialDocument | null>;
+    update(data: UpdateArcaCredentialParams): Promise<IArcaCredentialDocument | null>;
+}
+
+export interface IArcaCredentialsManager {
+    arcaCredentials: IArcaCredentialsAdapter;
+    generateCsr(data: GenerateArcaCredentialCsrParams): Promise<ArcaCredentialView>;
+    uploadCertificate(data: UploadArcaCredentialCertificateParams): Promise<ArcaCredentialView>;
+    testWsaaLogin(data: TestArcaWsaaLoginParams): Promise<ArcaWsaaLoginTestResult>;
+    getWsfeLastVoucher(data: ArcaWsfeLastVoucherParams): Promise<ArcaWsfeLastVoucherResult>;
+    issueFacturaC(data: ArcaWsfeIssueFacturaCParams): Promise<ArcaWsfeIssueFacturaCResult>;
+    getWsfeDiagnostics(data: ArcaWsfeDiagnosticsParams): Promise<ArcaWsfeDiagnosticsResult>;
+    find(data: FindArcaCredentialsParams): Promise<ArcaCredentialView[]>;
+}

server/src/Models/ArcaWsaaTokens/ArcaWsaaTokens.Adapter.Mongoose.ts

@@ -0,0 +1,97 @@
+import { Document, FilterQuery, Model, Schema, model, models } from "mongoose";
+import {
+    ARCA_WSAA_ENVIRONMENT,
+    ARCA_WSAA_SERVICE,
+    ArcaWsaaTokenLookupParams,
+    CreateArcaWsaaTokenParams,
+    IArcaWsaaToken,
+    IArcaWsaaTokensAdapter,
+    UpdateArcaWsaaTokenParams,
+} from "./ArcaWsaaTokens.Interface";
+
+export interface IArcaWsaaTokenDocument extends Omit<IArcaWsaaToken, "id">, Document {}
+
+export class ArcaWsaaTokensAdapterMongoose implements IArcaWsaaTokensAdapter {
+    schema: Schema;
+    arcaWsaaTokenList: Model<IArcaWsaaTokenDocument>;
+
+    constructor() {
+        this.schema = new Schema({
+            companyId: {
+                type: Schema.Types.ObjectId,
+                required: true,
+                ref: "Company",
+                index: true,
+            },
+            service: {
+                type: String,
+                required: true,
+                enum: Object.values(ARCA_WSAA_SERVICE),
+                index: true,
+            },
+            environment: {
+                type: String,
+                required: true,
+                enum: Object.values(ARCA_WSAA_ENVIRONMENT),
+                index: true,
+            },
+            token: { type: String, required: true },
+            sign: { type: String, required: true },
+            generationTime: { type: Date, required: false },
+            expirationTime: { type: Date, required: true, index: true },
+            createdAt: { type: Date, required: true, default: Date.now },
+            updatedAt: { type: Date, required: true, default: Date.now },
+        });
+
+        this.schema.index({ companyId: 1, service: 1, environment: 1 }, { unique: true });
+
+        this.arcaWsaaTokenList =
+            models.ArcaWsaaToken || model<IArcaWsaaTokenDocument>("ArcaWsaaToken", this.schema);
+    }
+
+    public async create(data: CreateArcaWsaaTokenParams): Promise<IArcaWsaaToken> {
+        return await this.arcaWsaaTokenList.create(data);
+    }
+
+    private buildSearchCriteria(
+        filters: Partial<ArcaWsaaTokenLookupParams>
+    ): FilterQuery<IArcaWsaaToken> {
+        const searchCriteria: FilterQuery<IArcaWsaaToken> = {};
+
+        if (filters.companyId) searchCriteria.companyId = filters.companyId;
+        if (filters.service) searchCriteria.service = filters.service;
+        if (filters.environment) searchCriteria.environment = filters.environment;
+
+        return searchCriteria;
+    }
+
+    public async find(filters: Partial<ArcaWsaaTokenLookupParams>): Promise<IArcaWsaaToken[]> {
+        return this.arcaWsaaTokenList.find(this.buildSearchCriteria(filters)).sort({ createdAt: -1 }).exec();
+    }
+
+    public async findOne(
+        filters: Partial<ArcaWsaaTokenLookupParams>
+    ): Promise<IArcaWsaaTokenDocument | null> {
+        return this.arcaWsaaTokenList.findOne(this.buildSearchCriteria(filters)).exec();
+    }
+
+    public async update(data: UpdateArcaWsaaTokenParams): Promise<IArcaWsaaTokenDocument | null> {
+        const { companyId, service, environment, ...updateData } = data;
+        return this.arcaWsaaTokenList
+            .findOneAndUpdate(this.buildSearchCriteria({ companyId, service, environment }), updateData, {
+                new: true,
+            })
+            .exec();
+    }
+
+    public async upsert(data: CreateArcaWsaaTokenParams): Promise<IArcaWsaaTokenDocument | null> {
+        const { companyId, service, environment, createdAt, ...updateData } = data;
+        return this.arcaWsaaTokenList
+            .findOneAndUpdate(
+                this.buildSearchCriteria({ companyId, service, environment }),
+                { $set: updateData, $setOnInsert: { companyId, service, environment, createdAt } },
+                { new: true, upsert: true }
+            )
+            .exec();
+    }
+}

server/src/Models/ArcaWsaaTokens/ArcaWsaaTokens.Interface.ts

@@ -0,0 +1,68 @@
+import { IArcaWsaaTokenDocument } from "./ArcaWsaaTokens.Adapter.Mongoose";
+
+export enum ARCA_WSAA_SERVICE {
+    WSFE = "wsfe",
+}
+
+export enum ARCA_WSAA_ENVIRONMENT {
+    HOMOLOGATION = "homologation",
+    PRODUCTION = "production",
+}
+
+export type ArcaWsaaTokenLookupParams = {
+    companyId: string;
+    service: ARCA_WSAA_SERVICE;
+    environment: ARCA_WSAA_ENVIRONMENT;
+};
+
+export type CreateArcaWsaaTokenParams = ArcaWsaaTokenLookupParams & {
+    token: string;
+    sign: string;
+    generationTime?: Date;
+    expirationTime: Date;
+    createdAt: Date;
+    updatedAt: Date;
+};
+
+export type UpdateArcaWsaaTokenParams = ArcaWsaaTokenLookupParams & {
+    token?: string;
+    sign?: string;
+    generationTime?: Date;
+    expirationTime?: Date;
+    updatedAt: Date;
+};
+
+export type UpsertArcaWsaaTokenParams = ArcaWsaaTokenLookupParams & {
+    token: string;
+    sign: string;
+    generationTime?: Date;
+    expirationTime: Date;
+};
+
+export interface IArcaWsaaToken {
+    id?: string;
+    companyId: string;
+    service: ARCA_WSAA_SERVICE;
+    environment: ARCA_WSAA_ENVIRONMENT;
+    token: string;
+    sign: string;
+    generationTime?: Date;
+    expirationTime: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface IArcaWsaaTokensAdapter {
+    create(data: CreateArcaWsaaTokenParams): Promise<IArcaWsaaToken>;
+    find(filters: Partial<ArcaWsaaTokenLookupParams>): Promise<IArcaWsaaToken[]>;
+    findOne(filters: Partial<ArcaWsaaTokenLookupParams>): Promise<IArcaWsaaTokenDocument | null>;
+    update(data: UpdateArcaWsaaTokenParams): Promise<IArcaWsaaTokenDocument | null>;
+    upsert(data: CreateArcaWsaaTokenParams): Promise<IArcaWsaaTokenDocument | null>;
+}
+
+export interface IArcaWsaaTokensManager {
+    arcaWsaaTokens: IArcaWsaaTokensAdapter;
+    getValidToken(data: ArcaWsaaTokenLookupParams): Promise<IArcaWsaaToken | null>;
+    saveToken(data: UpsertArcaWsaaTokenParams): Promise<IArcaWsaaToken>;
+    upsertToken(data: UpsertArcaWsaaTokenParams): Promise<IArcaWsaaToken>;
+}

server/src/Models/ArcaWsaaTokens/ArcaWsaaTokens.ts

@@ -0,0 +1,58 @@
+import { ArcaWsaaTokensAdapterMongoose } from "./ArcaWsaaTokens.Adapter.Mongoose";
+import {
+    ArcaWsaaTokenLookupParams,
+    IArcaWsaaToken,
+    IArcaWsaaTokensManager,
+    UpsertArcaWsaaTokenParams,
+} from "./ArcaWsaaTokens.Interface";
+
+const TOKEN_REUSE_SKEW_MS = 10 * 60 * 1000;
+
+class ArcaWsaaTokensManager implements IArcaWsaaTokensManager {
+    arcaWsaaTokens: ArcaWsaaTokensAdapterMongoose;
+
+    constructor() {
+        this.arcaWsaaTokens = new ArcaWsaaTokensAdapterMongoose();
+    }
+
+    public async getValidToken(data: ArcaWsaaTokenLookupParams): Promise<IArcaWsaaToken | null> {
+        const existingToken = await this.arcaWsaaTokens.findOne(data);
+
+        if (!existingToken) {
+            return null;
+        }
+
+        const reuseUntil = Date.now() + TOKEN_REUSE_SKEW_MS;
+        if (new Date(existingToken.expirationTime).getTime() <= reuseUntil) {
+            return null;
+        }
+
+        return existingToken;
+    }
+
+    public async saveToken(data: UpsertArcaWsaaTokenParams): Promise<IArcaWsaaToken> {
+        const now = new Date();
+        return await this.arcaWsaaTokens.create({
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        });
+    }
+
+    public async upsertToken(data: UpsertArcaWsaaTokenParams): Promise<IArcaWsaaToken> {
+        const now = new Date();
+        const token = await this.arcaWsaaTokens.upsert({
+            ...data,
+            createdAt: now,
+            updatedAt: now,
+        });
+
+        if (!token) {
+            throw new Error("No se pudo guardar el token WSAA de ARCA");
+        }
+
+        return token;
+    }
+}
+
+export default new ArcaWsaaTokensManager();

server/src/Models/Companies/Companies.Adapter.Mongoose.ts

@@ -58,13 +58,18 @@ export class CompaniesAdapterMongoose implements ICompaniesAdapter {
 
             templateWapNotifId: { type: Schema.Types.ObjectId, required: false, ref: "Template" },
             templateWapAltaId: { type: Schema.Types.ObjectId, required: false, ref: "Template" },
+            templateWapCancellationId: { type: Schema.Types.ObjectId, required: false, ref: "Template" },
             templateEmailNotifId: { type: Schema.Types.ObjectId, required: false, ref: "Template" },
             templateEmailAltaId: { type: Schema.Types.ObjectId, required: false, ref: "Template" },
+            templateEmailCancellationId: { type: Schema.Types.ObjectId, required: false, ref: "Template" },
             onboardingStep: { type: Number, required: false, default: 0 },
             onboardingCompleted: { type: Boolean, required: false, default: false },
 
             fixedPostIds: { type: Array, required: false },
             banned: { type: Boolean, required: false, default: false },
+            showPublicScores: { type: Boolean, required: false, default: true },
+            showPublicOpinions: { type: Boolean, required: false, default: true },
+            showPublicProfessionals: { type: Boolean, required: false, default: true },
         });
 
         this.companyList = model<ICompanyDocument>("Company", this.schema);
@@ -205,6 +210,10 @@ export class CompaniesAdapterMongoose implements ICompaniesAdapter {
             updateCompany.templateWapAltaId = data.templateWapAltaId;
         }
 
+        if (data.templateWapCancellationId) {
+            updateCompany.templateWapCancellationId = data.templateWapCancellationId;
+        }
+
         if (data.templateEmailNotifId) {
             updateCompany.templateEmailNotifId = data.templateEmailNotifId;
         }
@@ -213,6 +222,10 @@ export class CompaniesAdapterMongoose implements ICompaniesAdapter {
             updateCompany.templateEmailAltaId = data.templateEmailAltaId;
         }
 
+        if (data.templateEmailCancellationId) {
+            updateCompany.templateEmailCancellationId = data.templateEmailCancellationId;
+        }
+
         if (data.onboardingStep !== undefined) {
             updateCompany.onboardingStep = data.onboardingStep;
         }
@@ -225,6 +238,18 @@ export class CompaniesAdapterMongoose implements ICompaniesAdapter {
             updateCompany.banned = data.banned;
         }
 
+        if (data.showPublicScores !== undefined) {
+            updateCompany.showPublicScores = data.showPublicScores;
+        }
+
+        if (data.showPublicOpinions !== undefined) {
+            updateCompany.showPublicOpinions = data.showPublicOpinions;
+        }
+
+        if (data.showPublicProfessionals !== undefined) {
+            updateCompany.showPublicProfessionals = data.showPublicProfessionals;
+        }
+
         updateCompany.save();
 
         //actualizo los campos correspondientes a la localizacion de los servicios de la organizacion.

server/src/Models/Companies/Companies.Interface.ts

@@ -47,11 +47,16 @@ export type UpdateCompanyParams = {
     sessionUser: string;
     templateWapNotifId?: string;
     templateWapAltaId?: string;
+    templateWapCancellationId?: string;
     templateEmailNotifId?: string;
     templateEmailAltaId?: string;
+    templateEmailCancellationId?: string;
     onboardingStep?: number;
     onboardingCompleted?: boolean;
     banned?: boolean;
+    showPublicScores?: boolean;
+    showPublicOpinions?: boolean;
+    showPublicProfessionals?: boolean;
 };
 
 export type SetCompanyFileParams = {
@@ -144,12 +149,17 @@ export interface ICompany {
     automaticNotifications?: boolean;
     templateWapNotifId?: string;
     templateWapAltaId?: string;
+    templateWapCancellationId?: string;
     templateEmailNotifId?: string;
     templateEmailAltaId?: string;
+    templateEmailCancellationId?: string;
     onboardingStep?: number;
     onboardingCompleted?: boolean;
     fixedPostIds?: Array<string>;
     banned?: boolean;
+    showPublicScores?: boolean;
+    showPublicOpinions?: boolean;
+    showPublicProfessionals?: boolean;
 }
 
 export interface MyOranizationsView {
@@ -192,11 +202,16 @@ export interface MyOranizationsView {
     appointmentAlert?: string;
     templateWapNotifId?: string;
     templateWapAltaId?: string;
+    templateWapCancellationId?: string;
     templateEmailNotifId?: string;
     templateEmailAltaId?: string;
+    templateEmailCancellationId?: string;
     onboardingStep?: number;
     onboardingCompleted?: boolean;
     banned?: boolean;
+    showPublicScores?: boolean;
+    showPublicOpinions?: boolean;
+    showPublicProfessionals?: boolean;
 }
 
 export interface ClientOrganizationView {
@@ -249,6 +264,75 @@ export type SysAdminSetCompanyBannedParams = {
     banned: boolean;
 };
 
+export type SysAdminCompanyInsightsParams = {
+    companyId: string;
+};
+
+export type SysAdminCompanyInsightsResult = {
+    organization: {
+        id: string;
+        name: string;
+        slug: string;
+        description: string;
+        categoryId: number;
+        banned: boolean;
+        published?: COMPANY_PUBLISHED_STATUS;
+        onboardingStep?: number;
+        onboardingCompleted?: boolean;
+    };
+    owner: {
+        id: string;
+        firstName?: string;
+        lastName?: string;
+        email?: string;
+        verificated?: boolean;
+        phoneCountryCode?: string;
+        phoneAreaCode?: string;
+        phoneNumber?: string;
+    } | null;
+    collaborators: {
+        id: string;
+        userId?: string;
+        firstName?: string;
+        lastName?: string;
+        fullName?: string;
+        email?: string;
+        roles?: string[];
+        removed?: boolean;
+        active: boolean;
+        avatar?: string;
+    }[];
+    subscription: {
+        id: string;
+        startDate: Date;
+        endDate: Date;
+        isActive: boolean;
+        autoRenew: boolean;
+        mpStatus?: string;
+        pendingPaymentType?: "extension" | "upgrade";
+        plan: {
+            id: string;
+            name: string;
+            code: string;
+            price: number;
+            limitOrganizations: number;
+            limitEmployees: number;
+            limitServices: number;
+            limitAppointments: number;
+            limitClients: number;
+        } | null;
+    } | null;
+    stats: {
+        employeesCount: number;
+        activeEmployeesCount: number;
+        servicesCount: number;
+        activeServicesCount: number;
+        clientsCount: number;
+        activeClientsCount: number;
+        reservationsLast30Days: number;
+    };
+};
+
 export type FixCompanyPostParams = {
     companyId: string;
     postId: string;
@@ -295,4 +379,6 @@ export interface ICompaniesManager {
     sysAdminPaginate(data: SysAdminPaginateCompaniesParams): Promise<PaginateCompaniesResults>;
     sysAdminUpdate(data: SysAdminUpdateCompanyParams): Promise<void>;
     sysAdminSetBanned(data: SysAdminSetCompanyBannedParams): Promise<void>;
+    sysAdminGetInsights(data: SysAdminCompanyInsightsParams): Promise<SysAdminCompanyInsightsResult>;
+    checkCompanyAdmin(data: { companyId: string; sessionUser: string }): Promise<boolean>;
 }

server/src/Models/Companies/Companies.ts

@@ -27,6 +27,8 @@ import {
     SysAdminPaginateCompaniesParams,
     SysAdminUpdateCompanyParams,
     SysAdminSetCompanyBannedParams,
+    SysAdminCompanyInsightsParams,
+    SysAdminCompanyInsightsResult,
 } from "./Companies.Interface";
 import UsersManager from "../Users/Users";
 import EmployeesList from "../Employees/Employee";
@@ -54,11 +56,14 @@ import ClientAccount from "../ClientAccounts/ClientAccount";
 import Payments from "../Payments/Payments";
 import Discounts from "../Discounts/Discounts";
 import Templates from "../Templates/Templates";
+import PlanSubscriptionsList from "../PlanSubscriptions/PlanSubscriptons";
+import PlansList from "../Plans/Plans";
 
 import Posts from "../Posts/Posts";
 import SchedulesDisabledList from "../SchedulesDisabled/SchedulesDisabled";
 import DiscountsEmail from "../DiscountsEmail/DiscountsEmail";
 import { NotificationType } from "../../Models/SystemNotifications/SystemNotification.Interface";
+import getAvatar from "../../helpers/getAvatar";
 
 class CompaniesManager implements ICompaniesManager {
     companies: ICompaniesAdapter;
@@ -67,6 +72,17 @@ class CompaniesManager implements ICompaniesManager {
         this.companies = new CompaniesAdapterMongoose();
     }
 
+    private async validatePublicRatingFlagsPlan(ownerId: string): Promise<void> {
+        const { default: PlanSubscriptionsList } = await import("../PlanSubscriptions/PlanSubscriptons");
+        const subscription = await PlanSubscriptionsList.getSubscriptionByUser({
+            sessionUser: ownerId,
+        });
+
+        if (!subscription || subscription.plan.price === 0) {
+            throw new Error("Esta configuración está disponible solo para planes pagos.");
+        }
+    }
+
     public async toggleFixedPost(data: FixCompanyPostParams): Promise<void> {
         await validateSessionUser({
             sessionUser: data.sessionUser,
@@ -489,6 +505,14 @@ class CompaniesManager implements ICompaniesManager {
             throw new Error(NoPermissionMessage());
         }
 
+        if (
+            data.showPublicScores !== undefined ||
+            data.showPublicOpinions !== undefined ||
+            data.showPublicProfessionals !== undefined
+        ) {
+            await this.validatePublicRatingFlagsPlan(String(companyCheck.ownerId));
+        }
+
         let updateData = {
             ...data,
         };
@@ -597,6 +621,9 @@ class CompaniesManager implements ICompaniesManager {
             templateEmailAltaId: isNull<string>(company.templateEmailAltaId, ""),
             onboardingStep: company.onboardingStep,
             onboardingCompleted: company.onboardingCompleted,
+            showPublicScores: company.showPublicScores ?? true,
+            showPublicOpinions: company.showPublicOpinions ?? true,
+            showPublicProfessionals: company.showPublicProfessionals ?? true,
         };
     }
 
@@ -660,7 +687,11 @@ class CompaniesManager implements ICompaniesManager {
                 continue;
             }
 
-            const isAdmin = await EmployeesList.checkPermission(companyDoc, employ.id, EmployeeRoles.ADMIN);
+            const isAdmin = await EmployeesList.checkPermission(
+                companyDoc,
+                data.sessionUser,
+                EmployeeRoles.ADMIN
+            );
 
             returnData.push({
                 id: isNull<string>(company.id, ""),
@@ -716,6 +747,9 @@ class CompaniesManager implements ICompaniesManager {
                 templateEmailAltaId: isNull<string>(company.templateEmailAltaId, ""),
                 onboardingStep: company.onboardingStep,
                 onboardingCompleted: company.onboardingCompleted,
+                showPublicScores: company.showPublicScores ?? true,
+                showPublicOpinions: company.showPublicOpinions ?? true,
+                showPublicProfessionals: company.showPublicProfessionals ?? true,
             });
         }
 
@@ -786,6 +820,9 @@ class CompaniesManager implements ICompaniesManager {
                         templateEmailAltaId: isNull<string>(company.templateEmailAltaId, ""),
                         onboardingStep: company.onboardingStep,
                         onboardingCompleted: company.onboardingCompleted,
+                        showPublicScores: company.showPublicScores ?? true,
+                        showPublicOpinions: company.showPublicOpinions ?? true,
+                        showPublicProfessionals: company.showPublicProfessionals ?? true,
                     });
                 }
             }
@@ -1053,6 +1090,150 @@ class CompaniesManager implements ICompaniesManager {
             sessionUser: "" // sysadmin override
         });
     }
+
+    public async sysAdminGetInsights(data: SysAdminCompanyInsightsParams): Promise<SysAdminCompanyInsightsResult> {
+        const company = await this.companies.findOne({ _id: data.companyId });
+        if (!company) {
+            throw new Error("La compañia no existe");
+        }
+
+        const [ownerResult, subscriptionResult] = await Promise.allSettled([
+            UsersManager.users.findOne({ _id: String(company.ownerId) }),
+            PlanSubscriptionsList.planSuscriptions.planSuscriptionList
+            .findOne({ userId: String(company.ownerId) })
+            .sort({ endDate: -1 })
+            .exec(),
+        ]);
+        const owner = ownerResult.status === "fulfilled" ? ownerResult.value : null;
+        const subscription = subscriptionResult.status === "fulfilled" ? subscriptionResult.value : null;
+        const collaboratorsResult = await Promise.allSettled([
+            EmployeesList.employees.employeeList.find({ companyId: data.companyId }).exec(),
+        ]);
+        const employeeDocs = collaboratorsResult[0]?.status === "fulfilled" ? collaboratorsResult[0].value : [];
+        const collaboratorUserResults = await Promise.allSettled(
+            employeeDocs.map((employee) => employee.userId
+                ? UsersManager.users.findOne({ _id: String(employee.userId) })
+                : Promise.resolve(null))
+        );
+        const collaborators = employeeDocs.map((employee, index) => {
+            const userResult = collaboratorUserResults[index];
+            const user = userResult?.status === "fulfilled" ? userResult.value : null;
+            const firstName = user?.firstName || employee.profileSnapshot?.firstName;
+            const lastName = user?.lastName || employee.profileSnapshot?.lastName;
+            const fullName = [firstName, lastName].filter(Boolean).join(" ");
+            const avatar = user?.avatar
+                ? getAvatar(String(user.id || user._id), user.avatar, fullName)
+                : undefined;
+
+            return {
+                id: String(employee.id || employee._id),
+                userId: employee.userId ? String(employee.userId) : undefined,
+                firstName,
+                lastName,
+                fullName: fullName || undefined,
+                email: user?.email || employee.profileSnapshot?.email,
+                roles: employee.roles || [],
+                removed: employee.removed ?? false,
+                active: !(employee.removed ?? false),
+                avatar: avatar !== fullName ? avatar : undefined,
+            };
+        });
+        const planResult = subscription
+            ? await Promise.allSettled([PlansList.plans.planList.findOne({ _id: String(subscription.planId) }).exec()])
+            : [];
+        const plan = planResult[0]?.status === "fulfilled" ? planResult[0].value : null;
+        const thirtyDaysAgo = new Date();
+        thirtyDaysAgo.setUTCDate(thirtyDaysAgo.getUTCDate() - 30);
+        thirtyDaysAgo.setUTCHours(0, 0, 0, 0);
+
+        const [
+            employeesCount,
+            activeEmployeesCount,
+            servicesCount,
+            activeServicesCount,
+            clientsCount,
+            activeClientsCount,
+            reservationsLast30Days,
+        ] = (await Promise.allSettled([
+            EmployeesList.employees.employeeList.countDocuments({ companyId: data.companyId }).exec(),
+            EmployeesList.employees.employeeList.countDocuments({ companyId: data.companyId, removed: { $ne: true } }).exec(),
+            ServiceList.services.serviceList.countDocuments({ companyId: data.companyId }).exec(),
+            ServiceList.services.serviceList.countDocuments({ companyId: data.companyId, banned: { $ne: true } }).exec(),
+            ClientsList.clients.clientList.countDocuments({ companyId: data.companyId }).exec(),
+            ClientsList.clients.clientList.countDocuments({ companyId: data.companyId, status: true, banned: { $ne: true } }).exec(),
+            AppointmentList.Appointments.AppointmentList.countDocuments({
+                companyId: data.companyId,
+                start: { $gte: thirtyDaysAgo },
+            }).exec(),
+        ])).map((result) => result.status === "fulfilled" ? result.value : 0);
+
+        return {
+            organization: {
+                id: String(company.id || company._id),
+                name: company.name,
+                slug: company.slug,
+                description: company.description,
+                categoryId: company.categoryId,
+                banned: company.banned ?? false,
+                published: company.published,
+                onboardingStep: company.onboardingStep,
+                onboardingCompleted: company.onboardingCompleted,
+            },
+            owner: owner ? {
+                id: String(owner.id || owner._id),
+                firstName: owner.firstName,
+                lastName: owner.lastName,
+                email: owner.email,
+                verificated: owner.verificated,
+                phoneCountryCode: owner.phoneCountryCode,
+                phoneAreaCode: owner.phoneAreaCode,
+                phoneNumber: owner.phoneNumber,
+            } : null,
+            collaborators,
+            subscription: subscription ? {
+                id: String(subscription.id || subscription._id),
+                startDate: subscription.startDate,
+                endDate: subscription.endDate,
+                isActive: subscription.isActive,
+                autoRenew: subscription.autoRenew,
+                mpStatus: subscription.mpStatus,
+                pendingPaymentType: subscription.pendingPaymentType,
+                plan: plan ? {
+                    id: String(plan.id || plan._id),
+                    name: plan.name,
+                    code: plan.code,
+                    price: plan.price,
+                    limitOrganizations: plan.limitOrganizations,
+                    limitEmployees: plan.limitEmployees,
+                    limitServices: plan.limitServices,
+                    limitAppointments: plan.limitAppointments,
+                    limitClients: plan.limitClients,
+                } : null,
+            } : null,
+            stats: {
+                employeesCount,
+                activeEmployeesCount,
+                servicesCount,
+                activeServicesCount,
+                clientsCount,
+                activeClientsCount,
+                reservationsLast30Days,
+            },
+        };
+    }
+
+    public async checkCompanyAdmin(data: { companyId: string; sessionUser: string }): Promise<boolean> {
+        const filterData =
+            data.companyId.indexOf("-") >= 0 ? { slug: data.companyId } : { _id: data.companyId };
+
+        const company = await this.companies.findOne(filterData as any);
+
+        if (!company) {
+            return false;
+        }
+
+        return await EmployeesList.checkPermission(company, data.sessionUser, EmployeeRoles.ADMIN);
+    }
 }
 
 const CompaniesList = new CompaniesManager();

server/src/Models/Employees/Employee.ts

@@ -8,6 +8,9 @@ import {
     PaginateEmployeesParams,
     PaginateEmployeesResults,
     CompanyEmployeesView,
+    PublicCompanyEmployeeView,
+    FindPublicEmployeeParams,
+    PublicEmployeeView,
     FindEmployeesParams,
     FindEmployeesByIdParams,
     UpdateEmployeeRolesParams,
@@ -442,6 +445,71 @@ class EmployeeManager implements IEmployeesManager {
         return view;
     }
 
+    public async findPublicByCompanyId(
+        data: FindEmployeesParams
+    ): Promise<PublicCompanyEmployeeView[]> {
+        const employees = await this.employees.find({
+            companyId: data.companyId,
+            guestOk: true,
+            hostOk: true,
+            removed: { $ne: true },
+        } as any);
+
+        const view = await Promise.all(
+            employees.map(async (employee) => {
+                const userData = await UsersManager.users.findOne({ _id: employee.userId });
+
+                if (!userData) {
+                    return null;
+                }
+
+                const strFirstName = isNull<string>(userData.firstName, "");
+                const strLastName = isNull<string>(userData.lastName, "");
+                const strFullName = joinStrings([strFirstName, strLastName], " ");
+
+                return {
+                    employeeId: isNull<string>(employee.id, ""),
+                    userId: employee.userId,
+                    firstName: strFirstName,
+                    lastName: strLastName,
+                    avatarUrl: getAvatar(userData.id, userData.avatar, strFullName),
+                };
+            })
+        );
+
+        return view.filter((employee): employee is PublicCompanyEmployeeView => employee !== null);
+    }
+
+    public async findPublicByEmployeeId(data: FindPublicEmployeeParams): Promise<PublicEmployeeView> {
+        const employee = await this.employees.findOne({
+            _id: data.employeeId,
+            guestOk: true,
+            hostOk: true,
+            removed: { $ne: true },
+        } as any);
+
+        if (!employee) {
+            throw new Error("El colaborador no existe");
+        }
+
+        const userData = await UsersManager.users.findOne({ _id: employee.userId });
+
+        if (!userData) {
+            throw new Error("El colaborador no existe");
+        }
+
+        const strFirstName = isNull<string>(userData.firstName, "");
+        const strLastName = isNull<string>(userData.lastName, "");
+        const strFullName = joinStrings([strFirstName, strLastName], " ");
+
+        return {
+            employeeId: isNull<string>(employee.id, ""),
+            firstName: strFirstName,
+            lastName: strLastName,
+            avatarUrl: getAvatar(userData.id, userData.avatar, strFullName),
+        };
+    }
+
     public async findById(data: FindEmployeesByIdParams): Promise<CompanyEmployeesView> {
         const employee = await this.employees.findOne({ _id: data.id });
 

server/src/Models/Employees/Employees.Interface.ts

@@ -119,6 +119,25 @@ export interface CompanyEmployeesView {
     };
 }
 
+export interface PublicCompanyEmployeeView {
+    employeeId: string;
+    userId: string;
+    firstName: string;
+    lastName: string;
+    avatarUrl: string;
+}
+
+export interface FindPublicEmployeeParams {
+    employeeId: string;
+}
+
+export interface PublicEmployeeView {
+    employeeId: string;
+    firstName: string;
+    lastName: string;
+    avatarUrl: string;
+}
+
 export interface IncompleteCollaboratorView {
     employeeId: string;
     companyId: string;
@@ -143,6 +162,8 @@ export interface IEmployeesManager {
     updateEmployeeRoles(data: UpdateEmployeeRolesParams): Promise<void>;
     update(data: UpdateEmployeeParams): Promise<void>;
     findByCompanyId(data: FindEmployeesParams): Promise<CompanyEmployeesView[]>;
+    findPublicByCompanyId(data: FindEmployeesParams): Promise<PublicCompanyEmployeeView[]>;
+    findPublicByEmployeeId(data: FindPublicEmployeeParams): Promise<PublicEmployeeView>;
     findById(data: FindEmployeesByIdParams): Promise<CompanyEmployeesView>;
     textObjectFilter(data: FindEmployeesParams): Promise<TextObjectFilterResult[]>;
     deleteEmployeesByCompany(data: DeleteEmployeesByCompany): Promise<void>;

server/src/Models/Invoices/Invoices.Adapter.Mongoose.ts

@@ -0,0 +1,112 @@
+import { Document, FilterQuery, Model, Schema, model } from "mongoose";
+import {
+    CreateInvoiceParams,
+    FindInvoicesParams,
+    IInvoice,
+    IInvoicesAdapter,
+    INVOICE_STATUS,
+    INVOICE_TYPE,
+    UpdateInvoiceParams,
+} from "./Invoices.Interface";
+
+export interface IInvoiceDocument extends Omit<IInvoice, "id">, Document {}
+
+export class InvoicesAdapterMongoose implements IInvoicesAdapter {
+    schema: Schema;
+    invoiceList: Model<IInvoiceDocument>;
+
+    constructor() {
+        this.schema = new Schema({
+            cashMovementId: {
+                type: Schema.Types.ObjectId,
+                required: true,
+                ref: "CashFlow",
+                unique: true,
+                index: true,
+            },
+            companyId: {
+                type: Schema.Types.ObjectId,
+                required: true,
+                ref: "Company",
+                index: true,
+            },
+            clientId: { type: Schema.Types.ObjectId, required: false, ref: "Client" },
+            paymentId: { type: Schema.Types.ObjectId, required: false, ref: "Payment" },
+            clientAccountMovementId: {
+                type: Schema.Types.ObjectId,
+                required: false,
+                ref: "ClientAccountMovement",
+            },
+            appointmentId: { type: Schema.Types.ObjectId, required: false, ref: "Appointment" },
+            amount: { type: Number, required: true },
+            type: { type: String, required: true, enum: Object.values(INVOICE_TYPE) },
+            status: { type: String, required: true, enum: Object.values(INVOICE_STATUS), index: true },
+            billingDate: { type: Date, required: true },
+            servicePeriodFrom: { type: Date, required: true },
+            servicePeriodTo: { type: Date, required: true },
+            paymentDueDate: { type: Date, required: true },
+            activityCode: { type: String, required: true },
+            activityDescription: { type: String, required: true },
+            receiverIvaCondition: { type: Number, required: true, default: 5 },
+            receiverDocumentType: { type: Schema.Types.Mixed, required: false },
+            receiverDocumentNumber: { type: Schema.Types.Mixed, required: false },
+            receiverName: { type: String, required: false },
+            receiverAddress: { type: String, required: false },
+            receiverEmail: { type: String, required: false },
+            saleCondition: { type: String, required: true },
+            itemDescription: { type: String, required: true },
+            itemQuantity: { type: Number, required: true, default: 1 },
+            itemUnit: { type: String, required: false },
+            itemUnitPrice: { type: Number, required: true },
+            itemDiscountPercent: { type: Number, required: true, default: 0 },
+            itemDiscountAmount: { type: Number, required: true, default: 0 },
+            itemSubtotal: { type: Number, required: true },
+            cae: { type: String, required: false },
+            caeExpiresAt: { type: Date, required: false },
+            pointOfSale: { type: Number, required: false },
+            voucherNumber: { type: Number, required: false },
+            voucherType: { type: String, required: false },
+            arcaErrorCode: { type: String, required: false },
+            arcaErrorMessage: { type: String, required: false },
+            createdAt: { type: Date, required: true, default: Date.now },
+            updatedAt: { type: Date, required: true, default: Date.now },
+        });
+
+        this.invoiceList = model<IInvoiceDocument>("Invoice", this.schema);
+    }
+
+    public async create(data: CreateInvoiceParams): Promise<IInvoice> {
+        return await this.invoiceList.create(data);
+    }
+
+    private buildSearchCriteria(filters: FindInvoicesParams): FilterQuery<IInvoice> {
+        const searchCriteria: FilterQuery<IInvoice> = {};
+
+        if (filters.id) searchCriteria._id = filters.id;
+        if (filters.cashMovementId) searchCriteria.cashMovementId = filters.cashMovementId;
+        if (filters.cashMovementIds && filters.cashMovementIds.length > 0) {
+            searchCriteria.cashMovementId = { $in: filters.cashMovementIds };
+        }
+        if (filters.companyId) searchCriteria.companyId = filters.companyId;
+        if (filters.status) searchCriteria.status = filters.status;
+
+        return searchCriteria;
+    }
+
+    public async find(filters: FindInvoicesParams): Promise<IInvoice[]> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+        return this.invoiceList.find(searchCriteria).sort({ createdAt: -1 }).exec();
+    }
+
+    public async findOne(filters: FindInvoicesParams): Promise<IInvoiceDocument | null> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+        return this.invoiceList.findOne(searchCriteria).exec();
+    }
+
+    public async update(data: UpdateInvoiceParams): Promise<IInvoiceDocument | null> {
+        const { sessionUser, id, cashMovementId, cashMovementIds, companyId, ...updateData } = data;
+        const searchCriteria = this.buildSearchCriteria({ id, cashMovementId, companyId });
+        return this.invoiceList.findOneAndUpdate(searchCriteria, updateData, { new: true }).exec();
+    }
+
+}

server/src/Models/Invoices/Invoices.Interface.ts

@@ -0,0 +1,159 @@
+import { IInvoiceDocument } from "./Invoices.Adapter.Mongoose";
+
+export enum INVOICE_TYPE {
+    FACTURA_C = "FACTURA_C",
+}
+
+export enum INVOICE_STATUS {
+    PENDING_ARCA = "PENDING_ARCA",
+    APPROVED = "APPROVED",
+    PENDING_VERIFICATION = "PENDING_VERIFICATION",
+    REJECTED = "REJECTED",
+    FAILED = "FAILED",
+}
+
+export enum INVOICE_SALE_CONDITION {
+    CASH = "cash",
+    CONTADO = "contado",
+    BANK_TRANSFER = "bank_transfer",
+    CREDIT_CARD = "credit_card",
+    DEBIT_CARD = "debit_card",
+    CURRENT_ACCOUNT = "current_account",
+    CHECK = "check",
+    OTHER = "other",
+    ELECTRONIC_PAYMENT = "electronic_payment",
+}
+
+export const FINAL_CONSUMER_IVA_CONDITION_ID = 5;
+
+export type CreateInvoiceFromCashMovementParams = {
+    cashMovementId: string;
+    billingDate: Date | string;
+    servicePeriodFrom: Date | string;
+    servicePeriodTo: Date | string;
+    paymentDueDate: Date | string;
+    activityCode: string;
+    activityDescription: string;
+    receiverIvaCondition?: 5;
+    receiverDocumentType?: number | string;
+    receiverDocumentNumber?: number | string;
+    receiverName?: string;
+    receiverAddress?: string;
+    receiverEmail?: string;
+    saleCondition: INVOICE_SALE_CONDITION | string;
+    itemDescription: string;
+    itemQuantity?: number;
+    itemUnit?: string;
+    itemUnitPrice: number;
+    itemDiscountPercent?: number;
+    itemDiscountAmount?: number;
+    itemSubtotal: number;
+    sessionUser: string;
+};
+
+export type FindInvoicesParams = {
+    id?: string;
+    cashMovementId?: string;
+    cashMovementIds?: string[];
+    companyId?: string;
+    status?: INVOICE_STATUS;
+    sessionUser?: string;
+};
+
+export type CreateInvoiceParams = {
+    cashMovementId: string;
+    companyId: string;
+    clientId?: string;
+    paymentId?: string;
+    clientAccountMovementId?: string;
+    appointmentId?: string;
+    amount: number;
+    type: INVOICE_TYPE;
+    status: INVOICE_STATUS;
+    billingDate: Date;
+    servicePeriodFrom: Date;
+    servicePeriodTo: Date;
+    paymentDueDate: Date;
+    activityCode: string;
+    activityDescription: string;
+    receiverIvaCondition: 5;
+    receiverDocumentType?: number | string;
+    receiverDocumentNumber?: number | string;
+    receiverName?: string;
+    receiverAddress?: string;
+    receiverEmail?: string;
+    saleCondition: INVOICE_SALE_CONDITION | string;
+    itemDescription: string;
+    itemQuantity: number;
+    itemUnit?: string;
+    itemUnitPrice: number;
+    itemDiscountPercent: number;
+    itemDiscountAmount: number;
+    itemSubtotal: number;
+    cae?: string;
+    caeExpiresAt?: Date;
+    pointOfSale?: number;
+    voucherNumber?: number;
+    voucherType?: string;
+    arcaErrorCode?: string;
+    arcaErrorMessage?: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+
+export type UpdateInvoiceParams = FindInvoicesParams & Partial<CreateInvoiceParams>;
+
+export interface IInvoice {
+    id?: string;
+    cashMovementId: string;
+    companyId: string;
+    clientId?: string;
+    paymentId?: string;
+    clientAccountMovementId?: string;
+    appointmentId?: string;
+    amount: number;
+    type: INVOICE_TYPE;
+    status: INVOICE_STATUS;
+    billingDate: Date;
+    servicePeriodFrom: Date;
+    servicePeriodTo: Date;
+    paymentDueDate: Date;
+    activityCode: string;
+    activityDescription: string;
+    receiverIvaCondition: 5;
+    receiverDocumentType?: number | string;
+    receiverDocumentNumber?: number | string;
+    receiverName?: string;
+    receiverAddress?: string;
+    receiverEmail?: string;
+    saleCondition: INVOICE_SALE_CONDITION | string;
+    itemDescription: string;
+    itemQuantity: number;
+    itemUnit?: string;
+    itemUnitPrice: number;
+    itemDiscountPercent: number;
+    itemDiscountAmount: number;
+    itemSubtotal: number;
+    cae?: string;
+    caeExpiresAt?: Date;
+    pointOfSale?: number;
+    voucherNumber?: number;
+    voucherType?: string;
+    arcaErrorCode?: string;
+    arcaErrorMessage?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface IInvoicesAdapter {
+    create(data: CreateInvoiceParams): Promise<IInvoice>;
+    find(filters: FindInvoicesParams): Promise<IInvoice[]>;
+    findOne(filters: FindInvoicesParams): Promise<IInvoiceDocument | null>;
+    update(data: UpdateInvoiceParams): Promise<IInvoiceDocument | null>;
+}
+
+export interface IInvoicesManager {
+    invoices: IInvoicesAdapter;
+    createFromCashMovement(data: CreateInvoiceFromCashMovementParams): Promise<IInvoice>;
+    find(data: FindInvoicesParams): Promise<IInvoice[]>;
+}

server/src/Models/Invoices/Invoices.ts

@@ -0,0 +1,518 @@
+import CashFlow from "../CashFlow/CashFlow";
+import { CLIENT_ACCOUNT_MOVEMENT_TYPES } from "../ClientAccountMovements/ClientAccountMovements.Interface";
+import CompaniesList from "../Companies/Companies";
+import OrganizationFiscalProfiles from "../OrganizationFiscalProfiles/OrganizationFiscalProfiles";
+import { ORGANIZATION_FISCAL_PROFILE_STATUS } from "../OrganizationFiscalProfiles/OrganizationFiscalProfiles.Interface";
+import ArcaCredentials, { ArcaWsfeIssueFacturaCError } from "../ArcaCredentials/ArcaCredentials";
+import PlanSubscriptionsList from "../PlanSubscriptions/PlanSubscriptons";
+import { PlanFeatures } from "../Plans/Plans.interface";
+import { validatePermissionsByCompany, validateSessionUser } from "../../helpers/check";
+import { InvoicesAdapterMongoose } from "./Invoices.Adapter.Mongoose";
+import {
+    CreateInvoiceFromCashMovementParams,
+    CreateInvoiceParams,
+    FindInvoicesParams,
+    FINAL_CONSUMER_IVA_CONDITION_ID,
+    IInvoice,
+    IInvoicesManager,
+    INVOICE_SALE_CONDITION,
+    INVOICE_STATUS,
+    INVOICE_TYPE,
+} from "./Invoices.Interface";
+
+const FACTURA_C_VOUCHER_TYPE = "11";
+const ARGENTINA_TIME_ZONE = "America/Argentina/Buenos_Aires";
+const TEXT_MAX_LENGTH = 500;
+const RECEIVER_TEXT_MAX_LENGTH = 200;
+const CENTS_TOLERANCE = 0.01;
+const YYYY_MM_DD_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const DNI_DOCUMENT_TYPE = 96;
+const FINAL_CONSUMER_DOCUMENT_TYPE = 99;
+const FINAL_CONSUMER_DOCUMENT_NUMBER = 0;
+const FINAL_CONSUMER_COMPATIBLE_DOCUMENT_TYPES = new Set([DNI_DOCUMENT_TYPE, FINAL_CONSUMER_DOCUMENT_TYPE]);
+
+class InvoicesManager implements IInvoicesManager {
+    invoices: InvoicesAdapterMongoose;
+
+    constructor() {
+        this.invoices = new InvoicesAdapterMongoose();
+    }
+
+    private isDuplicateKeyError(error: unknown): boolean {
+        return typeof error === "object" && error !== null && "code" in error && error.code === 11000;
+    }
+
+    private async validatePaymentsPlan(companyId: string): Promise<void> {
+        const company = await CompaniesList.companies.findOne({ _id: companyId });
+
+        if (!company) {
+            throw new Error("No se ha encontrado la organización");
+        }
+
+        const canAccess = await PlanSubscriptionsList.checkFeature({
+            userId: String(company.ownerId),
+            feature: PlanFeatures.PAYMENTS,
+        });
+
+        if (!canAccess) {
+            throw new Error("La organizacion no tiene un plan que soporte el módulo de pagos");
+        }
+    }
+
+    private formatArgentinaCalendarDate(date: Date): string {
+        const parts = new Intl.DateTimeFormat("en-US", {
+            timeZone: ARGENTINA_TIME_ZONE,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        }).formatToParts(date);
+        const year = parts.find((part) => part.type === "year")?.value || "";
+        const month = parts.find((part) => part.type === "month")?.value || "";
+        const day = parts.find((part) => part.type === "day")?.value || "";
+        return `${year}-${month}-${day}`;
+    }
+
+    private parseArgentinaCalendarDate(dateValue: Date | string, requiredMessage: string, invalidMessage: string): Date {
+        if (!dateValue) {
+            throw new Error(requiredMessage);
+        }
+
+        let parsedDate: Date;
+
+        if (typeof dateValue === "string") {
+            const localDateMatch = dateValue.match(YYYY_MM_DD_PATTERN);
+
+            if (!localDateMatch) {
+                throw new Error(invalidMessage);
+            }
+
+            const [, year, month, day] = localDateMatch;
+            const yearNumber = Number(year);
+            const monthNumber = Number(month);
+            const dayNumber = Number(day);
+            parsedDate = new Date(Date.UTC(yearNumber, monthNumber - 1, dayNumber, 12));
+
+            if (
+                parsedDate.getUTCFullYear() !== yearNumber ||
+                parsedDate.getUTCMonth() !== monthNumber - 1 ||
+                parsedDate.getUTCDate() !== dayNumber
+            ) {
+                throw new Error(invalidMessage);
+            }
+        } else {
+            parsedDate = dateValue;
+        }
+
+        if (Number.isNaN(parsedDate.getTime())) {
+            throw new Error(invalidMessage);
+        }
+
+        return parsedDate;
+    }
+
+    private parseBillingDate(billingDate: Date | string): Date {
+        const parsedDate = this.parseArgentinaCalendarDate(
+            billingDate,
+            "Se requiere la fecha del comprobante",
+            "La fecha del comprobante no es válida"
+        );
+
+        const selectedDate = this.formatArgentinaCalendarDate(parsedDate);
+        const todayDate = this.formatArgentinaCalendarDate(new Date());
+
+        if (selectedDate > todayDate) {
+            throw new Error("La fecha del comprobante no puede ser futura");
+        }
+
+        return parsedDate;
+    }
+
+    private validateSaleCondition(saleCondition: string): INVOICE_SALE_CONDITION {
+        if (!Object.values(INVOICE_SALE_CONDITION).includes(saleCondition as INVOICE_SALE_CONDITION)) {
+            throw new Error("La condición de venta de la factura no es válida");
+        }
+
+        return saleCondition as INVOICE_SALE_CONDITION;
+    }
+
+    private trimOptional(value?: string): string | undefined {
+        const trimmed = value?.trim();
+        return trimmed || undefined;
+    }
+
+    private parseReceiverDocumentCode(value: number | string, fieldName: string): number {
+        if (typeof value === "string" && value.trim() === "") {
+            throw new Error(`${fieldName} del receptor no es válido`);
+        }
+
+        const parsedValue = typeof value === "string" ? Number(value.trim()) : value;
+
+        if (!Number.isInteger(parsedValue) || !Number.isFinite(parsedValue) || parsedValue < 0) {
+            throw new Error(`${fieldName} del receptor no es válido`);
+        }
+
+        return parsedValue;
+    }
+
+    private validateReceiverDocumentPair(data: CreateInvoiceFromCashMovementParams): {
+        receiverDocumentType: number;
+        receiverDocumentNumber: number;
+    } {
+        const hasDocumentType = data.receiverDocumentType !== undefined && data.receiverDocumentType !== null && data.receiverDocumentType !== "";
+        const hasDocumentNumber = data.receiverDocumentNumber !== undefined && data.receiverDocumentNumber !== null && data.receiverDocumentNumber !== "";
+
+        if (hasDocumentType !== hasDocumentNumber) {
+            throw new Error("Tipo y número de documento del receptor deben informarse juntos");
+        }
+
+        if (!hasDocumentType && !hasDocumentNumber) {
+            return {
+                receiverDocumentType: FINAL_CONSUMER_DOCUMENT_TYPE,
+                receiverDocumentNumber: FINAL_CONSUMER_DOCUMENT_NUMBER,
+            };
+        }
+
+        const receiverDocumentType = this.parseReceiverDocumentCode(data.receiverDocumentType as number | string, "El tipo de documento");
+        const receiverDocumentNumber = this.parseReceiverDocumentCode(data.receiverDocumentNumber as number | string, "El número de documento");
+
+        if (!FINAL_CONSUMER_COMPATIBLE_DOCUMENT_TYPES.has(receiverDocumentType)) {
+            throw new Error("El tipo de documento del receptor no es compatible con Consumidor Final");
+        }
+
+        if (receiverDocumentType === FINAL_CONSUMER_DOCUMENT_TYPE && receiverDocumentNumber !== FINAL_CONSUMER_DOCUMENT_NUMBER) {
+            throw new Error("El número de documento debe ser 0 cuando el tipo es Consumidor Final");
+        }
+
+        return {
+            receiverDocumentType,
+            receiverDocumentNumber,
+        };
+    }
+
+    public async createFromCashMovement(data: CreateInvoiceFromCashMovementParams): Promise<IInvoice> {
+        await validateSessionUser({ sessionUser: data.sessionUser });
+
+        if (!data.cashMovementId || !data.cashMovementId.trim()) {
+            throw new Error("Se requiere un movimiento de caja para emitir la factura");
+        }
+
+        const billingDate = this.parseBillingDate(data.billingDate);
+        const servicePeriodFrom = this.parseArgentinaCalendarDate(
+            data.servicePeriodFrom,
+            "Se requiere la fecha de inicio del período facturado",
+            "La fecha de inicio del período facturado no es válida"
+        );
+        const servicePeriodTo = this.parseArgentinaCalendarDate(
+            data.servicePeriodTo,
+            "Se requiere la fecha de fin del período facturado",
+            "La fecha de fin del período facturado no es válida"
+        );
+        const paymentDueDate = this.parseArgentinaCalendarDate(
+            data.paymentDueDate,
+            "Se requiere el vencimiento de pago",
+            "El vencimiento de pago no es válido"
+        );
+        const servicePeriodFromValue = this.formatArgentinaCalendarDate(servicePeriodFrom);
+        const servicePeriodToValue = this.formatArgentinaCalendarDate(servicePeriodTo);
+        const billingDateValue = this.formatArgentinaCalendarDate(billingDate);
+        const paymentDueDateValue = this.formatArgentinaCalendarDate(paymentDueDate);
+
+        if (servicePeriodFromValue > servicePeriodToValue) {
+            throw new Error("El inicio del período facturado no puede ser posterior al fin");
+        }
+
+        if (paymentDueDateValue < billingDateValue) {
+            throw new Error("El vencimiento de pago no puede ser anterior a la fecha del comprobante");
+        }
+
+        const activityCode = data.activityCode?.trim();
+        const activityDescription = data.activityDescription?.trim();
+        const itemDescription = data.itemDescription?.trim();
+
+        if (!activityCode) {
+            throw new Error("Se requiere el código de actividad");
+        }
+
+        if (!activityDescription) {
+            throw new Error("Se requiere la descripción de la actividad");
+        }
+
+        if (!itemDescription) {
+            throw new Error("Se requiere la descripción del ítem facturado");
+        }
+
+        if ([activityCode, activityDescription, itemDescription].some((value) => value.length > TEXT_MAX_LENGTH)) {
+            throw new Error(`Los datos de actividad e ítem no pueden superar los ${TEXT_MAX_LENGTH} caracteres`);
+        }
+
+        if (!data.saleCondition || !data.saleCondition.trim()) {
+            throw new Error("Se requiere la condición de venta");
+        }
+
+        const saleCondition = this.validateSaleCondition(data.saleCondition.trim());
+        const receiverDocument = this.validateReceiverDocumentPair(data);
+        const itemQuantity = data.itemQuantity ?? 1;
+        const itemDiscountPercent = data.itemDiscountPercent ?? 0;
+        const itemDiscountAmount = data.itemDiscountAmount ?? 0;
+
+        if (!Number.isFinite(data.itemUnitPrice) || !Number.isFinite(data.itemSubtotal)) {
+            throw new Error("El importe del ítem no es válido");
+        }
+
+        if (itemQuantity !== 1 || data.itemUnitPrice <= 0 || itemDiscountPercent !== 0 || itemDiscountAmount !== 0) {
+            throw new Error("El MVP permite un único ítem de servicio sin descuentos por el total del movimiento");
+        }
+
+        const movement = await CashFlow.movements.movementList.findOne({
+            _id: data.cashMovementId,
+        });
+
+        if (!movement) {
+            throw new Error("No se ha encontrado el movimiento de caja");
+        }
+
+        const companyId = String(movement.companyId);
+        await validatePermissionsByCompany({ companyId, sessionUser: data.sessionUser });
+        await this.validatePaymentsPlan(companyId);
+
+        if (movement.type !== CLIENT_ACCOUNT_MOVEMENT_TYPES.DEPOSIT || movement.amount <= 0) {
+            throw new Error("El movimiento de caja no es facturable");
+        }
+
+        const expectedSubtotal = Number((itemQuantity * data.itemUnitPrice - itemDiscountAmount).toFixed(2));
+        const sentSubtotal = Number(data.itemSubtotal.toFixed(2));
+        const movementAmount = Number(movement.amount.toFixed(2));
+
+        if (
+            Math.abs(expectedSubtotal - sentSubtotal) > CENTS_TOLERANCE ||
+            Math.abs(sentSubtotal - movementAmount) > CENTS_TOLERANCE
+        ) {
+            throw new Error("El total del ítem debe coincidir con el importe del movimiento");
+        }
+
+        const fiscalProfiles = await OrganizationFiscalProfiles.find({
+            companyId,
+            status: ORGANIZATION_FISCAL_PROFILE_STATUS.ACTIVE,
+            sessionUser: data.sessionUser,
+        });
+
+        if (fiscalProfiles.length === 0) {
+            throw new Error("La organización debe tener un perfil fiscal activo para emitir facturas");
+        }
+
+        const existingInvoice = await this.invoices.findOne({
+            cashMovementId: data.cashMovementId,
+        });
+
+        if (existingInvoice?.status === INVOICE_STATUS.APPROVED) {
+            return existingInvoice;
+        }
+
+        if (existingInvoice?.status === INVOICE_STATUS.PENDING_VERIFICATION) {
+            return existingInvoice;
+        }
+
+        if (existingInvoice?.status === INVOICE_STATUS.PENDING_ARCA && existingInvoice.voucherNumber) {
+            const updatedPendingInvoice = await this.invoices.update({
+                cashMovementId: data.cashMovementId,
+                status: INVOICE_STATUS.PENDING_VERIFICATION,
+                arcaErrorMessage:
+                    existingInvoice.arcaErrorMessage ||
+                    "La emisión quedó pendiente de verificación en ARCA. Revisá el comprobante antes de reintentar.",
+                updatedAt: new Date(),
+            });
+
+            return updatedPendingInvoice || existingInvoice;
+        }
+
+        const baseInvoiceData: CreateInvoiceParams = {
+            cashMovementId: data.cashMovementId,
+            companyId,
+            clientId: movement.clientId ? String(movement.clientId) : undefined,
+            paymentId: movement.paymentId ? String(movement.paymentId) : undefined,
+            clientAccountMovementId: movement.clientAccountMovementId
+                ? String(movement.clientAccountMovementId)
+                : undefined,
+            appointmentId: movement.appointmentId ? String(movement.appointmentId) : undefined,
+            amount: movement.amount,
+            type: INVOICE_TYPE.FACTURA_C,
+            status: INVOICE_STATUS.PENDING_ARCA,
+            billingDate,
+            servicePeriodFrom,
+            servicePeriodTo,
+            paymentDueDate,
+            activityCode,
+            activityDescription,
+            receiverIvaCondition: FINAL_CONSUMER_IVA_CONDITION_ID,
+            receiverDocumentType: receiverDocument.receiverDocumentType,
+            receiverDocumentNumber: receiverDocument.receiverDocumentNumber,
+            receiverName: this.trimOptional(data.receiverName)?.slice(0, RECEIVER_TEXT_MAX_LENGTH),
+            receiverAddress: this.trimOptional(data.receiverAddress)?.slice(0, RECEIVER_TEXT_MAX_LENGTH),
+            receiverEmail: this.trimOptional(data.receiverEmail)?.slice(0, RECEIVER_TEXT_MAX_LENGTH),
+            saleCondition,
+            itemDescription,
+            itemQuantity,
+            itemUnit: this.trimOptional(data.itemUnit),
+            itemUnitPrice: data.itemUnitPrice,
+            itemDiscountPercent,
+            itemDiscountAmount,
+            itemSubtotal: sentSubtotal,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        let invoice: IInvoice | null = existingInvoice;
+
+        if (!invoice) {
+            try {
+                invoice = await this.invoices.create(baseInvoiceData);
+            } catch (error) {
+                if (this.isDuplicateKeyError(error)) {
+                    const duplicateInvoice = await this.invoices.findOne({
+                        cashMovementId: data.cashMovementId,
+                    });
+
+                    if (duplicateInvoice) {
+                        return duplicateInvoice;
+                    }
+                }
+
+                throw error;
+            }
+        }
+
+        if (!invoice) {
+            throw new Error("No se pudo crear el registro local de factura");
+        }
+
+        if (
+            existingInvoice?.status === INVOICE_STATUS.PENDING_ARCA ||
+            existingInvoice?.status === INVOICE_STATUS.REJECTED ||
+            existingInvoice?.status === INVOICE_STATUS.FAILED
+        ) {
+            invoice = await this.invoices.update({
+                cashMovementId: data.cashMovementId,
+                billingDate,
+                servicePeriodFrom,
+                servicePeriodTo,
+                paymentDueDate,
+                activityCode,
+                activityDescription,
+                receiverIvaCondition: FINAL_CONSUMER_IVA_CONDITION_ID,
+                receiverDocumentType: receiverDocument.receiverDocumentType,
+                receiverDocumentNumber: receiverDocument.receiverDocumentNumber,
+                receiverName: this.trimOptional(data.receiverName)?.slice(0, RECEIVER_TEXT_MAX_LENGTH),
+                receiverAddress: this.trimOptional(data.receiverAddress)?.slice(0, RECEIVER_TEXT_MAX_LENGTH),
+                receiverEmail: this.trimOptional(data.receiverEmail)?.slice(0, RECEIVER_TEXT_MAX_LENGTH),
+                saleCondition,
+                itemDescription,
+                itemQuantity,
+                itemUnit: this.trimOptional(data.itemUnit),
+                itemUnitPrice: data.itemUnitPrice,
+                itemDiscountPercent,
+                itemDiscountAmount,
+                itemSubtotal: sentSubtotal,
+                updatedAt: new Date(),
+            }) || invoice;
+        }
+
+        let invoiceData: Pick<
+            CreateInvoiceParams,
+            | "status"
+            | "cae"
+            | "caeExpiresAt"
+            | "pointOfSale"
+            | "voucherNumber"
+            | "voucherType"
+            | "arcaErrorMessage"
+        >;
+
+        try {
+            const arcaInvoice = await ArcaCredentials.issueFacturaC({
+                companyId,
+                amount: movement.amount,
+                billingDate,
+                servicePeriodFrom,
+                servicePeriodTo,
+                paymentDueDate,
+                receiverDocumentType: receiverDocument.receiverDocumentType,
+                receiverDocumentNumber: receiverDocument.receiverDocumentNumber,
+                sessionUser: data.sessionUser,
+            });
+
+            invoiceData = {
+                status: INVOICE_STATUS.APPROVED,
+                cae: arcaInvoice.cae,
+                caeExpiresAt: arcaInvoice.caeExpiresAt,
+                pointOfSale: arcaInvoice.pointOfSale,
+                voucherNumber: arcaInvoice.voucherNumber,
+                voucherType: String(arcaInvoice.voucherType),
+                arcaErrorMessage: "",
+            };
+        } catch (error) {
+            const errorOccurred = error as Error;
+            const arcaError = error as ArcaWsfeIssueFacturaCError;
+            const hasArcaAttempt = error instanceof ArcaWsfeIssueFacturaCError;
+            invoiceData = {
+                status: hasArcaAttempt
+                    ? arcaError.isAmbiguous
+                        ? INVOICE_STATUS.PENDING_VERIFICATION
+                        : INVOICE_STATUS.REJECTED
+                    : INVOICE_STATUS.FAILED,
+                pointOfSale: hasArcaAttempt ? arcaError.attempt.pointOfSale : undefined,
+                voucherNumber: hasArcaAttempt ? arcaError.attempt.voucherNumber : undefined,
+                voucherType: hasArcaAttempt ? String(arcaError.attempt.voucherType) : FACTURA_C_VOUCHER_TYPE,
+                arcaErrorMessage: errorOccurred.message,
+            };
+        }
+
+        const updatedInvoice = await this.invoices.update({
+            cashMovementId: data.cashMovementId,
+            ...invoiceData,
+            updatedAt: new Date(),
+        });
+
+        if (!updatedInvoice) {
+            return invoice;
+        }
+
+        return updatedInvoice;
+    }
+
+    public async find(data: FindInvoicesParams): Promise<IInvoice[]> {
+        if (!data.sessionUser) {
+            throw new Error("Se requiere un usuario autenticado");
+        }
+
+        const sessionUser = data.sessionUser;
+        await validateSessionUser({ sessionUser });
+
+        if (data.companyId) {
+            await validatePermissionsByCompany({
+                companyId: data.companyId,
+                sessionUser,
+            });
+            await this.validatePaymentsPlan(data.companyId);
+        } else if (data.id || data.cashMovementId) {
+            const invoice = await this.invoices.findOne(data);
+
+            if (!invoice) {
+                return [];
+            }
+
+            await validatePermissionsByCompany({
+                companyId: String(invoice.companyId),
+                sessionUser,
+            });
+            await this.validatePaymentsPlan(String(invoice.companyId));
+
+            return [invoice];
+        } else {
+            throw new Error("Se requiere una organización para buscar facturas");
+        }
+
+        return await this.invoices.find(data);
+    }
+}
+
+export default new InvoicesManager();

server/src/Models/Metrics/Metrics.Adapter.Mongoose.ts

@@ -157,7 +157,10 @@ export class MetricsAdapterMongoose implements IMetricsAdapter {
         if (!metrics.repeatsCount) {
             metrics.repeatsCount = 0;
         }
-        metrics.repeatsCount += isNull<number>(data.quantity, 1);
+        metrics.repeatsCount = Math.max(
+            0,
+            isNull<number>(metrics.repeatsCount, 0) + isNull<number>(data.quantity, 1)
+        );
         await metrics.save();
     }
 }

server/src/Models/Metrics/Metrics.Interface.ts

@@ -37,6 +37,7 @@ export interface IMetricsAdapter {
     addService(data: MetricsParams): Promise<void>;
     addAppointment(data: MetricsParams): Promise<void>;
     addClient(data: MetricsParams): Promise<void>;
+    addRepeat(data: MetricsParams): Promise<void>;
 }
 
 export interface IMetricsManager {
@@ -50,6 +51,7 @@ export interface IMetricsManager {
     reserveAppointment(data: MetricsParams): Promise<boolean>;
     releaseAppointment(data: MetricsParams): Promise<void>;
     addClient(data: MetricsParams): Promise<void>;
+    addRepeat(data: MetricsParams): Promise<void>;
     canAddOrganization(userId: string): Promise<boolean>;
     canAddEmployee(userId: string): Promise<boolean>;
     canAddService(userId: string): Promise<boolean>;

server/src/Models/NotificationJobs/NotificationJobs.Adapter.Mongoose.ts

@@ -0,0 +1,187 @@
+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 {}
+
+export class NotificationJobsAdapterMongoose implements INotificationJobAdapter {
+    schema: Schema;
+    notificationJobList: Model<INotificationJobDocument>;
+    private lastCleanupAt?: number;
+
+    constructor() {
+        this.schema = new Schema(
+            {
+                companyId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    ref: "Company",
+                },
+                appointmentId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    ref: "Appointment",
+                },
+                clientId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    ref: "Client",
+                },
+                channel: {
+                    type: String,
+                    required: true,
+                    enum: ["whatsapp", "email", "system"],
+                },
+                type: {
+                    type: String,
+                    required: true,
+                    enum: ["creation", "reminder", "update", "cancellation"],
+                },
+                scheduledAt: { type: Date, required: true },
+                status: {
+                    type: String,
+                    required: true,
+                    enum: Object.values(NotificationJobStatus),
+                    default: NotificationJobStatus.PENDING,
+                },
+                attempts: { type: Number, required: true, default: 0 },
+                maxAttempts: { type: Number, required: true, default: 3 },
+                lastError: { type: String, required: false },
+                nextRetryAt: { type: Date, required: false },
+                providerResponse: { type: String, required: false },
+                payload: { type: Schema.Types.Mixed, required: false },
+                sentAt: { type: Date, required: false },
+            },
+            {
+                timestamps: true,
+            }
+        );
+
+        this.schema.index({ status: 1, scheduledAt: 1 });
+        this.schema.index({ companyId: 1, status: 1 });
+        this.schema.index({ appointmentId: 1 });
+
+        this.notificationJobList = model<INotificationJobDocument>(
+            "NotificationJob",
+            this.schema
+        );
+    }
+
+    public async create(data: CreateJobParams): Promise<INotificationJob> {
+        await this.cleanupOldJobsIfDueSafely();
+        const doc = await this.notificationJobList.create({
+            ...data,
+            status: NotificationJobStatus.PENDING,
+            attempts: 0,
+            maxAttempts: 3,
+        });
+        return doc.toObject() as INotificationJob;
+    }
+
+    public async findPendingDue(now: Date): Promise<INotificationJob[]> {
+        const docs = await this.notificationJobList
+            .find({
+                status: NotificationJobStatus.PENDING,
+                scheduledAt: { $lte: now },
+            })
+            .sort({ scheduledAt: 1 })
+            .exec();
+        return docs.map((d) => d.toObject() as INotificationJob);
+    }
+
+    public async updateStatus(
+        jobId: string,
+        status: NotificationJobStatus,
+        data?: { lastError?: string; nextRetryAt?: Date; providerResponse?: string }
+    ): Promise<void> {
+        const update: Record<string, unknown> = { status };
+        if (status === NotificationJobStatus.SENT) {
+            update.sentAt = new Date();
+        }
+        if (data?.lastError !== undefined) update.lastError = data.lastError;
+        if (data?.nextRetryAt !== undefined) update.nextRetryAt = data.nextRetryAt;
+        if (data?.providerResponse !== undefined)
+            update.providerResponse = data.providerResponse;
+
+        await this.notificationJobList.updateOne({ _id: jobId }, { $set: update }).exec();
+    }
+
+    public async cancelByAppointment(appointmentId: string): Promise<void> {
+        await this.cleanupOldJobsIfDueSafely();
+        await this.notificationJobList
+            .updateMany(
+                {
+                    appointmentId,
+                    status: NotificationJobStatus.PENDING,
+                },
+                { $set: { status: NotificationJobStatus.CANCELLED } }
+            )
+            .exec();
+    }
+
+    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

@@ -0,0 +1,83 @@
+export enum NotificationJobStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    SENT = "sent",
+    FAILED = "failed",
+    CANCELLED = "cancelled",
+}
+
+export type NotificationChannel = "whatsapp" | "email" | "system";
+
+export type NotificationJobType =
+    | "creation"
+    | "reminder"
+    | "update"
+    | "cancellation";
+
+export interface NotificationJobPayload {
+    email?: string;
+    phoneNumber?: string;
+    userId?: string;
+    companyOwnerId?: string;
+    subject?: string;
+    message?: string;
+    emailSubject?: string;
+    emailMessage?: string;
+    emailTemplateId?: string;
+    emailContext?: Record<string, unknown>;
+    wapMessage?: string;
+    systemSubject?: string;
+    systemMessage?: string;
+}
+
+export interface INotificationJob {
+    id?: string;
+    companyId: string;
+    appointmentId: string;
+    clientId: string;
+    channel: NotificationChannel;
+    type: NotificationJobType;
+    scheduledAt: Date;
+    status: NotificationJobStatus;
+    attempts: number;
+    maxAttempts: number;
+    lastError?: string;
+    nextRetryAt?: Date;
+    providerResponse?: string;
+    payload?: NotificationJobPayload;
+    createdAt: Date;
+    updatedAt: Date;
+    sentAt?: Date;
+}
+
+export interface CreateJobParams {
+    companyId: string;
+    appointmentId: string;
+    clientId: string;
+    channel: NotificationChannel;
+    type: NotificationJobType;
+    scheduledAt: Date;
+    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[]>;
+    updateStatus(
+        jobId: string,
+        status: NotificationJobStatus,
+        data?: { lastError?: string; nextRetryAt?: Date; providerResponse?: string }
+    ): Promise<void>;
+    cancelByAppointment(appointmentId: string): Promise<void>;
+    findByAppointment(appointmentId: string): Promise<INotificationJob[]>;
+    deleteOldJobs(data: DeleteOldJobsParams): Promise<DeleteOldJobsResult>;
+}

server/src/Models/NotificationJobs/NotificationJobs.ts

@@ -0,0 +1,28 @@
+import {
+    CreateJobParams,
+    INotificationJob,
+} from "./NotificationJobs.Interface";
+import { NotificationJobsAdapterMongoose } from "./NotificationJobs.Adapter.Mongoose";
+
+class NotificationJobManager {
+    adapter: NotificationJobsAdapterMongoose;
+
+    constructor() {
+        this.adapter = new NotificationJobsAdapterMongoose();
+    }
+
+    public async createJob(data: CreateJobParams): Promise<INotificationJob> {
+        return this.adapter.create(data);
+    }
+
+    public async cancelByAppointment(appointmentId: string): Promise<void> {
+        return this.adapter.cancelByAppointment(appointmentId);
+    }
+
+    public async findByAppointment(appointmentId: string): Promise<INotificationJob[]> {
+        return this.adapter.findByAppointment(appointmentId);
+    }
+}
+
+const NotificationJobsList = new NotificationJobManager();
+export default NotificationJobsList;

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/Models/NotificationPolicies/ClientCompanyNotificationOverride.Adapter.Mongoose.ts

@@ -0,0 +1,84 @@
+import { Document, Model, Schema, model, models } from "mongoose";
+import {
+    FindClientCompanyOverrideParams,
+    IClientCompanyNotificationOverride,
+    IClientCompanyNotificationOverrideAdapter,
+} from "./ClientCompanyNotificationOverride.Interface";
+
+export interface IClientCompanyNotificationOverrideDocument
+    extends Omit<IClientCompanyNotificationOverride, "id">,
+        Document {}
+
+export class ClientCompanyNotificationOverrideAdapterMongoose
+    implements IClientCompanyNotificationOverrideAdapter
+{
+    schema: Schema;
+    overrideList: Model<IClientCompanyNotificationOverrideDocument>;
+
+    constructor() {
+        this.schema = new Schema(
+            {
+                clientId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    ref: "Client",
+                },
+                companyId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    ref: "Company",
+                },
+                preferredChannels: {
+                    type: [String],
+                    required: true,
+                    default: ["whatsapp", "email", "system"],
+                    enum: ["whatsapp", "email", "system"],
+                },
+                mutedChannels: {
+                    type: [String],
+                    required: true,
+                    default: [],
+                    enum: ["whatsapp", "email", "system"],
+                },
+            },
+            {
+                timestamps: true,
+            }
+        );
+
+        this.schema.index({ clientId: 1, companyId: 1 }, { unique: true });
+
+        this.overrideList = models.ClientCompanyNotificationOverride ||
+            model<IClientCompanyNotificationOverrideDocument>(
+                "ClientCompanyNotificationOverride",
+                this.schema
+            );
+    }
+
+    public async findOne(
+        filters: FindClientCompanyOverrideParams
+    ): Promise<IClientCompanyNotificationOverride | null> {
+        const doc = await this.overrideList.findOne(filters).exec();
+        return doc ? (doc.toObject() as IClientCompanyNotificationOverride) : null;
+    }
+
+    public async upsert(
+        clientId: string,
+        companyId: string,
+        data: Partial<
+            Omit<
+                IClientCompanyNotificationOverride,
+                "id" | "clientId" | "companyId" | "createdAt" | "updatedAt"
+            >
+        >
+    ): Promise<IClientCompanyNotificationOverride> {
+        const doc = await this.overrideList
+            .findOneAndUpdate(
+                { clientId, companyId },
+                { $set: data },
+                { upsert: true, new: true }
+            )
+            .exec();
+        return doc.toObject() as IClientCompanyNotificationOverride;
+    }
+}

server/src/Models/NotificationPolicies/ClientCompanyNotificationOverride.Interface.ts

@@ -0,0 +1,32 @@
+import { NotificationChannel } from "../NotificationJobs/NotificationJobs.Interface";
+
+export interface IClientCompanyNotificationOverride {
+    id?: string;
+    clientId: string;
+    companyId: string;
+    preferredChannels: NotificationChannel[];
+    mutedChannels: NotificationChannel[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface FindClientCompanyOverrideParams {
+    clientId?: string;
+    companyId?: string;
+}
+
+export interface IClientCompanyNotificationOverrideAdapter {
+    findOne(
+        filters: FindClientCompanyOverrideParams
+    ): Promise<IClientCompanyNotificationOverride | null>;
+    upsert(
+        clientId: string,
+        companyId: string,
+        data: Partial<
+            Omit<
+                IClientCompanyNotificationOverride,
+                "id" | "clientId" | "companyId" | "createdAt" | "updatedAt"
+            >
+        >
+    ): Promise<IClientCompanyNotificationOverride>;
+}

server/src/Models/NotificationPolicies/ClientCompanyNotificationOverride.ts

@@ -0,0 +1,71 @@
+import { ClientCompanyNotificationOverrideAdapterMongoose } from "./ClientCompanyNotificationOverride.Adapter.Mongoose";
+import {
+    IClientCompanyNotificationOverride,
+    IClientCompanyNotificationOverrideAdapter,
+} from "./ClientCompanyNotificationOverride.Interface";
+import ClientsList from "../Clients/Clients";
+import { validatePermissionsByCompany, validateSessionUser } from "../../helpers/check";
+
+type FindClientCompanyOverrideParams = {
+    clientId: string;
+    companyId: string;
+    sessionUser: string;
+};
+
+type UpsertClientCompanyOverrideParams = FindClientCompanyOverrideParams & {
+    data: Partial<
+        Omit<
+            IClientCompanyNotificationOverride,
+            "id" | "clientId" | "companyId" | "createdAt" | "updatedAt"
+        >
+    >;
+};
+
+class ClientCompanyNotificationOverrideManager {
+    overrides: IClientCompanyNotificationOverrideAdapter;
+
+    constructor() {
+        this.overrides = new ClientCompanyNotificationOverrideAdapterMongoose();
+    }
+
+    public async findOne(
+        params: FindClientCompanyOverrideParams
+    ): Promise<IClientCompanyNotificationOverride | null> {
+        await this.validateAccess(params);
+
+        return this.overrides.findOne({
+            clientId: params.clientId,
+            companyId: params.companyId,
+        });
+    }
+
+    public async upsert(
+        params: UpsertClientCompanyOverrideParams
+    ): Promise<IClientCompanyNotificationOverride> {
+        await this.validateAccess(params);
+
+        return this.overrides.upsert(params.clientId, params.companyId, params.data);
+    }
+
+    private async validateAccess(params: FindClientCompanyOverrideParams): Promise<void> {
+        await validateSessionUser({ sessionUser: params.sessionUser });
+        await validatePermissionsByCompany({
+            companyId: params.companyId,
+            sessionUser: params.sessionUser,
+        });
+
+        const client = await ClientsList.clients.findOne({ _id: params.clientId });
+
+        if (!client) {
+            throw new Error("El cliente no existe");
+        }
+
+        if (String(client.companyId) !== String(params.companyId)) {
+            throw new Error("El cliente no pertenece a la organización");
+        }
+    }
+}
+
+const ClientCompanyNotificationOverride = new ClientCompanyNotificationOverrideManager();
+
+export default ClientCompanyNotificationOverride;

server/src/Models/NotificationPolicies/ClientNotificationPreferences.Adapter.Mongoose.ts

@@ -0,0 +1,70 @@
+import { Document, Model, Schema, model, models } from "mongoose";
+import {
+    FindClientPreferencesParams,
+    IClientNotificationPreferences,
+    IClientNotificationPreferencesAdapter,
+} from "./ClientNotificationPreferences.Interface";
+
+export interface IClientNotificationPreferencesDocument
+    extends Omit<IClientNotificationPreferences, "id">,
+        Document {}
+
+export class ClientNotificationPreferencesAdapterMongoose
+    implements IClientNotificationPreferencesAdapter
+{
+    schema: Schema;
+    preferencesList: Model<IClientNotificationPreferencesDocument>;
+
+    constructor() {
+        this.schema = new Schema(
+            {
+                userId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    unique: true,
+                    ref: "User",
+                },
+                preferredChannels: {
+                    type: [String],
+                    required: true,
+                    default: ["whatsapp", "email", "system"],
+                    enum: ["whatsapp", "email", "system"],
+                },
+                mutedChannels: {
+                    type: [String],
+                    required: true,
+                    default: [],
+                    enum: ["whatsapp", "email", "system"],
+                },
+            },
+            {
+                timestamps: true,
+            }
+        );
+
+        this.preferencesList = models.ClientNotificationPreferences ||
+            model<IClientNotificationPreferencesDocument>(
+                "ClientNotificationPreferences",
+                this.schema
+            );
+    }
+
+    public async findOne(
+        filters: FindClientPreferencesParams
+    ): Promise<IClientNotificationPreferences | null> {
+        const doc = await this.preferencesList.findOne(filters).exec();
+        return doc ? (doc.toObject() as IClientNotificationPreferences) : null;
+    }
+
+    public async upsert(
+        userId: string,
+        data: Partial<
+            Omit<IClientNotificationPreferences, "id" | "userId" | "createdAt" | "updatedAt">
+        >
+    ): Promise<IClientNotificationPreferences> {
+        const doc = await this.preferencesList
+            .findOneAndUpdate({ userId }, { $set: data }, { upsert: true, new: true })
+            .exec();
+        return doc.toObject() as IClientNotificationPreferences;
+    }
+}

server/src/Models/NotificationPolicies/ClientNotificationPreferences.Interface.ts

@@ -0,0 +1,26 @@
+import { NotificationChannel } from "../NotificationJobs/NotificationJobs.Interface";
+
+export interface IClientNotificationPreferences {
+    id?: string;
+    userId: string;
+    preferredChannels: NotificationChannel[];
+    mutedChannels: NotificationChannel[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface FindClientPreferencesParams {
+    userId?: string;
+}
+
+export interface IClientNotificationPreferencesAdapter {
+    findOne(
+        filters: FindClientPreferencesParams
+    ): Promise<IClientNotificationPreferences | null>;
+    upsert(
+        userId: string,
+        data: Partial<
+            Omit<IClientNotificationPreferences, "id" | "userId" | "createdAt" | "updatedAt">
+        >
+    ): Promise<IClientNotificationPreferences>;
+}

server/src/Models/NotificationPolicies/ClientNotificationPreferences.ts

@@ -0,0 +1,51 @@
+import { ClientNotificationPreferencesAdapterMongoose } from "./ClientNotificationPreferences.Adapter.Mongoose";
+import {
+    IClientNotificationPreferences,
+    IClientNotificationPreferencesAdapter,
+} from "./ClientNotificationPreferences.Interface";
+import { validateSessionUser } from "../../helpers/check";
+
+type FindClientPreferencesParams = {
+    userId: string;
+    sessionUser: string;
+};
+
+type UpsertClientPreferencesParams = FindClientPreferencesParams & {
+    data: Partial<
+        Omit<IClientNotificationPreferences, "id" | "userId" | "createdAt" | "updatedAt">
+    >;
+};
+
+class ClientNotificationPreferencesManager {
+    preferences: IClientNotificationPreferencesAdapter;
+
+    constructor() {
+        this.preferences = new ClientNotificationPreferencesAdapterMongoose();
+    }
+
+    public async findOne(
+        params: FindClientPreferencesParams
+    ): Promise<IClientNotificationPreferences | null> {
+        await this.validateUserOwner(params);
+        return this.preferences.findOne({ userId: params.userId });
+    }
+
+    public async upsert(
+        params: UpsertClientPreferencesParams
+    ): Promise<IClientNotificationPreferences> {
+        await this.validateUserOwner(params);
+        return this.preferences.upsert(params.userId, params.data);
+    }
+
+    private async validateUserOwner(params: FindClientPreferencesParams): Promise<void> {
+        await validateSessionUser({ sessionUser: params.sessionUser });
+
+        if (String(params.userId) !== String(params.sessionUser)) {
+            throw new Error("No tienes permisos para modificar preferencias de otro usuario");
+        }
+    }
+}
+
+const ClientNotificationPreferences = new ClientNotificationPreferencesManager();
+
+export default ClientNotificationPreferences;

server/src/Models/NotificationPolicies/CompanyNotificationPolicy.Adapter.Mongoose.ts

@@ -0,0 +1,83 @@
+import { Document, Model, Schema, model, models } from "mongoose";
+import {
+    FindCompanyPolicyParams,
+    ICompanyNotificationPolicy,
+    ICompanyNotificationPolicyAdapter,
+} from "./CompanyNotificationPolicy.Interface";
+
+export interface ICompanyNotificationPolicyDocument
+    extends Omit<ICompanyNotificationPolicy, "id">,
+        Document {}
+
+export class CompanyNotificationPolicyAdapterMongoose
+    implements ICompanyNotificationPolicyAdapter
+{
+    schema: Schema;
+    policyList: Model<ICompanyNotificationPolicyDocument>;
+
+    constructor() {
+        this.schema = new Schema(
+            {
+                companyId: {
+                    type: Schema.Types.ObjectId,
+                    required: true,
+                    unique: true,
+                    ref: "Company",
+                },
+                defaultChannels: {
+                    type: [String],
+                    required: true,
+                    default: ["whatsapp", "email", "system"],
+                    enum: ["whatsapp", "email", "system"],
+                },
+                mutedChannels: {
+                    type: [String],
+                    required: false,
+                    default: [],
+                    enum: ["whatsapp", "email", "system"],
+                },
+                timezone: {
+                    type: String,
+                    required: true,
+                    default: "America/Argentina/Buenos_Aires",
+                },
+                quietHours: {
+                    from: { type: String, required: false },
+                    to: { type: String, required: false },
+                },
+                reminderRules: [
+                    {
+                        offset: { type: Number, required: true },
+                        enabled: { type: Boolean, required: true, default: true },
+                    },
+                ],
+            },
+            {
+                timestamps: true,
+            }
+        );
+
+        this.policyList = models.CompanyNotificationPolicy ||
+            model<ICompanyNotificationPolicyDocument>(
+                "CompanyNotificationPolicy",
+                this.schema
+            );
+    }
+
+    public async findOne(
+        filters: FindCompanyPolicyParams
+    ): Promise<ICompanyNotificationPolicy | null> {
+        const doc = await this.policyList.findOne(filters).exec();
+        return doc ? (doc.toObject() as ICompanyNotificationPolicy) : null;
+    }
+
+    public async upsert(
+        companyId: string,
+        data: Partial<Omit<ICompanyNotificationPolicy, "id" | "companyId" | "createdAt" | "updatedAt">>
+    ): Promise<ICompanyNotificationPolicy> {
+        const doc = await this.policyList
+            .findOneAndUpdate({ companyId }, { $set: data }, { upsert: true, new: true })
+            .exec();
+        return doc.toObject() as ICompanyNotificationPolicy;
+    }
+}

server/src/Models/NotificationPolicies/CompanyNotificationPolicy.Interface.ts

@@ -0,0 +1,35 @@
+import { NotificationChannel } from "../NotificationJobs/NotificationJobs.Interface";
+
+export interface QuietHours {
+    from: string; // "HH:mm" format, e.g. "22:00"
+    to: string; // "HH:mm" format, e.g. "07:00"
+}
+
+export interface ReminderRules {
+    offset: number; // minutes before appointment
+    enabled: boolean;
+}
+
+export interface ICompanyNotificationPolicy {
+    id?: string;
+    companyId: string;
+    defaultChannels: NotificationChannel[];
+    mutedChannels?: NotificationChannel[];
+    timezone: string;
+    quietHours?: QuietHours;
+    reminderRules?: ReminderRules[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface FindCompanyPolicyParams {
+    companyId?: string;
+}
+
+export interface ICompanyNotificationPolicyAdapter {
+    findOne(filters: FindCompanyPolicyParams): Promise<ICompanyNotificationPolicy | null>;
+    upsert(
+        companyId: string,
+        data: Partial<Omit<ICompanyNotificationPolicy, "id" | "companyId" | "createdAt" | "updatedAt">>
+    ): Promise<ICompanyNotificationPolicy>;
+}

server/src/Models/NotificationPolicies/CompanyNotificationPolicy.ts

@@ -0,0 +1,51 @@
+import { CompanyNotificationPolicyAdapterMongoose } from "./CompanyNotificationPolicy.Adapter.Mongoose";
+import {
+    ICompanyNotificationPolicy,
+    ICompanyNotificationPolicyAdapter,
+} from "./CompanyNotificationPolicy.Interface";
+import { validatePermissionsByCompany, validateSessionUser } from "../../helpers/check";
+
+type FindCompanyPolicyParams = {
+    companyId: string;
+    sessionUser: string;
+};
+
+type UpsertCompanyPolicyParams = FindCompanyPolicyParams & {
+    data: Partial<
+        Omit<ICompanyNotificationPolicy, "id" | "companyId" | "createdAt" | "updatedAt">
+    >;
+};
+
+class CompanyNotificationPolicyManager {
+    policies: ICompanyNotificationPolicyAdapter;
+
+    constructor() {
+        this.policies = new CompanyNotificationPolicyAdapterMongoose();
+    }
+
+    public async findOne(
+        params: FindCompanyPolicyParams
+    ): Promise<ICompanyNotificationPolicy | null> {
+        await validateSessionUser({ sessionUser: params.sessionUser });
+        await validatePermissionsByCompany({
+            companyId: params.companyId,
+            sessionUser: params.sessionUser,
+        });
+
+        return this.policies.findOne({ companyId: params.companyId });
+    }
+
+    public async upsert(params: UpsertCompanyPolicyParams): Promise<ICompanyNotificationPolicy> {
+        await validateSessionUser({ sessionUser: params.sessionUser });
+        await validatePermissionsByCompany({
+            companyId: params.companyId,
+            sessionUser: params.sessionUser,
+        });
+
+        return this.policies.upsert(params.companyId, params.data);
+    }
+}
+
+const CompanyNotificationPolicy = new CompanyNotificationPolicyManager();
+
+export default CompanyNotificationPolicy;

server/src/Models/NotificationPolicies/NotificationJobService.ts

@@ -0,0 +1,280 @@
+import {
+    CreateJobParams,
+    NotificationChannel,
+} from "../NotificationJobs/NotificationJobs.Interface";
+import { NotificationJobsAdapterMongoose } from "../NotificationJobs/NotificationJobs.Adapter.Mongoose";
+import { PolicyResolver, ResolvedPolicy } from "./PolicyResolver";
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc";
+
+dayjs.extend(utc);
+
+export interface CreateJobServiceParams {
+    companyId: string;
+    clientId: string;
+    appointmentId: string;
+    type: CreateJobParams["type"];
+    scheduledAt?: Date;
+    appointmentStart?: Date;
+    payload?: CreateJobParams["payload"];
+    reminderPayload?: CreateJobParams["payload"];
+}
+
+export class NotificationJobService {
+    private jobAdapter: NotificationJobsAdapterMongoose;
+    private policyResolver: PolicyResolver;
+
+    constructor() {
+        this.jobAdapter = new NotificationJobsAdapterMongoose();
+        this.policyResolver = new PolicyResolver();
+    }
+
+    async createJob(params: CreateJobServiceParams): Promise<any[]> {
+        const resolvedPolicy = await this.policyResolver.resolve(
+            params.companyId,
+            params.clientId
+        );
+
+        if (resolvedPolicy.channels.length === 0) {
+            return [];
+        }
+
+        const now = new Date();
+        const baseScheduledAt = params.scheduledAt || now;
+        const adjustedScheduledAt = this.adjustForQuietHours(
+            baseScheduledAt,
+            resolvedPolicy
+        );
+
+        const jobs: any[] = [];
+        for (const channel of resolvedPolicy.channels) {
+            const job = await this.jobAdapter.create({
+                companyId: params.companyId,
+                appointmentId: params.appointmentId,
+                clientId: params.clientId,
+                channel,
+                type: params.type,
+                scheduledAt: adjustedScheduledAt,
+                payload: params.payload,
+            });
+            jobs.push(job);
+        }
+
+        if (params.appointmentStart) {
+            const enabledReminderRules = (resolvedPolicy.reminderRules || []).filter(
+                (rule) => rule.enabled
+            );
+
+            for (const rule of enabledReminderRules) {
+                const reminderScheduledAt = this.adjustForQuietHours(
+                    dayjs(params.appointmentStart).subtract(rule.offset, "minute").toDate(),
+                    resolvedPolicy
+                );
+
+                if (reminderScheduledAt < now || reminderScheduledAt >= params.appointmentStart) {
+                    continue;
+                }
+
+                for (const channel of resolvedPolicy.channels) {
+                    const job = await this.jobAdapter.create({
+                        companyId: params.companyId,
+                        appointmentId: params.appointmentId,
+                        clientId: params.clientId,
+                        channel,
+                        type: "reminder",
+                        scheduledAt: reminderScheduledAt,
+                        payload: params.reminderPayload,
+                    });
+                    jobs.push(job);
+                }
+            }
+        }
+
+        return jobs;
+    }
+
+    async createImmediateJob(params: CreateJobServiceParams): Promise<any[]> {
+        const resolvedPolicy = await this.policyResolver.resolve(
+            params.companyId,
+            params.clientId
+        );
+
+        if (resolvedPolicy.channels.length === 0) {
+            return [];
+        }
+
+        const scheduledAt = params.scheduledAt || new Date();
+        const jobs: any[] = [];
+
+        for (const channel of resolvedPolicy.channels) {
+            const job = await this.jobAdapter.create({
+                companyId: params.companyId,
+                appointmentId: params.appointmentId,
+                clientId: params.clientId,
+                channel,
+                type: params.type,
+                scheduledAt,
+                payload: params.payload,
+            });
+            jobs.push(job);
+        }
+
+        return jobs;
+    }
+
+    async createMandatoryCreationJob(params: CreateJobServiceParams): Promise<any[]> {
+        const payloadChannels = this.getPayloadChannels(params.payload);
+        const channels = await this.policyResolver.resolveAvailableChannels(
+            params.companyId,
+            payloadChannels
+        );
+
+        if (channels.length === 0) {
+            return [];
+        }
+
+        const scheduledAt = params.scheduledAt || new Date();
+        const jobs: any[] = [];
+
+        for (const channel of channels) {
+            const job = await this.jobAdapter.create({
+                companyId: params.companyId,
+                appointmentId: params.appointmentId,
+                clientId: params.clientId,
+                channel,
+                type: "creation",
+                scheduledAt,
+                payload: params.payload,
+            });
+            jobs.push(job);
+        }
+
+        return jobs;
+    }
+
+    async createReminderJobs(params: CreateJobServiceParams): Promise<any[]> {
+        const resolvedPolicy = await this.policyResolver.resolve(
+            params.companyId,
+            params.clientId
+        );
+
+        if (!params.appointmentStart || resolvedPolicy.channels.length === 0) {
+            return [];
+        }
+
+        const now = new Date();
+        const jobs: any[] = [];
+        const enabledReminderRules = (resolvedPolicy.reminderRules || []).filter(
+            (rule) => rule.enabled
+        );
+
+        for (const rule of enabledReminderRules) {
+            const reminderScheduledAt = this.adjustForQuietHours(
+                dayjs(params.appointmentStart).subtract(rule.offset, "minute").toDate(),
+                resolvedPolicy
+            );
+
+            if (reminderScheduledAt < now || reminderScheduledAt >= params.appointmentStart) {
+                continue;
+            }
+
+            for (const channel of resolvedPolicy.channels) {
+                const job = await this.jobAdapter.create({
+                    companyId: params.companyId,
+                    appointmentId: params.appointmentId,
+                    clientId: params.clientId,
+                    channel,
+                    type: "reminder",
+                    scheduledAt: reminderScheduledAt,
+                    payload: params.reminderPayload,
+                });
+                jobs.push(job);
+            }
+        }
+
+        return jobs;
+    }
+
+    /**
+     * Cancel all pending jobs for an appointment.
+     * Called when an appointment is deleted or rescheduled.
+     */
+    async cancelByAppointment(appointmentId: string): Promise<void> {
+        return this.jobAdapter.cancelByAppointment(appointmentId);
+    }
+
+    private adjustForQuietHours(scheduledAt: Date, policy: ResolvedPolicy): Date {
+        if (!policy.quietHours?.from || !policy.quietHours?.to) {
+            return scheduledAt;
+        }
+
+        const scheduled = dayjs.utc(scheduledAt);
+        const fromHour = parseInt(policy.quietHours.from.split(":")[0], 10);
+        const fromMinute = parseInt(policy.quietHours.from.split(":")[1], 10);
+        const toHour = parseInt(policy.quietHours.to.split(":")[0], 10);
+        const toMinute = parseInt(policy.quietHours.to.split(":")[1], 10);
+
+        const scheduledHour = scheduled.hour();
+        const scheduledMinute = scheduled.minute();
+
+        const isInsideQuietHours = this.isTimeInQuietHours(
+            scheduledHour,
+            scheduledMinute,
+            fromHour,
+            fromMinute,
+            toHour,
+            toMinute
+        );
+
+        if (isInsideQuietHours) {
+            // Shift to quiet hours end
+            let adjusted = scheduled.hour(toHour).minute(toMinute).second(0);
+            // If quiet hours cross midnight, only the pre-midnight segment ends next day.
+            if (toHour < fromHour && scheduledHour >= fromHour) {
+                adjusted = adjusted.add(1, "day");
+            }
+            return adjusted.toDate();
+        }
+
+        return scheduledAt;
+    }
+
+    private getPayloadChannels(payload?: CreateJobParams["payload"]): NotificationChannel[] {
+        const channels: NotificationChannel[] = [];
+
+        if (payload?.email) {
+            channels.push("email");
+        }
+
+        if (payload?.phoneNumber) {
+            channels.push("whatsapp");
+        }
+
+        if (payload?.userId) {
+            channels.push("system");
+        }
+
+        return channels;
+    }
+
+    private isTimeInQuietHours(
+        hour: number,
+        minute: number,
+        fromHour: number,
+        fromMinute: number,
+        toHour: number,
+        toMinute: number
+    ): boolean {
+        const currentMinutes = hour * 60 + minute;
+        const fromMinutes = fromHour * 60 + fromMinute;
+        const toMinutes = toHour * 60 + toMinute;
+
+        if (fromMinutes < toMinutes) {
+            // Quiet hours within same day (e.g. 01:00-06:00)
+            return currentMinutes >= fromMinutes && currentMinutes < toMinutes;
+        } else {
+            // Quiet hours cross midnight (e.g. 22:00-07:00)
+            return currentMinutes >= fromMinutes || currentMinutes < toMinutes;
+        }
+    }
+}

server/src/Models/NotificationPolicies/PolicyResolver.ts

@@ -0,0 +1,173 @@
+import { NotificationChannel } from "../NotificationJobs/NotificationJobs.Interface";
+import { CompanyNotificationPolicyAdapterMongoose } from "./CompanyNotificationPolicy.Adapter.Mongoose";
+import { ClientNotificationPreferencesAdapterMongoose } from "./ClientNotificationPreferences.Adapter.Mongoose";
+import { ClientCompanyNotificationOverrideAdapterMongoose } from "./ClientCompanyNotificationOverride.Adapter.Mongoose";
+import { IClientNotificationPreferences } from "./ClientNotificationPreferences.Interface";
+import { IClientCompanyNotificationOverride } from "./ClientCompanyNotificationOverride.Interface";
+import { ICompanyNotificationPolicy } from "./CompanyNotificationPolicy.Interface";
+import PlanSubscriptionsList from "../PlanSubscriptions/PlanSubscriptons";
+import { PlanFeatures } from "../Plans/Plans.interface";
+import ClientsList from "../Clients/Clients";
+
+const DEFAULT_TIMEZONE = "America/Argentina/Buenos_Aires";
+const SYSTEM_DEFAULT_CHANNELS: NotificationChannel[] = ["whatsapp", "email", "system"];
+
+const PLAN_CHANNEL_MAP: Record<string, PlanFeatures> = {
+    whatsapp: PlanFeatures.WAP_NOTIFICATIONS,
+    email: PlanFeatures.MAIL_NOTIFICATIONS,
+};
+
+export interface ResolvedPolicy {
+    channels: NotificationChannel[];
+    timezone: string;
+    quietHours?: { from: string; to: string };
+    reminderRules?: { offset: number; enabled: boolean }[];
+}
+
+export class PolicyResolver {
+    private companyPolicyAdapter: CompanyNotificationPolicyAdapterMongoose;
+    private clientPreferencesAdapter: ClientNotificationPreferencesAdapterMongoose;
+    private clientCompanyOverrideAdapter: ClientCompanyNotificationOverrideAdapterMongoose;
+
+    constructor() {
+        this.companyPolicyAdapter = new CompanyNotificationPolicyAdapterMongoose();
+        this.clientPreferencesAdapter = new ClientNotificationPreferencesAdapterMongoose();
+        this.clientCompanyOverrideAdapter = new ClientCompanyNotificationOverrideAdapterMongoose();
+    }
+
+    async resolve(companyId: string, clientId: string): Promise<ResolvedPolicy> {
+        // Level 2: ClientCompanyNotificationOverride (per-client per-org)
+        const override = await this.clientCompanyOverrideAdapter.findOne({
+            clientId,
+            companyId,
+        });
+
+        const client = await ClientsList.clients.findOne({ _id: clientId });
+
+        // Level 3: ClientNotificationPreferences (user global)
+        const clientPrefs = client?.userId
+            ? await this.clientPreferencesAdapter.findOne({ userId: String(client.userId) })
+            : null;
+
+        // Level 4: CompanyNotificationPolicy (org defaults)
+        const companyPolicy = await this.companyPolicyAdapter.findOne({ companyId });
+
+        // Determine channels from cascade
+        let channels: NotificationChannel[];
+        let timezone: string;
+        let quietHours: ResolvedPolicy["quietHours"];
+        let reminderRules: ResolvedPolicy["reminderRules"];
+
+        if (override) {
+            channels = [...override.preferredChannels];
+        } else if (clientPrefs) {
+            channels = [...clientPrefs.preferredChannels];
+        } else if (companyPolicy) {
+            channels = [...companyPolicy.defaultChannels];
+        } else {
+            // Level 5: System defaults
+            channels = [...SYSTEM_DEFAULT_CHANNELS];
+        }
+
+        // Apply muted channels from the winning level only — do NOT merge across levels
+        const mutedChannels = this.getMutedChannels(override, clientPrefs, companyPolicy);
+        channels = channels.filter((ch) => !mutedChannels.includes(ch));
+
+        // Timezone and quiet hours from company policy
+        if (companyPolicy) {
+            timezone = companyPolicy.timezone;
+            quietHours = companyPolicy.quietHours;
+            reminderRules = companyPolicy.reminderRules;
+        } else {
+            timezone = DEFAULT_TIMEZONE;
+        }
+
+        // Level 1: Plan limits — filter channels by plan features
+        channels = await this.applyPlanLimits(companyId, channels);
+
+        return {
+            channels,
+            timezone,
+            quietHours,
+            reminderRules,
+        };
+    }
+
+    async resolveAvailableChannels(
+        companyId: string,
+        channels: NotificationChannel[]
+    ): Promise<NotificationChannel[]> {
+        const companyPolicy = await this.companyPolicyAdapter.findOne({ companyId });
+        const enabledChannels = companyPolicy
+            ? companyPolicy.defaultChannels
+            : SYSTEM_DEFAULT_CHANNELS;
+        const companyEnabledChannels = channels.filter((channel) =>
+            enabledChannels.includes(channel)
+        );
+
+        return this.applyPlanLimits(companyId, companyEnabledChannels);
+    }
+
+    /**
+     * Returns muted channels from the winning cascade level only.
+     * Per spec, muted channels are NOT merged across levels.
+     * The level that determines preferredChannels also determines mutedChannels.
+     */
+    private getMutedChannels(
+        override: IClientCompanyNotificationOverride | null,
+        clientPrefs: IClientNotificationPreferences | null,
+        companyPolicy: ICompanyNotificationPolicy | null
+    ): NotificationChannel[] {
+        if (override) {
+            // Override wins — use only override's muted channels
+            return override.mutedChannels || [];
+        }
+        if (clientPrefs) {
+            // Client prefs wins — use only clientPrefs' muted channels
+            return clientPrefs.mutedChannels || [];
+        }
+        if (companyPolicy) {
+            // Company policy wins — use only companyPolicy' muted channels
+            return companyPolicy.mutedChannels || [];
+        }
+        // System defaults — no muted channels
+        return [];
+    }
+
+    private async applyPlanLimits(
+        companyId: string,
+        channels: NotificationChannel[]
+    ): Promise<NotificationChannel[]> {
+        // Resolve the company owner's userId for plan feature checks
+        // Use lazy require to avoid circular dependency (PolicyResolver → CompaniesManager → Appointments → NotificationJobService → PolicyResolver)
+        const CompaniesManager = require("../Companies/Companies").default;
+        const company = await CompaniesManager.companies.findOne({ _id: companyId });
+        if (!company) {
+            // Company not found — return channels unchanged (fail-open)
+            return channels;
+        }
+
+        const ownerUserId = String(company.ownerId);
+        const filtered: NotificationChannel[] = [];
+
+        for (const channel of channels) {
+            const planFeature = PLAN_CHANNEL_MAP[channel];
+            if (!planFeature) {
+                // Channel has no plan restriction (e.g., system)
+                filtered.push(channel);
+                continue;
+            }
+
+            const canSend = await PlanSubscriptionsList.checkFeature({
+                userId: ownerUserId,
+                feature: planFeature,
+            });
+
+            if (canSend) {
+                filtered.push(channel);
+            }
+        }
+
+        return filtered;
+    }
+}

server/src/Models/NotificationPolicies/__tests__/NotificationJobService.test.ts

@@ -0,0 +1,511 @@
+import { NotificationJobStatus } from "../../NotificationJobs/NotificationJobs.Interface";
+
+// Mock all external dependencies
+jest.mock("../../NotificationJobs/NotificationJobs.Adapter.Mongoose", () => ({
+    NotificationJobsAdapterMongoose: jest.fn().mockImplementation(() => ({
+        create: jest.fn(),
+    })),
+}));
+
+jest.mock("../PolicyResolver", () => ({
+    PolicyResolver: jest.fn().mockImplementation(() => ({
+        resolve: jest.fn(),
+        resolveAvailableChannels: jest.fn(),
+    })),
+}));
+
+jest.mock("../../PlanSubscriptions/PlanSubscriptons", () => ({
+    __esModule: true,
+    default: {
+        checkFeature: jest.fn(),
+    },
+}));
+
+import { NotificationJobService } from "../NotificationJobService";
+import { ResolvedPolicy } from "../PolicyResolver";
+
+describe("NotificationJobService.createJob", () => {
+    let service: NotificationJobService;
+    let mockJobCreate: jest.Mock;
+    let mockResolverResolve: jest.Mock;
+    let mockResolveAvailableChannels: jest.Mock;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useRealTimers();
+
+        service = new NotificationJobService();
+
+        mockJobCreate = (service as any).jobAdapter.create as jest.Mock;
+        mockResolverResolve = (service as any).policyResolver.resolve as jest.Mock;
+        mockResolveAvailableChannels = (service as any).policyResolver.resolveAvailableChannels as jest.Mock;
+    });
+
+    it("creates a job with resolved channels", async () => {
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["whatsapp", "email"],
+            timezone: "America/Argentina/Buenos_Aires",
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({
+            id: "job-1",
+            status: NotificationJobStatus.PENDING,
+        });
+
+        const result = await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+        });
+
+        expect(mockResolverResolve).toHaveBeenCalledWith("company-1", "client-1");
+        expect(mockJobCreate).toHaveBeenCalledTimes(2); // one per channel
+        expect(result).toHaveLength(2);
+    });
+
+    it("creates reminder jobs for each enabled rule and resolved channel in addition to immediate jobs", async () => {
+        jest.useFakeTimers().setSystemTime(new Date("2026-07-21T14:00:00.000Z"));
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system", "email"],
+            timezone: "America/Argentina/Buenos_Aires",
+            reminderRules: [
+                { offset: 2, enabled: true },
+                { offset: 5, enabled: true },
+            ],
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({
+            id: "job-1",
+            status: NotificationJobStatus.PENDING,
+        });
+
+        const result = await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            appointmentStart: new Date("2026-07-21T14:30:00.000Z"),
+        });
+
+        const createCalls = mockJobCreate.mock.calls.map((call) => call[0]);
+        const immediateJobs = createCalls.filter((job) => job.type === "creation");
+        const reminderJobs = createCalls.filter((job) => job.type === "reminder");
+
+        expect(mockJobCreate).toHaveBeenCalledTimes(6);
+        expect(result).toHaveLength(6);
+        expect(immediateJobs).toHaveLength(2);
+        expect(reminderJobs).toHaveLength(4);
+        expect(immediateJobs.map((job) => job.channel).sort()).toEqual(["email", "system"]);
+        expect(immediateJobs.map((job) => job.scheduledAt.toISOString())).toEqual([
+            "2026-07-21T14:00:00.000Z",
+            "2026-07-21T14:00:00.000Z",
+        ]);
+        expect(reminderJobs.map((job) => job.channel).sort()).toEqual([
+            "email",
+            "email",
+            "system",
+            "system",
+        ]);
+        expect(reminderJobs.map((job) => job.scheduledAt.toISOString()).sort()).toEqual([
+            "2026-07-21T14:25:00.000Z",
+            "2026-07-21T14:25:00.000Z",
+            "2026-07-21T14:28:00.000Z",
+            "2026-07-21T14:28:00.000Z",
+        ]);
+    });
+
+    it("passes reminder snapshot payload to scheduled reminder jobs", async () => {
+        jest.useFakeTimers().setSystemTime(new Date("2026-07-21T14:00:00.000Z"));
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["whatsapp", "email"],
+            timezone: "America/Argentina/Buenos_Aires",
+            reminderRules: [{ offset: 30, enabled: true }],
+        };
+        const payload = { message: "Creation body" };
+        const reminderPayload = {
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            companyOwnerId: "owner-1",
+            emailMessage: "Reminder email body",
+            wapMessage: "Reminder WAP body",
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            appointmentStart: new Date("2026-07-21T15:00:00.000Z"),
+            payload,
+            reminderPayload,
+        });
+
+        const createCalls = mockJobCreate.mock.calls.map((call) => call[0]);
+        expect(createCalls.filter((job) => job.type === "creation")).toEqual([
+            expect.objectContaining({ channel: "whatsapp", payload }),
+            expect.objectContaining({ channel: "email", payload }),
+        ]);
+        expect(createCalls.filter((job) => job.type === "reminder")).toEqual([
+            expect.objectContaining({ channel: "whatsapp", payload: reminderPayload }),
+            expect.objectContaining({ channel: "email", payload: reminderPayload }),
+        ]);
+    });
+
+    it("skips reminder jobs scheduled in the past", async () => {
+        jest.useFakeTimers().setSystemTime(new Date("2026-07-21T14:29:00.000Z"));
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system", "email"],
+            timezone: "America/Argentina/Buenos_Aires",
+            reminderRules: [
+                { offset: 2, enabled: true },
+                { offset: 5, enabled: true },
+            ],
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            appointmentStart: new Date("2026-07-21T14:30:00.000Z"),
+        });
+
+        const createCalls = mockJobCreate.mock.calls.map((call) => call[0]);
+        expect(createCalls.filter((job) => job.type === "creation")).toHaveLength(2);
+        expect(createCalls.filter((job) => job.type === "reminder")).toHaveLength(0);
+    });
+
+    it("skips reminder jobs adjusted by quiet hours after appointment start", async () => {
+        jest.useFakeTimers().setSystemTime(new Date("2026-07-21T20:00:00.000Z"));
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system", "email"],
+            timezone: "America/Argentina/Buenos_Aires",
+            quietHours: { from: "22:00", to: "07:00" },
+            reminderRules: [{ offset: 15, enabled: true }],
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            appointmentStart: new Date("2026-07-21T23:30:00.000Z"),
+        });
+
+        const createCalls = mockJobCreate.mock.calls.map((call) => call[0]);
+        expect(createCalls.filter((job) => job.type === "creation")).toHaveLength(2);
+        expect(createCalls.filter((job) => job.type === "reminder")).toHaveLength(0);
+    });
+
+    it("creates no jobs when resolved channels are empty", async () => {
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: [],
+            timezone: "America/Argentina/Buenos_Aires",
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+
+        const result = await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+        });
+
+        expect(mockJobCreate).not.toHaveBeenCalled();
+        expect(result).toHaveLength(0);
+    });
+
+    it("creates mandatory creation jobs from available payload destinations without resolving reminder policy", async () => {
+        jest.useFakeTimers().setSystemTime(new Date("2026-07-21T14:00:00.000Z"));
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+        mockResolveAvailableChannels.mockResolvedValue(["email", "whatsapp"]);
+        const payload = {
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            companyOwnerId: "owner-1",
+            emailMessage: "Alta email",
+            wapMessage: "Alta WAP",
+        };
+
+        const result = await service.createMandatoryCreationJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            payload,
+        });
+
+        const createCalls = mockJobCreate.mock.calls.map((call) => call[0]);
+        expect(mockResolverResolve).not.toHaveBeenCalled();
+        expect(mockResolveAvailableChannels).toHaveBeenCalledWith("company-1", [
+            "email",
+            "whatsapp",
+        ]);
+        expect(result).toHaveLength(2);
+        expect(createCalls).toEqual([
+            expect.objectContaining({
+                channel: "email",
+                type: "creation",
+                scheduledAt: new Date("2026-07-21T14:00:00.000Z"),
+                payload,
+            }),
+            expect.objectContaining({
+                channel: "whatsapp",
+                type: "creation",
+                scheduledAt: new Date("2026-07-21T14:00:00.000Z"),
+                payload,
+            }),
+        ]);
+    });
+
+    it("does not create mandatory creation jobs for channels missing destination data", async () => {
+        mockResolveAvailableChannels.mockResolvedValue([]);
+
+        await service.createMandatoryCreationJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            payload: {
+                companyOwnerId: "owner-1",
+                emailMessage: "Alta email",
+                wapMessage: "Alta WAP",
+            },
+        });
+
+        expect(mockResolverResolve).not.toHaveBeenCalled();
+        expect(mockResolveAvailableChannels).toHaveBeenCalledWith("company-1", []);
+        expect(mockJobCreate).not.toHaveBeenCalled();
+    });
+
+    it("does not create mandatory creation jobs for unavailable channels", async () => {
+        mockResolveAvailableChannels.mockResolvedValue(["email"]);
+        const payload = {
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            companyOwnerId: "owner-1",
+        };
+
+        const result = await service.createMandatoryCreationJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            payload,
+        });
+
+        const createCalls = mockJobCreate.mock.calls.map((call) => call[0]);
+        expect(result).toHaveLength(1);
+        expect(createCalls).toEqual([
+            expect.objectContaining({ channel: "email", type: "creation", payload }),
+        ]);
+    });
+
+    it("keeps reminder jobs policy-aware when resolved channels are empty", async () => {
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: [],
+            timezone: "America/Argentina/Buenos_Aires",
+            reminderRules: [{ offset: 30, enabled: true }],
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+
+        const result = await service.createReminderJobs({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "reminder",
+            appointmentStart: new Date("2026-07-21T15:00:00.000Z"),
+            reminderPayload: { email: "client@example.com" },
+        });
+
+        expect(mockResolverResolve).toHaveBeenCalledWith("company-1", "client-1");
+        expect(mockJobCreate).not.toHaveBeenCalled();
+        expect(result).toHaveLength(0);
+    });
+
+    it("adjusts scheduledAt for quiet hours crossing midnight", async () => {
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system"],
+            timezone: "America/Argentina/Buenos_Aires",
+            quietHours: { from: "22:00", to: "07:00" },
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        // scheduledAt at 23:30 UTC — should be adjusted to 07:00 next day UTC
+        const scheduledAt = new Date("2026-07-21T23:30:00.000Z");
+
+        await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            scheduledAt,
+        });
+
+        const createCall = mockJobCreate.mock.calls[0][0];
+        // 23:30 is inside quiet hours (22:00-07:00), adjusted to 07:00 next day
+        expect(createCall.scheduledAt.getUTCHours()).toBe(7);
+        expect(createCall.scheduledAt.getUTCDate()).toBe(22); // next day
+    });
+
+    it("adjusts early morning quiet hours crossing midnight to the same day", async () => {
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system"],
+            timezone: "America/Argentina/Buenos_Aires",
+            quietHours: { from: "22:00", to: "07:00" },
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            scheduledAt: new Date("2026-07-21T05:00:00.000Z"),
+        });
+
+        const createCall = mockJobCreate.mock.calls[0][0];
+        expect(createCall.scheduledAt.toISOString()).toBe("2026-07-21T07:00:00.000Z");
+    });
+
+    it("does not adjust scheduledAt when outside quiet hours", async () => {
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system"],
+            timezone: "America/Argentina/Buenos_Aires",
+            quietHours: { from: "22:00", to: "07:00" },
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        // scheduledAt at 14:00 UTC — outside quiet hours (22:00-07:00)
+        const scheduledAt = new Date("2026-07-21T14:00:00.000Z");
+
+        await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "creation",
+            scheduledAt,
+        });
+
+        const createCall = mockJobCreate.mock.calls[0][0];
+        // 14:00 is outside quiet hours, should remain unchanged
+        expect(createCall.scheduledAt.getUTCHours()).toBe(14);
+        expect(createCall.scheduledAt.getUTCDate()).toBe(21);
+    });
+
+    it("passes appointmentId and type to job creation", async () => {
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system"],
+            timezone: "America/Argentina/Buenos_Aires",
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        const scheduledAt = new Date("2026-07-21T15:00:00.000Z");
+
+        await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-42",
+            type: "reminder",
+            scheduledAt,
+        });
+
+        const createCall = mockJobCreate.mock.calls[0][0];
+        expect(createCall.appointmentId).toBe("appt-42");
+        expect(createCall.type).toBe("reminder");
+        expect(createCall.companyId).toBe("company-1");
+        expect(createCall.clientId).toBe("client-1");
+    });
+
+    it("creates immediate jobs without reminder offsets", async () => {
+        jest.useFakeTimers().setSystemTime(new Date("2026-07-21T14:00:00.000Z"));
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system", "email"],
+            timezone: "America/Argentina/Buenos_Aires",
+            reminderRules: [{ offset: 30, enabled: true }],
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        const result = await service.createImmediateJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "reminder",
+            appointmentStart: new Date("2026-07-21T16:00:00.000Z"),
+        });
+
+        const createCalls = mockJobCreate.mock.calls.map((call) => call[0]);
+        expect(result).toHaveLength(2);
+        expect(mockJobCreate).toHaveBeenCalledTimes(2);
+        expect(createCalls).toEqual([
+            expect.objectContaining({
+                channel: "system",
+                type: "reminder",
+                scheduledAt: new Date("2026-07-21T14:00:00.000Z"),
+            }),
+            expect.objectContaining({
+                channel: "email",
+                type: "reminder",
+                scheduledAt: new Date("2026-07-21T14:00:00.000Z"),
+            }),
+        ]);
+    });
+
+    it("creates immediate cancellation jobs with snapshot payload for each resolved channel", async () => {
+        jest.useFakeTimers().setSystemTime(new Date("2026-07-21T14:00:00.000Z"));
+        const resolvedPolicy: ResolvedPolicy = {
+            channels: ["system", "email"],
+            timezone: "America/Argentina/Buenos_Aires",
+        };
+        const payload = {
+            email: "client@example.com",
+            phoneNumber: "5491112345678",
+            userId: "user-1",
+            companyOwnerId: "owner-1",
+            subject: "Turno cancelado en Barber Shop",
+            message: "Tu turno fue cancelado.",
+        };
+        mockResolverResolve.mockResolvedValue(resolvedPolicy);
+        mockJobCreate.mockResolvedValue({ id: "job-1" });
+
+        const result = await service.createJob({
+            companyId: "company-1",
+            clientId: "client-1",
+            appointmentId: "appt-1",
+            type: "cancellation",
+            scheduledAt: new Date(),
+            payload,
+        });
+
+        const createCalls = mockJobCreate.mock.calls.map((call) => call[0]);
+        expect(result).toHaveLength(2);
+        expect(createCalls).toEqual([
+            expect.objectContaining({
+                appointmentId: "appt-1",
+                channel: "system",
+                type: "cancellation",
+                scheduledAt: new Date("2026-07-21T14:00:00.000Z"),
+                payload,
+            }),
+            expect.objectContaining({
+                appointmentId: "appt-1",
+                channel: "email",
+                type: "cancellation",
+                scheduledAt: new Date("2026-07-21T14:00:00.000Z"),
+                payload,
+            }),
+        ]);
+    });
+});

server/src/Models/NotificationPolicies/__tests__/PolicyResolver.test.ts

@@ -0,0 +1,351 @@
+import { NotificationChannel } from "../../NotificationJobs/NotificationJobs.Interface";
+
+// Mock all external dependencies before importing the module under test
+jest.mock("../../PlanSubscriptions/PlanSubscriptons", () => ({
+    __esModule: true,
+    default: {
+        checkFeature: jest.fn(),
+    },
+}));
+
+jest.mock("../CompanyNotificationPolicy.Adapter.Mongoose", () => ({
+    CompanyNotificationPolicyAdapterMongoose: jest.fn().mockImplementation(() => ({
+        findOne: jest.fn(),
+    })),
+}));
+
+jest.mock("../ClientNotificationPreferences.Adapter.Mongoose", () => ({
+    ClientNotificationPreferencesAdapterMongoose: jest.fn().mockImplementation(() => ({
+        findOne: jest.fn(),
+    })),
+}));
+
+jest.mock("../ClientCompanyNotificationOverride.Adapter.Mongoose", () => ({
+    ClientCompanyNotificationOverrideAdapterMongoose: jest.fn().mockImplementation(() => ({
+        findOne: jest.fn(),
+    })),
+}));
+
+jest.mock("../../Companies/Companies", () => ({
+    __esModule: true,
+    default: {
+        companies: {
+            findOne: jest.fn(),
+        },
+    },
+}));
+
+jest.mock("../../Clients/Clients", () => ({
+    __esModule: true,
+    default: {
+        clients: {
+            findOne: jest.fn(),
+        },
+    },
+}));
+
+import { PolicyResolver } from "../PolicyResolver";
+import PlanSubscriptionsList from "../../PlanSubscriptions/PlanSubscriptons";
+import CompaniesManager from "../../Companies/Companies";
+import ClientsList from "../../Clients/Clients";
+import { PlanFeatures } from "../../Plans/Plans.interface";
+
+describe("PolicyResolver", () => {
+    let resolver: PolicyResolver;
+    let mockCompanyPolicyFindOne: jest.Mock;
+    let mockClientPreferencesFindOne: jest.Mock;
+    let mockOverrideFindOne: jest.Mock;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        resolver = new PolicyResolver();
+
+        // Access the mocked adapter instances
+        mockCompanyPolicyFindOne = (
+            resolver as any
+        ).companyPolicyAdapter.findOne as jest.Mock;
+        mockClientPreferencesFindOne = (
+            resolver as any
+        ).clientPreferencesAdapter.findOne as jest.Mock;
+        mockOverrideFindOne = (
+            resolver as any
+        ).clientCompanyOverrideAdapter.findOne as jest.Mock;
+
+        // Mock CompaniesManager to return a company with an ownerId
+        (CompaniesManager.companies.findOne as jest.Mock).mockResolvedValue({
+            _id: "company-1",
+            ownerId: "owner-user-1",
+        });
+        (ClientsList.clients.findOne as jest.Mock).mockResolvedValue({
+            _id: "client-1",
+            userId: "client-user-1",
+        });
+    });
+
+    it("returns system defaults when no policies exist", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue(null);
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).toEqual(
+            expect.arrayContaining(["whatsapp", "email", "system"])
+        );
+        expect(result.channels).toHaveLength(3);
+    });
+
+    it("uses company policy defaults when no client override exists", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue({
+            companyId: "company-1",
+            defaultChannels: ["email" as NotificationChannel],
+            timezone: "America/Argentina/Buenos_Aires",
+        });
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).toEqual(["email"]);
+    });
+
+    it("client override wins over company default", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue({
+            companyId: "company-1",
+            defaultChannels: ["email" as NotificationChannel],
+            timezone: "America/Argentina/Buenos_Aires",
+        });
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue({
+            clientId: "client-1",
+            companyId: "company-1",
+            preferredChannels: ["whatsapp" as NotificationChannel],
+            mutedChannels: [],
+        });
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).toEqual(["whatsapp"]);
+    });
+
+    it("client global preferences used when no override exists", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue({
+            companyId: "company-1",
+            defaultChannels: ["whatsapp" as NotificationChannel, "email" as NotificationChannel],
+            timezone: "America/Argentina/Buenos_Aires",
+        });
+        mockClientPreferencesFindOne.mockResolvedValue({
+            userId: "client-user-1",
+            preferredChannels: ["email" as NotificationChannel],
+            mutedChannels: [],
+        });
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).toEqual(["email"]);
+    });
+
+    it("excludes muted channels from override", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue(null);
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue({
+            clientId: "client-1",
+            companyId: "company-1",
+            preferredChannels: [
+                "whatsapp" as NotificationChannel,
+                "email" as NotificationChannel,
+            ],
+            mutedChannels: ["whatsapp" as NotificationChannel],
+        });
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).toEqual(["email"]);
+        expect(result.channels).not.toContain("whatsapp");
+    });
+
+    it("excludes muted channels from client preferences", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue(null);
+        mockClientPreferencesFindOne.mockResolvedValue({
+            userId: "client-user-1",
+            preferredChannels: [
+                "whatsapp" as NotificationChannel,
+                "email" as NotificationChannel,
+                "system" as NotificationChannel,
+            ],
+            mutedChannels: ["email" as NotificationChannel],
+        });
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).toEqual(
+            expect.arrayContaining(["whatsapp", "system"])
+        );
+        expect(result.channels).not.toContain("email");
+    });
+
+    it("loads global preferences by the appointment client's userId", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue(null);
+        mockClientPreferencesFindOne.mockResolvedValue({
+            userId: "client-user-1",
+            preferredChannels: ["system" as NotificationChannel],
+            mutedChannels: [],
+        });
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(ClientsList.clients.findOne).toHaveBeenCalledWith({ _id: "client-1" });
+        expect(mockClientPreferencesFindOne).toHaveBeenCalledWith({ userId: "client-user-1" });
+        expect(result.channels).toEqual(["system"]);
+    });
+
+    it("plan blocks WhatsApp when feature not available", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue({
+            companyId: "company-1",
+            defaultChannels: [
+                "whatsapp" as NotificationChannel,
+                "email" as NotificationChannel,
+            ],
+            timezone: "America/Argentina/Buenos_Aires",
+        });
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockImplementation(
+            async (params: { feature: string }) => {
+                if (params.feature === PlanFeatures.WAP_NOTIFICATIONS) return false;
+                return true;
+            }
+        );
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).not.toContain("whatsapp");
+        expect(result.channels).toContain("email");
+    });
+
+    it("plan blocks email when feature not available", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue({
+            companyId: "company-1",
+            defaultChannels: [
+                "whatsapp" as NotificationChannel,
+                "email" as NotificationChannel,
+            ],
+            timezone: "America/Argentina/Buenos_Aires",
+        });
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockImplementation(
+            async (params: { feature: string }) => {
+                if (params.feature === PlanFeatures.MAIL_NOTIFICATIONS) return false;
+                return true;
+            }
+        );
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).not.toContain("email");
+        expect(result.channels).toContain("whatsapp");
+    });
+
+    it("returns timezone from company policy", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue({
+            companyId: "company-1",
+            defaultChannels: ["system" as NotificationChannel],
+            timezone: "America/New_York",
+            quietHours: { from: "22:00", to: "07:00" },
+        });
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.timezone).toBe("America/New_York");
+        expect(result.quietHours).toEqual({ from: "22:00", to: "07:00" });
+    });
+
+    it("returns default timezone when no company policy", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue(null);
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue(null);
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.timezone).toBe("America/Argentina/Buenos_Aires");
+    });
+
+    it("returns empty channels when all are muted via override", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue(null);
+        mockClientPreferencesFindOne.mockResolvedValue(null);
+        mockOverrideFindOne.mockResolvedValue({
+            clientId: "client-1",
+            companyId: "company-1",
+            preferredChannels: [
+                "whatsapp" as NotificationChannel,
+                "email" as NotificationChannel,
+                "system" as NotificationChannel,
+            ],
+            mutedChannels: [
+                "whatsapp" as NotificationChannel,
+                "email" as NotificationChannel,
+                "system" as NotificationChannel,
+            ],
+        });
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolve("company-1", "client-1");
+
+        expect(result.channels).toEqual([]);
+    });
+
+    it("resolves available channels from company defaults and plan limits without client preferences", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue({
+            companyId: "company-1",
+            defaultChannels: ["whatsapp" as NotificationChannel, "email" as NotificationChannel],
+            mutedChannels: ["email" as NotificationChannel],
+            timezone: "America/Argentina/Buenos_Aires",
+        });
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockResolvedValue(true);
+
+        const result = await resolver.resolveAvailableChannels("company-1", [
+            "whatsapp",
+            "email",
+            "system",
+        ]);
+
+        expect(result).toEqual(["whatsapp", "email"]);
+        expect(mockClientPreferencesFindOne).not.toHaveBeenCalled();
+        expect(mockOverrideFindOne).not.toHaveBeenCalled();
+    });
+
+    it("removes available channels disallowed by the owner plan", async () => {
+        mockCompanyPolicyFindOne.mockResolvedValue({
+            companyId: "company-1",
+            defaultChannels: ["whatsapp" as NotificationChannel, "email" as NotificationChannel],
+            timezone: "America/Argentina/Buenos_Aires",
+        });
+        (PlanSubscriptionsList.checkFeature as jest.Mock).mockImplementation(
+            async (params: { feature: string }) =>
+                params.feature !== PlanFeatures.WAP_NOTIFICATIONS
+        );
+
+        const result = await resolver.resolveAvailableChannels("company-1", [
+            "whatsapp",
+            "email",
+        ]);
+
+        expect(result).toEqual(["email"]);
+    });
+});

server/src/Models/Notifications/Notifications.Adapter.donweb.ts

@@ -3,13 +3,37 @@ import { INotificationsAdapter, NotificationDataEmail } from "./Notifications.In
 
 export class NotificationsDonWebAdapter implements INotificationsAdapter<NotificationDataEmail> {
     async send(data: NotificationDataEmail): Promise<void> {
-        const dataEmail = {
+        if (data.context && data.substitutions) {
+            throw new Error("No se puede enviar un email con context y substitutions al mismo tiempo.");
+        }
+
+        if (!data.templateId && !data.message) {
+            throw new Error("Debe indicarse el contenido del email mediante message o templateId.");
+        }
+
+        const dataEmail: Record<string, unknown> = {
             from: "norepply@turnosxpress.com.ar",
             to: data.email,
-            subject: data.subject,
-            html: data.message,
         };
 
+        if (data.templateId) {
+            dataEmail.templateID = data.templateId;
+        } else {
+            dataEmail.html = data.message;
+        }
+
+        if (data.subject) {
+            dataEmail.subject = data.subject;
+        }
+
+        if (data.context) {
+            dataEmail.context = data.context;
+        }
+
+        if (data.substitutions) {
+            dataEmail.substitutions = data.substitutions;
+        }
+
         const apiConfig = {
             method: "post",
             maxBodyLength: Infinity,

server/src/Models/Notifications/Notifications.Interface.ts

@@ -6,8 +6,11 @@ export enum NOTIFICATION_TYPES {
 
 export type NotificationDataEmail = {
     email: string;
-    subject: string;
+    subject?: string;
-    message: string;
+    message?: string;
+    templateId?: string;
+    context?: Record<string, unknown>;
+    substitutions?: Record<string, string | number | boolean>;
 };
 
 export type NotificationDataWap = {

server/src/Models/OrganizationFiscalProfiles/OrganizationFiscalProfiles.Adapter.Mongoose.ts

@@ -0,0 +1,102 @@
+import { Document, FilterQuery, Model, Schema, model } from "mongoose";
+import {
+    CreateOrganizationFiscalProfileParams,
+    FindOrganizationFiscalProfilesParams,
+    IOrganizationFiscalProfile,
+    IOrganizationFiscalProfilesAdapter,
+    ORGANIZATION_FISCAL_PROFILE_STATUS,
+    ORGANIZATION_FISCAL_PROFILE_TAX_CONDITION,
+    UpdateOrganizationFiscalProfileParams,
+} from "./OrganizationFiscalProfiles.Interface";
+
+export interface IOrganizationFiscalProfileDocument
+    extends Omit<IOrganizationFiscalProfile, "id">,
+        Document {}
+
+export class OrganizationFiscalProfilesAdapterMongoose implements IOrganizationFiscalProfilesAdapter {
+    schema: Schema;
+    organizationFiscalProfileList: Model<IOrganizationFiscalProfileDocument>;
+
+    constructor() {
+        this.schema = new Schema({
+            companyId: {
+                type: Schema.Types.ObjectId,
+                required: true,
+                ref: "Company",
+                unique: true,
+                index: true,
+            },
+            cuit: { type: String, required: true },
+            legalName: { type: String, required: true },
+            taxCondition: {
+                type: String,
+                required: true,
+                enum: Object.values(ORGANIZATION_FISCAL_PROFILE_TAX_CONDITION),
+            },
+            pointOfSale: { type: Number, required: true },
+            activityCode: { type: String, required: false },
+            activityDescription: { type: String, required: false },
+            status: {
+                type: String,
+                required: true,
+                enum: Object.values(ORGANIZATION_FISCAL_PROFILE_STATUS),
+                index: true,
+            },
+            createdAt: { type: Date, required: true, default: Date.now },
+            updatedAt: { type: Date, required: true, default: Date.now },
+        });
+
+        this.organizationFiscalProfileList = model<IOrganizationFiscalProfileDocument>(
+            "OrganizationFiscalProfile",
+            this.schema
+        );
+    }
+
+    public async create(
+        data: CreateOrganizationFiscalProfileParams
+    ): Promise<IOrganizationFiscalProfile> {
+        return await this.organizationFiscalProfileList.create(data);
+    }
+
+    private buildSearchCriteria(
+        filters: FindOrganizationFiscalProfilesParams
+    ): FilterQuery<IOrganizationFiscalProfile> {
+        const searchCriteria: FilterQuery<IOrganizationFiscalProfile> = {};
+
+        if (filters.id) searchCriteria._id = filters.id;
+        if (filters.companyId) searchCriteria.companyId = filters.companyId;
+        if (filters.status) searchCriteria.status = filters.status;
+
+        return searchCriteria;
+    }
+
+    public async find(
+        filters: FindOrganizationFiscalProfilesParams
+    ): Promise<IOrganizationFiscalProfile[]> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+        return this.organizationFiscalProfileList.find(searchCriteria).sort({ createdAt: -1 }).exec();
+    }
+
+    public async findOne(
+        filters: FindOrganizationFiscalProfilesParams
+    ): Promise<IOrganizationFiscalProfileDocument | null> {
+        const searchCriteria = this.buildSearchCriteria(filters);
+        return this.organizationFiscalProfileList.findOne(searchCriteria).exec();
+    }
+
+    public async update(
+        data: UpdateOrganizationFiscalProfileParams
+    ): Promise<IOrganizationFiscalProfileDocument | null> {
+        const { id, companyId, sessionUser, ...updateData } = data;
+
+        if (!id && !companyId) {
+            throw new Error("Se requiere un identificador para actualizar el perfil fiscal");
+        }
+
+        return this.organizationFiscalProfileList
+            .findOneAndUpdate(this.buildSearchCriteria({ id, companyId, sessionUser }), updateData, {
+                new: true,
+            })
+            .exec();
+    }
+}

server/src/Models/OrganizationFiscalProfiles/OrganizationFiscalProfiles.Interface.ts

@@ -0,0 +1,83 @@
+import { IOrganizationFiscalProfileDocument } from "./OrganizationFiscalProfiles.Adapter.Mongoose";
+
+export enum ORGANIZATION_FISCAL_PROFILE_TAX_CONDITION {
+    MONOTRIBUTO = "MONOTRIBUTO",
+    EXENTO = "EXENTO",
+}
+
+export enum ORGANIZATION_FISCAL_PROFILE_STATUS {
+    PENDING = "PENDING",
+    ACTIVE = "ACTIVE",
+    DISABLED = "DISABLED",
+}
+
+export type UpsertOrganizationFiscalProfileParams = {
+    companyId: string;
+    cuit: string;
+    legalName: string;
+    taxCondition: ORGANIZATION_FISCAL_PROFILE_TAX_CONDITION;
+    pointOfSale: number;
+    activityCode?: string;
+    activityDescription?: string;
+    sessionUser: string;
+};
+
+export type FindOrganizationFiscalProfilesParams = {
+    id?: string;
+    companyId?: string;
+    status?: ORGANIZATION_FISCAL_PROFILE_STATUS;
+    sessionUser?: string;
+};
+
+export type CreateOrganizationFiscalProfileParams = {
+    companyId: string;
+    cuit: string;
+    legalName: string;
+    taxCondition: ORGANIZATION_FISCAL_PROFILE_TAX_CONDITION;
+    pointOfSale: number;
+    activityCode?: string;
+    activityDescription?: string;
+    status: ORGANIZATION_FISCAL_PROFILE_STATUS;
+    createdAt: Date;
+    updatedAt: Date;
+};
+
+export type UpdateOrganizationFiscalProfileParams = FindOrganizationFiscalProfilesParams & {
+    cuit?: string;
+    legalName?: string;
+    taxCondition?: ORGANIZATION_FISCAL_PROFILE_TAX_CONDITION;
+    pointOfSale?: number;
+    activityCode?: string;
+    activityDescription?: string;
+    status?: ORGANIZATION_FISCAL_PROFILE_STATUS;
+    updatedAt: Date;
+};
+
+export interface IOrganizationFiscalProfile {
+    id?: string;
+    companyId: string;
+    cuit: string;
+    legalName: string;
+    taxCondition: ORGANIZATION_FISCAL_PROFILE_TAX_CONDITION;
+    pointOfSale: number;
+    activityCode?: string;
+    activityDescription?: string;
+    status: ORGANIZATION_FISCAL_PROFILE_STATUS;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface IOrganizationFiscalProfilesAdapter {
+    create(data: CreateOrganizationFiscalProfileParams): Promise<IOrganizationFiscalProfile>;
+    find(filters: FindOrganizationFiscalProfilesParams): Promise<IOrganizationFiscalProfile[]>;
+    findOne(
+        filters: FindOrganizationFiscalProfilesParams
+    ): Promise<IOrganizationFiscalProfileDocument | null>;
+    update(data: UpdateOrganizationFiscalProfileParams): Promise<IOrganizationFiscalProfileDocument | null>;
+}
+
+export interface IOrganizationFiscalProfilesManager {
+    organizationFiscalProfiles: IOrganizationFiscalProfilesAdapter;
+    upsert(data: UpsertOrganizationFiscalProfileParams): Promise<IOrganizationFiscalProfile>;
+    find(data: FindOrganizationFiscalProfilesParams): Promise<IOrganizationFiscalProfile[]>;
+}

server/src/Models/OrganizationFiscalProfiles/OrganizationFiscalProfiles.ts

@@ -0,0 +1,164 @@
+import { validatePermissionsByCompany, validateSessionUser } from "../../helpers/check";
+import { findArcaActivityByCode } from "../ArcaActivities/ArcaActivities.Catalog";
+import { OrganizationFiscalProfilesAdapterMongoose } from "./OrganizationFiscalProfiles.Adapter.Mongoose";
+import {
+    FindOrganizationFiscalProfilesParams,
+    IOrganizationFiscalProfile,
+    IOrganizationFiscalProfilesManager,
+    ORGANIZATION_FISCAL_PROFILE_STATUS,
+    UpsertOrganizationFiscalProfileParams,
+} from "./OrganizationFiscalProfiles.Interface";
+
+class OrganizationFiscalProfilesManager implements IOrganizationFiscalProfilesManager {
+    organizationFiscalProfiles: OrganizationFiscalProfilesAdapterMongoose;
+
+    constructor() {
+        this.organizationFiscalProfiles = new OrganizationFiscalProfilesAdapterMongoose();
+    }
+
+    private isDuplicateKeyError(error: unknown): boolean {
+        return typeof error === "object" && error !== null && "code" in error && error.code === 11000;
+    }
+
+    private validateProfileFields(data: UpsertOrganizationFiscalProfileParams): void {
+        if (!/^\d{11}$/.test(data.cuit)) {
+            throw new Error("El CUIT debe contener 11 dígitos");
+        }
+
+        if (!data.legalName || !data.legalName.trim()) {
+            throw new Error("La razón social es requerida");
+        }
+
+        if (!data.pointOfSale || data.pointOfSale <= 0) {
+            throw new Error("El punto de venta debe ser mayor a 0");
+        }
+
+        const activityCode = data.activityCode?.trim();
+
+        if (activityCode && !/^\d{6}$/.test(activityCode)) {
+            throw new Error("El código de actividad debe contener 6 dígitos");
+        }
+
+        if (activityCode && !findArcaActivityByCode(activityCode)) {
+            throw new Error("La actividad ARCA/CLAE seleccionada no existe en el catálogo");
+        }
+    }
+
+    private buildProfileData(data: UpsertOrganizationFiscalProfileParams) {
+        const activityCode = data.activityCode?.trim();
+        const activity = activityCode ? findArcaActivityByCode(activityCode) : undefined;
+
+        return {
+            cuit: data.cuit,
+            legalName: data.legalName.trim(),
+            taxCondition: data.taxCondition,
+            pointOfSale: data.pointOfSale,
+            activityCode: activity?.code || "",
+            activityDescription: activity?.description || "",
+            status: ORGANIZATION_FISCAL_PROFILE_STATUS.ACTIVE,
+        };
+    }
+
+    public async upsert(
+        data: UpsertOrganizationFiscalProfileParams
+    ): Promise<IOrganizationFiscalProfile> {
+        await validateSessionUser({ sessionUser: data.sessionUser });
+
+        if (!data.companyId || !data.companyId.trim()) {
+            throw new Error("Se requiere una organización para guardar el perfil fiscal");
+        }
+
+        await validatePermissionsByCompany({ companyId: data.companyId, sessionUser: data.sessionUser });
+
+        this.validateProfileFields(data);
+
+        const existingProfile = await this.organizationFiscalProfiles.findOne({
+            companyId: data.companyId,
+        });
+
+        const now = new Date();
+        const profileData = this.buildProfileData(data);
+
+        if (existingProfile) {
+            const updatedProfile = await this.organizationFiscalProfiles.update({
+                companyId: data.companyId,
+                ...profileData,
+                updatedAt: now,
+            });
+
+            if (!updatedProfile) {
+                throw new Error("No se pudo actualizar el perfil fiscal");
+            }
+
+            return updatedProfile;
+        }
+
+        try {
+            return await this.organizationFiscalProfiles.create({
+                companyId: data.companyId,
+                ...profileData,
+                createdAt: now,
+                updatedAt: now,
+            });
+        } catch (error) {
+            if (this.isDuplicateKeyError(error)) {
+                const updatedProfile = await this.organizationFiscalProfiles.update({
+                    companyId: data.companyId,
+                    ...profileData,
+                    updatedAt: new Date(),
+                });
+
+                if (updatedProfile) {
+                    return updatedProfile;
+                }
+
+                const existingProfile = await this.organizationFiscalProfiles.findOne({
+                    companyId: data.companyId,
+                });
+
+                if (existingProfile) {
+                    return existingProfile;
+                }
+            }
+
+            throw error;
+        }
+    }
+
+    public async find(
+        data: FindOrganizationFiscalProfilesParams
+    ): Promise<IOrganizationFiscalProfile[]> {
+        if (!data.sessionUser) {
+            throw new Error("Se requiere un usuario autenticado");
+        }
+
+        const sessionUser = data.sessionUser;
+        await validateSessionUser({ sessionUser });
+
+        if (data.companyId) {
+            await validatePermissionsByCompany({
+                companyId: data.companyId,
+                sessionUser,
+            });
+        } else if (data.id) {
+            const profile = await this.organizationFiscalProfiles.findOne(data);
+
+            if (!profile) {
+                return [];
+            }
+
+            await validatePermissionsByCompany({
+                companyId: String(profile.companyId),
+                sessionUser,
+            });
+
+            return [profile];
+        } else {
+            throw new Error("Se requiere una organización para buscar perfiles fiscales");
+        }
+
+        return await this.organizationFiscalProfiles.find(data);
+    }
+}
+
+export default new OrganizationFiscalProfilesManager();

server/src/Models/PlanUsageCycle/PlanUsageCycle.Adapter.Mongoose.ts

@@ -112,7 +112,6 @@ export class PlanUsageCycleAdapterMongoose implements IPlanUsageCycleAdapter {
                     planId: data.planId,
                     cycleStart: data.cycleStart,
                     cycleEnd: data.cycleEnd,
-                    appointmentsCount: 0,
                     creationDate: now,
                 },
                 $inc: { appointmentsCount: data.quantity },

server/src/Models/Ratings/Ratings.Adapter.Mongoose.ts

@@ -0,0 +1,191 @@
+import { Document, Model, Schema, Types, model, models } from "mongoose";
+import getAvatar from "../../helpers/getAvatar";
+import { joinStrings } from "../../helpers/String";
+import {
+    FindRatingsParams,
+    IRating,
+    IRatingsAdapter,
+    RATING_COMMENT_MAX_LENGTH,
+    RatingTargetSummaryParams,
+    RatingTargetSummaryResult,
+    RatingTargetReviewsParams,
+    RatingTargetReviewsResult,
+    RatingTargetType,
+} from "./Ratings.Interface";
+
+export interface IRatingDocument extends Omit<IRating, "id">, Document {
+    _id: Types.ObjectId;
+}
+
+type RatingReviewDocument = IRatingDocument & {
+    userId?: {
+        _id: Types.ObjectId;
+        firstName?: string;
+        lastName?: string;
+        avatar?: string;
+    };
+};
+
+const GENERIC_REVIEW_AUTHOR = "Cliente verificado";
+
+export class RatingsAdapterMongoose implements IRatingsAdapter {
+    schema: Schema;
+    ratingsList: Model<IRatingDocument>;
+
+    constructor() {
+        this.schema = new Schema(
+            {
+                appointmentId: { type: Schema.Types.ObjectId, required: true, ref: "Appointment" },
+                userId: { type: Schema.Types.ObjectId, required: true, ref: "User" },
+                companyId: { type: Schema.Types.ObjectId, required: true, ref: "Companie" },
+                serviceId: { type: Schema.Types.ObjectId, required: true, ref: "Service" },
+                employeeId: { type: Schema.Types.ObjectId, required: true, ref: "Employee" },
+                targetType: { type: String, required: true, enum: Object.values(RatingTargetType) },
+                targetId: { type: Schema.Types.ObjectId, required: true },
+                score: { type: Number, required: true, min: 1, max: 5 },
+                comment: { type: String, required: false, default: "", maxlength: RATING_COMMENT_MAX_LENGTH },
+            },
+            { timestamps: true }
+        );
+
+        this.schema.index({ userId: 1, targetType: 1, targetId: 1 }, { unique: true });
+        this.ratingsList = (models.Rating as Model<IRatingDocument>) || model<IRatingDocument>("Rating", this.schema);
+    }
+
+    public async create(data: Omit<IRating, "id" | "createdAt" | "updatedAt">): Promise<IRating> {
+        const rating = await this.ratingsList.create(data);
+        return this.mapRating(rating);
+    }
+
+    public async find(filters: FindRatingsParams): Promise<IRating[]> {
+        const ratings = await this.ratingsList.find(filters).exec();
+        return ratings.map((rating) => this.mapRating(rating));
+    }
+
+    public async findOne(filters: FindRatingsParams): Promise<IRating | null> {
+        const rating = await this.ratingsList.findOne(filters).exec();
+        return rating ? this.mapRating(rating) : null;
+    }
+
+    public async count(filters: FindRatingsParams): Promise<number> {
+        return this.ratingsList.countDocuments(filters).exec();
+    }
+
+    public async summaryByTarget(filters: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult> {
+        const [summary] = await this.ratingsList
+            .aggregate<{ averageScore: number; totalCount: number }>([
+                {
+                    $match: {
+                        targetType: filters.targetType,
+                        targetId: new Types.ObjectId(filters.targetId),
+                    },
+                },
+                {
+                    $group: {
+                        _id: null,
+                        averageScore: { $avg: "$score" },
+                        totalCount: { $sum: 1 },
+                    },
+                },
+            ])
+            .exec();
+
+        return {
+            averageScore: summary?.averageScore || 0,
+            totalCount: summary?.totalCount || 0,
+        };
+    }
+
+    public async summaryByTargets(filters: { targetType: RatingTargetType; targetIds: string[] }): Promise<RatingTargetSummaryResult> {
+        const targetIds = filters.targetIds.filter((targetId) => Types.ObjectId.isValid(targetId));
+
+        if (targetIds.length === 0) {
+            return { averageScore: 0, totalCount: 0 };
+        }
+
+        const [summary] = await this.ratingsList
+            .aggregate<{ averageScore: number; totalCount: number }>([
+                {
+                    $match: {
+                        targetType: filters.targetType,
+                        targetId: { $in: targetIds.map((targetId) => new Types.ObjectId(targetId)) },
+                    },
+                },
+                {
+                    $group: {
+                        _id: null,
+                        averageScore: { $avg: "$score" },
+                        totalCount: { $sum: 1 },
+                    },
+                },
+            ])
+            .exec();
+
+        return {
+            averageScore: summary?.averageScore || 0,
+            totalCount: summary?.totalCount || 0,
+        };
+    }
+
+    public async reviewsByTarget(filters: RatingTargetReviewsParams): Promise<RatingTargetReviewsResult> {
+        const page = filters.page || 1;
+        const pageSize = filters.pageSize || filters.limit || 20;
+        const targetReviewsFilter = {
+            targetType: filters.targetType,
+            targetId: new Types.ObjectId(filters.targetId),
+            comment: { $regex: /\S/ },
+        };
+
+        const total = await this.ratingsList.countDocuments(targetReviewsFilter).exec();
+        const ratings = await this.ratingsList
+            .find(targetReviewsFilter)
+            .sort({ score: -1, createdAt: -1 })
+            .skip((page - 1) * pageSize)
+            .limit(pageSize)
+            .select("score comment createdAt userId")
+            .populate("userId", "firstName lastName avatar")
+            .exec();
+
+        const reviews = (ratings as unknown as RatingReviewDocument[]).map((rating) => {
+            const user = rating.userId;
+            const displayName = user ? joinStrings([user.firstName, user.lastName], " ") : "";
+            const authorName = displayName || GENERIC_REVIEW_AUTHOR;
+
+            return {
+                id: rating._id.toString(),
+                score: rating.score,
+                comment: rating.comment || "",
+                createdAt: rating.createdAt,
+                author: {
+                    displayName: authorName,
+                    avatarUrl: user ? getAvatar(user._id.toString(), user.avatar, "") : "",
+                },
+            };
+        });
+
+        return {
+            reviews,
+            total,
+            page,
+            pageSize,
+            totalPages: Math.ceil(total / pageSize),
+        };
+    }
+
+    private mapRating(rating: IRatingDocument): IRating {
+        return {
+            id: rating._id.toString(),
+            appointmentId: rating.appointmentId.toString(),
+            userId: rating.userId.toString(),
+            companyId: rating.companyId.toString(),
+            serviceId: rating.serviceId.toString(),
+            employeeId: rating.employeeId.toString(),
+            targetType: rating.targetType,
+            targetId: rating.targetId.toString(),
+            score: rating.score,
+            comment: rating.comment,
+            createdAt: rating.createdAt,
+            updatedAt: rating.updatedAt,
+        };
+    }
+}

server/src/Models/Ratings/Ratings.Interface.ts

@@ -0,0 +1,125 @@
+export enum RatingTargetType {
+    COMPANY = "company",
+    SERVICE = "service",
+    EMPLOYEE = "employee",
+}
+
+export const RATING_COMMENT_MAX_LENGTH = 1000;
+
+export type FindRatingsParams = {
+    _id?: string;
+    appointmentId?: string;
+    userId?: string;
+    companyId?: string;
+    serviceId?: string;
+    employeeId?: string;
+    targetType?: RatingTargetType;
+    targetId?: string | { $in: string[] };
+};
+
+export type CreateRatingParams = {
+    appointmentId: string;
+    targetType: RatingTargetType;
+    targetId: string;
+    score: number;
+    comment?: string;
+    sessionUser: string;
+};
+
+export type PendingRatingsByUserParams = {
+    sessionUser: string;
+};
+
+export type CountRatingsByUserParams = {
+    sessionUser: string;
+};
+
+export type CountRatingsByUserResult = {
+    count: number;
+};
+
+export type ProfessionalRatingSummaryByUserParams = {
+    sessionUser: string;
+};
+
+export type RatingTargetSummaryParams = {
+    targetType: RatingTargetType;
+    targetId: string;
+};
+
+export type RatingTargetSummaryResult = {
+    averageScore: number;
+    totalCount: number;
+};
+
+export type RatingTargetReviewsParams = RatingTargetSummaryParams & {
+    page?: number;
+    pageSize?: number;
+    limit?: number;
+};
+
+export type RatingTargetReviewItem = {
+    id: string;
+    score: number;
+    comment: string;
+    createdAt: Date;
+    author: {
+        displayName: string;
+        avatarUrl: string;
+    };
+};
+
+export type RatingTargetReviewsResult = {
+    reviews: RatingTargetReviewItem[];
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+};
+
+export interface IRating {
+    id?: string;
+    appointmentId: string;
+    userId: string;
+    companyId: string;
+    serviceId: string;
+    employeeId: string;
+    targetType: RatingTargetType;
+    targetId: string;
+    score: number;
+    comment?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface PendingRatingItem {
+    appointmentId: string;
+    appointmentDate: string;
+    targetType: RatingTargetType;
+    targetId: string;
+    targetName: string;
+    companyId: string;
+    serviceId: string;
+    employeeId: string;
+    serviceName: string;
+}
+
+export interface IRatingsAdapter {
+    create(data: Omit<IRating, "id" | "createdAt" | "updatedAt">): Promise<IRating>;
+    find(filters: FindRatingsParams): Promise<IRating[]>;
+    findOne(filters: FindRatingsParams): Promise<IRating | null>;
+    count(filters: FindRatingsParams): Promise<number>;
+    summaryByTarget(filters: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult>;
+    summaryByTargets(filters: { targetType: RatingTargetType; targetIds: string[] }): Promise<RatingTargetSummaryResult>;
+    reviewsByTarget(filters: RatingTargetReviewsParams): Promise<RatingTargetReviewsResult>;
+}
+
+export interface IRatingsManager {
+    ratings: IRatingsAdapter;
+    createRating(data: CreateRatingParams): Promise<IRating>;
+    pendingByUser(data: PendingRatingsByUserParams): Promise<PendingRatingItem[]>;
+    countByUser(data: CountRatingsByUserParams): Promise<CountRatingsByUserResult>;
+    professionalSummaryByUser(data: ProfessionalRatingSummaryByUserParams): Promise<RatingTargetSummaryResult>;
+    summaryByTarget(data: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult>;
+    reviewsByTarget(data: RatingTargetReviewsParams): Promise<RatingTargetReviewsResult>;
+}

server/src/Models/Ratings/Ratings.ts

@@ -0,0 +1,296 @@
+import dayjs from "dayjs";
+import { Types } from "mongoose";
+import { isNull } from "../../helpers/IsNull";
+import { joinStrings } from "../../helpers/String";
+import AppointmentList from "../Appointments/Appointments";
+import CompaniesManager from "../Companies/Companies";
+import EmployeesList from "../Employees/Employee";
+import ServicesManager from "../Services/Service";
+import UsersManager from "../Users/Users";
+import { RatingsAdapterMongoose } from "./Ratings.Adapter.Mongoose";
+import {
+    CountRatingsByUserParams,
+    CountRatingsByUserResult,
+    CreateRatingParams,
+    IRating,
+    IRatingsManager,
+    PendingRatingItem,
+    PendingRatingsByUserParams,
+    ProfessionalRatingSummaryByUserParams,
+    RATING_COMMENT_MAX_LENGTH,
+    RatingTargetSummaryParams,
+    RatingTargetSummaryResult,
+    RatingTargetReviewsParams,
+    RatingTargetReviewsResult,
+    RatingTargetType,
+} from "./Ratings.Interface";
+
+const PENDING_RATINGS_APPOINTMENT_LIMIT = 50;
+const TARGET_REVIEWS_LIMIT = 20;
+
+class RatingsManager implements IRatingsManager {
+    ratings: RatingsAdapterMongoose;
+
+    constructor() {
+        this.ratings = new RatingsAdapterMongoose();
+    }
+
+    public async createRating(data: CreateRatingParams): Promise<IRating> {
+        await this.validateSessionUser(data.sessionUser);
+        this.validateScore(data.score);
+        this.validateTargetType(data.targetType);
+        const comment = isNull<string>(data.comment, "").trim();
+        this.validateComment(comment);
+
+        const appointment = await AppointmentList.Appointments.AppointmentList.findOne({
+            _id: data.appointmentId,
+            userId: data.sessionUser,
+        });
+
+        if (!appointment) {
+            throw new Error("No se encontró un turno válido para calificar.");
+        }
+
+        if (!appointment.present || !dayjs(appointment.dateDay).isBefore(dayjs().startOf("day"))) {
+            throw new Error("Solo puedes calificar turnos pasados a los que asististe.");
+        }
+
+        const expectedTargetId = this.getTargetId({
+            targetType: data.targetType,
+            companyId: String(appointment.companyId),
+            serviceId: String(appointment.serviceId),
+            employeeId: String(appointment.employeeId),
+        });
+
+        if (String(data.targetId) !== expectedTargetId) {
+            throw new Error("La calificación no corresponde al turno seleccionado.");
+        }
+
+        const existingRating = await this.ratings.findOne({
+            userId: data.sessionUser,
+            targetType: data.targetType,
+            targetId: data.targetId,
+        });
+
+        if (existingRating) {
+            throw new Error("Ya calificaste este item.");
+        }
+
+        try {
+            return await this.ratings.create({
+                appointmentId: data.appointmentId,
+                userId: data.sessionUser,
+                companyId: String(appointment.companyId),
+                serviceId: String(appointment.serviceId),
+                employeeId: String(appointment.employeeId),
+                targetType: data.targetType,
+                targetId: data.targetId,
+                score: data.score,
+                comment,
+            });
+        } catch (error) {
+            if (this.isDuplicateRatingError(error)) {
+                throw new Error("Ya calificaste este item.");
+            }
+
+            throw error;
+        }
+    }
+
+    public async pendingByUser(data: PendingRatingsByUserParams): Promise<PendingRatingItem[]> {
+        await this.validateSessionUser(data.sessionUser);
+
+        const appointments = await AppointmentList.Appointments.AppointmentList.find({
+            userId: data.sessionUser,
+            present: true,
+            dateDay: { $lt: dayjs().startOf("day").toDate() },
+        })
+            .sort({ start: -1 })
+            .limit(PENDING_RATINGS_APPOINTMENT_LIMIT);
+
+        const pendingItems: PendingRatingItem[] = [];
+        const seenTargets = new Set<string>();
+        const candidateTargetIds = Array.from(
+            new Set(
+                appointments.flatMap((appointment) => [
+                    String(appointment.companyId),
+                    String(appointment.serviceId),
+                    String(appointment.employeeId),
+                ])
+            )
+        );
+        const candidateTargetObjectIds = this.toObjectIds(candidateTargetIds);
+        const existingRatings = await this.ratings.find({
+            userId: data.sessionUser,
+            targetId: { $in: candidateTargetIds },
+        });
+        const ratedTargets = new Set(
+            existingRatings.map((rating) => `${rating.targetType}:${String(rating.targetId)}`)
+        );
+        const companies = await CompaniesManager.companies.find({ _id: { $in: candidateTargetObjectIds } } as any);
+        const services = await ServicesManager.services.find({ _id: { $in: candidateTargetObjectIds } } as any);
+        const employees = await EmployeesList.employees.find({ _id: { $in: candidateTargetObjectIds } } as any);
+        const employeeUserIds = Array.from(new Set(employees.map((employee) => String(employee.userId))));
+        const employeeUsers = await UsersManager.users.find({ _id: { $in: this.toObjectIds(employeeUserIds) } } as any);
+
+        const companiesById = new Map(companies.map((company) => [String(company.id), company]));
+        const servicesById = new Map(services.map((service) => [String(service.id), service]));
+        const employeesById = new Map(employees.map((employee) => [String(employee.id), employee]));
+        const employeeUsersById = new Map(employeeUsers.map((user) => [String(user.id), user]));
+
+        for (const appointment of appointments) {
+            const company = companiesById.get(String(appointment.companyId));
+            const service = servicesById.get(String(appointment.serviceId));
+            const employee = employeesById.get(String(appointment.employeeId));
+
+            if (!company || !service || !employee) {
+                continue;
+            }
+
+            const userEmployee = employeeUsersById.get(String(employee.userId));
+            const employeeName = userEmployee
+                ? joinStrings([isNull<string>(userEmployee.firstName, ""), isNull<string>(userEmployee.lastName, "")], " ")
+                : "Profesional";
+
+            const candidates = [
+                { targetType: RatingTargetType.COMPANY, targetId: String(appointment.companyId), targetName: company.name },
+                { targetType: RatingTargetType.SERVICE, targetId: String(appointment.serviceId), targetName: service.name },
+                { targetType: RatingTargetType.EMPLOYEE, targetId: String(appointment.employeeId), targetName: employeeName },
+            ];
+
+            for (const candidate of candidates) {
+                const seenKey = `${candidate.targetType}:${candidate.targetId}`;
+                if (seenTargets.has(seenKey)) {
+                    continue;
+                }
+
+                if (ratedTargets.has(seenKey)) {
+                    seenTargets.add(seenKey);
+                    continue;
+                }
+
+                pendingItems.push({
+                    appointmentId: String(appointment.id),
+                    appointmentDate: dayjs(appointment.start).toISOString(),
+                    targetType: candidate.targetType,
+                    targetId: candidate.targetId,
+                    targetName: candidate.targetName,
+                    companyId: String(appointment.companyId),
+                    serviceId: String(appointment.serviceId),
+                    employeeId: String(appointment.employeeId),
+                    serviceName: service.name,
+                });
+
+                seenTargets.add(seenKey);
+            }
+        }
+
+        return pendingItems;
+    }
+
+    public async countByUser(data: CountRatingsByUserParams): Promise<CountRatingsByUserResult> {
+        await this.validateSessionUser(data.sessionUser);
+
+        return {
+            count: await this.ratings.count({ userId: data.sessionUser }),
+        };
+    }
+
+    public async professionalSummaryByUser(data: ProfessionalRatingSummaryByUserParams): Promise<RatingTargetSummaryResult> {
+        await this.validateSessionUser(data.sessionUser);
+
+        const employees = await EmployeesList.employees.find({
+            userId: data.sessionUser,
+            removed: { $ne: true },
+        } as any);
+        const employeeIds = employees.map((employee) => String(employee.id));
+
+        return this.ratings.summaryByTargets({
+            targetType: RatingTargetType.EMPLOYEE,
+            targetIds: employeeIds,
+        });
+    }
+
+    public async summaryByTarget(data: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult> {
+        this.validateTargetType(data.targetType);
+
+        if (!Types.ObjectId.isValid(data.targetId)) {
+            throw new Error("No se ha proporcionado un objetivo válido.");
+        }
+
+        return this.ratings.summaryByTarget(data);
+    }
+
+    public async reviewsByTarget(data: RatingTargetReviewsParams): Promise<RatingTargetReviewsResult> {
+        this.validateTargetType(data.targetType);
+
+        if (!Types.ObjectId.isValid(data.targetId)) {
+            throw new Error("No se ha proporcionado un objetivo válido.");
+        }
+
+        const pageSize = Math.min(Math.max(data.pageSize || data.limit || TARGET_REVIEWS_LIMIT, 1), TARGET_REVIEWS_LIMIT);
+        const page = Math.max(data.page || 1, 1);
+
+        return this.ratings.reviewsByTarget({
+            ...data,
+            page,
+            pageSize,
+            limit: pageSize,
+        });
+    }
+
+    private async validateSessionUser(sessionUser: string): Promise<void> {
+        const user = await UsersManager.users.findOne({ _id: sessionUser });
+
+        if (!user) {
+            throw new Error("No se ha encontrado el usuario o no tiene permisos para realizar esta acción");
+        }
+    }
+
+    private toObjectIds(ids: string[]): Types.ObjectId[] {
+        return ids.filter((id) => Types.ObjectId.isValid(id)).map((id) => new Types.ObjectId(id));
+    }
+
+    private validateScore(score: number): void {
+        if (!Number.isInteger(score) || score < 1 || score > 5) {
+            throw new Error("La calificación debe estar entre 1 y 5.");
+        }
+    }
+
+    private validateTargetType(targetType: RatingTargetType): void {
+        if (!Object.values(RatingTargetType).includes(targetType)) {
+            throw new Error("El tipo de calificación no es válido.");
+        }
+    }
+
+    private validateComment(comment: string): void {
+        if (comment.length > RATING_COMMENT_MAX_LENGTH) {
+            throw new Error(`El comentario no puede superar los ${RATING_COMMENT_MAX_LENGTH} caracteres.`);
+        }
+    }
+
+    private isDuplicateRatingError(error: unknown): boolean {
+        return Boolean(error && typeof error === "object" && "code" in error && error.code === 11000);
+    }
+
+    private getTargetId(data: {
+        targetType: RatingTargetType;
+        companyId: string;
+        serviceId: string;
+        employeeId: string;
+    }): string {
+        if (data.targetType === RatingTargetType.COMPANY) {
+            return data.companyId;
+        }
+
+        if (data.targetType === RatingTargetType.SERVICE) {
+            return data.serviceId;
+        }
+
+        return data.employeeId;
+    }
+}
+
+const RatingsList = new RatingsManager();
+
+export default RatingsList;

server/src/Models/Repeats/Repeats.ts

@@ -212,6 +212,7 @@ class RepeatsManager implements IRepeatsManager {
         }
 
         await this.repeats.delete(data.repeatId);
+        await MetricsList.addRepeat({ userId: String(companyCheck.ownerId), quantity: -1 });
     }
 
     public async deleteRepeatsByCompany(data: DeleteRepeatsByCompanyParams): Promise<void> {

server/src/Models/Schedules/Schedules.Interface.ts

@@ -8,6 +8,34 @@ export type ScheduleItem = {
     serviceIds?: string[];
 };
 
+export type ScheduleConflictStrategy = "reject" | "overwrite-conflicts";
+
+export type ScheduleConflictDetail = {
+    employeeId: string;
+    employeeName: string;
+    weekDay: number;
+    weekDayLabel: string;
+    attempted: ScheduleItem;
+    existing: ScheduleItem;
+    message: string;
+};
+
+export type ScheduleApplyParams = {
+    companyId: string;
+    employeeIds: string[];
+    weekDays: number[];
+    schedules: ScheduleItem[];
+    sessionUser: string;
+    conflictStrategy: ScheduleConflictStrategy;
+};
+
+export type ScheduleApplyResult = {
+    valid: boolean;
+    applied: boolean;
+    conflicts: ScheduleConflictDetail[];
+    message: string;
+};
+
 export type FindSchedulesParams = {
     _id?: string;
     companyId?: string;
@@ -100,6 +128,7 @@ export interface ISchedulesManager {
     findAllSchedulesByCollaborator(data: FindSchedulesParams): Promise<CollaboratorSchedulesView>;
     delete(data: DeleteScheduleParams): Promise<void>;
     isAvailable(data: AvailableSchedulesParams): Promise<boolean>;
+    applyScheduleChanges(data: ScheduleApplyParams): Promise<ScheduleApplyResult>;
     deleteSchedulesByCompany(data: DeleteScheulesByCompanyParams): Promise<void>;
     deleteSchedulesByEmployee(data: DeleteSchedulesByEmployeeParams): Promise<void>;
 }

server/src/Models/Schedules/Schedules.ts

@@ -13,6 +13,9 @@ import {
     DeleteScheulesByCompanyParams,
     DeleteSchedulesByEmployeeParams,
     ScheduleItem,
+    ScheduleApplyParams,
+    ScheduleApplyResult,
+    ScheduleConflictDetail,
 } from "./Schedules.Interface";
 import { EmployeeRoles } from "../Employees/Employees.Interface";
 import UsersManager from "../Users/Users";
@@ -24,6 +27,9 @@ import { isNull } from "../../helpers/IsNull";
 import getAvatar from "../../helpers/getAvatar";
 import { NotificationsManager } from "../Notifications/Notifications";
 import { NotificationType } from "../../Models/SystemNotifications/SystemNotification.Interface";
+import { validatePermissionsByCompany, validateSessionUser } from "../../helpers/check";
+
+const WEEK_DAY_LABELS = ["Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado"];
 
 class SchedulesManager implements ISchedulesManager {
     schedules: SchedulesAdapterMongoose;
@@ -173,6 +179,169 @@ class SchedulesManager implements ISchedulesManager {
         return await this.schedules.find(filters);
     }
 
+    private parseTimeToMinutes(time: string): number {
+        const [hours, minutes] = time.split(":").map((part) => Number(part));
+
+        if (!Number.isInteger(hours) || !Number.isInteger(minutes)) {
+            throw new Error("El horario indicado no es válido");
+        }
+
+        return hours * 60 + minutes;
+    }
+
+    private hasTimeOverlap(first: ScheduleItem, second: ScheduleItem): boolean {
+        return this.parseTimeToMinutes(first.from) < this.parseTimeToMinutes(second.to)
+            && this.parseTimeToMinutes(second.from) < this.parseTimeToMinutes(first.to);
+    }
+
+    private getServiceScope(schedule: ScheduleItem): "all" | "specific" {
+        return schedule.serviceScope || "all";
+    }
+
+    private hasServiceOverlap(first: ScheduleItem, second: ScheduleItem): boolean {
+        const firstScope = this.getServiceScope(first);
+        const secondScope = this.getServiceScope(second);
+
+        if (firstScope === "all" || secondScope === "all") {
+            return true;
+        }
+
+        const secondServices = new Set(second.serviceIds || []);
+        return (first.serviceIds || []).some((serviceId) => secondServices.has(serviceId));
+    }
+
+    private hasScheduleConflict(first: ScheduleItem, second: ScheduleItem): boolean {
+        if (first.disabled || second.disabled) {
+            return false;
+        }
+
+        return this.hasTimeOverlap(first, second) && this.hasServiceOverlap(first, second);
+    }
+
+    private formatSchedule(schedule: ScheduleItem): string {
+        if (this.getServiceScope(schedule) === "all") {
+            return `${schedule.from} a ${schedule.to} para todos los servicios`;
+        }
+
+        return `${schedule.from} a ${schedule.to} para servicios específicos`;
+    }
+
+    private getEmployeeName(employee: any): string {
+        const snapshotName = [employee.profileSnapshot?.firstName, employee.profileSnapshot?.lastName].filter(Boolean).join(" ").trim();
+        return snapshotName || employee.fullName || employee.name || String(employee._id);
+    }
+
+    private buildConflict(employee: any, weekDay: number, attempted: ScheduleItem, existing: ScheduleItem): ScheduleConflictDetail {
+        const employeeId = String(employee._id);
+        const employeeName = this.getEmployeeName(employee);
+        const weekDayLabel = WEEK_DAY_LABELS[weekDay] || String(weekDay);
+
+        return {
+            employeeId,
+            employeeName,
+            weekDay,
+            weekDayLabel,
+            attempted,
+            existing,
+            message: `${employeeName} ya tiene un horario el ${weekDayLabel} de ${this.formatSchedule(existing)} que se superpone con ${this.formatSchedule(attempted)}.`,
+        };
+    }
+
+    private async findScheduleDocument(companyId: string, employeeId: string, weekDay: number) {
+        return this.schedules.findOne({ companyId, employeeId, weekDay });
+    }
+
+    public async applyScheduleChanges(data: ScheduleApplyParams): Promise<ScheduleApplyResult> {
+        await validateSessionUser({ sessionUser: data.sessionUser });
+        await validatePermissionsByCompany({ companyId: data.companyId, sessionUser: data.sessionUser });
+
+        if (!Array.isArray(data.employeeIds) || data.employeeIds.length === 0) {
+            throw new Error("Tenés que seleccionar al menos un colaborador.");
+        }
+
+        if (!Array.isArray(data.weekDays) || data.weekDays.length === 0 || data.weekDays.some((day) => !Number.isInteger(day) || day < 0 || day > 6)) {
+            throw new Error("Tenés que seleccionar días válidos entre 0 y 6.");
+        }
+
+        if (data.conflictStrategy !== "reject" && data.conflictStrategy !== "overwrite-conflicts") {
+            throw new Error("La estrategia de conflictos no es válida.");
+        }
+
+        const employees = await Promise.all(data.employeeIds.map(async (employeeId) => {
+            const employee = await EmployeesList.employees.findOne({ companyId: data.companyId, _id: employeeId });
+
+            if (!employee) {
+                throw new Error("El empleado no existe o no pertenece a la compañia.");
+            }
+
+            return employee;
+        }));
+
+        const conflicts: ScheduleConflictDetail[] = [];
+
+        for (const employee of employees) {
+            const employeeId = String(employee._id);
+
+            for (const weekDay of data.weekDays) {
+                const scheduleDocument = await this.findScheduleDocument(data.companyId, employeeId, weekDay);
+                const existingSchedules = scheduleDocument?.schedules || [];
+
+                for (const attempted of data.schedules) {
+                    const existing = existingSchedules.find((schedule) => this.hasScheduleConflict(attempted, schedule));
+
+                    if (existing) {
+                        conflicts.push(this.buildConflict(employee, weekDay, attempted, existing));
+                    }
+                }
+            }
+        }
+
+        if (conflicts.length > 0 && data.conflictStrategy === "reject") {
+            return {
+                valid: false,
+                applied: false,
+                conflicts,
+                message: "Encontramos horarios superpuestos. Revisalos antes de guardar o elegí sobrescribir solo esos conflictos.",
+            };
+        }
+
+        for (const employee of employees) {
+            const employeeId = String(employee._id);
+
+            for (const weekDay of data.weekDays) {
+                const scheduleDocument = await this.findScheduleDocument(data.companyId, employeeId, weekDay);
+                const existingSchedules = scheduleDocument?.schedules || [];
+                const nextSchedules = data.conflictStrategy === "overwrite-conflicts"
+                    ? existingSchedules.filter((existing) => !data.schedules.some((attempted) => this.hasScheduleConflict(attempted, existing)))
+                    : existingSchedules;
+
+                const schedules = [...nextSchedules, ...data.schedules];
+
+                if (scheduleDocument) {
+                    scheduleDocument.schedules = schedules;
+                    await scheduleDocument.save();
+                } else {
+                    await this.schedules.create({
+                        companyId: data.companyId,
+                        employeeId,
+                        weekDay,
+                        schedules,
+                        sessionUser: data.sessionUser,
+                    });
+                }
+            }
+        }
+
+        return {
+            valid: conflicts.length === 0,
+            applied: true,
+            conflicts,
+            message: conflicts.length > 0
+                ? "Se sobrescribieron solo los horarios en conflicto."
+                : "Los horarios se guardaron correctamente.",
+        };
+    }
+
     private isScheduleAvailableForService(schedule: ScheduleItem, serviceId?: string): boolean {
         if (!serviceId || !schedule.serviceScope || schedule.serviceScope === "all") {
             return true;

server/src/Models/SchedulesDisabled/SchedulesDisabled.Adapter.Mongoose.ts

@@ -32,6 +32,12 @@ export class SchedulesDisabledAdapterMongoose implements ISchedulesDisabledAdapt
         await this.schedulesDisabledList.deleteOne({ _id: id }).exec();
     }
 
+    public async find(
+        filters: Omit<FindSchedulesDisabledParams, "sessionUser">
+    ): Promise<ISchedulesDisabledDocument[]> {
+        return this.schedulesDisabledList.find(filters).exec();
+    }
+
     public async findOne(
         filters: Omit<FindSchedulesDisabledParams, "sessionUser">
     ): Promise<ISchedulesDisabledDocument | null> {

server/src/Models/SchedulesDisabled/SchedulesDisabled.Interface.ts

@@ -90,6 +90,7 @@ export interface SchedulesDisabledByCollaboratorView {
 export interface ISchedulesDisabledAdapter {
     create(data: CreateSchedulesDisabledParams): Promise<ISchedulesDisabled>;
     delete(id: string): Promise<void>;
+    find(filters: Omit<FindSchedulesDisabledParams, "sessionUser">): Promise<ISchedulesDisabled[]>;
     findOne(filters: FindSchedulesDisabledParams): Promise<ISchedulesDisabled | null>;
 }
 
@@ -98,6 +99,7 @@ export interface ISchedulesDisabledManager {
     createSchedulesDisabled(data: CreateSchedulesDisabledParams): Promise<ISchedulesDisabled>;
     disableSchedule(data: DisableScheduleParams): Promise<void>;
     enableSchedule(data: DisableScheduleParams): Promise<void>;
+    find(data: FindSchedulesDisabledParams): Promise<ISchedulesDisabled[]>;
     findOne(data: FindSchedulesDisabledParams): Promise<ISchedulesDisabled | null>;
     findSchedulesDisabledByCollaborator(
         data: FindSchedulesDisabledParams

server/src/Models/SchedulesDisabled/SchedulesDisabled.ts

@@ -271,6 +271,17 @@ class SchedulesDisabledManager implements ISchedulesDisabledManager {
         return await this.schedulesDisabled.findOne(data);
     }
 
+    public async find(data: FindSchedulesDisabledParams): Promise<ISchedulesDisabled[]> {
+        await validateSessionUser({ sessionUser: data.sessionUser });
+        await validatePermissionsByCompany({
+            sessionUser: data.sessionUser,
+            companyId: data.companyId,
+        });
+
+        const { sessionUser, ...filters } = data;
+        return await this.schedulesDisabled.find(filters);
+    }
+
     public async delete(data: DeleteSchedulesDisabledParams): Promise<void> {
         await validateSessionUser({ sessionUser: data.sessionUser });
 

server/src/Models/SchedulesEnabled/SchedulesEnabled.Interface.ts

@@ -49,6 +49,49 @@ export type EnableScheduleParams = {
     sessionUser: string;
 };
 
+export type ReservationPeriodScope = "employee" | "all";
+
+export type ReservationPeriodDurationUnit = "week" | "month";
+
+export type ReservationPeriodDuration = {
+    unit: ReservationPeriodDurationUnit;
+    value: number;
+};
+
+export type ReservationPeriodsSummaryParams = {
+    companyId: string;
+    sessionUser: string;
+};
+
+export type ExtendReservationPeriodsParams = {
+    companyId: string;
+    scope: ReservationPeriodScope;
+    employeeId?: string;
+    duration?: ReservationPeriodDuration;
+    weeks?: number;
+    sessionUser: string;
+};
+
+export type ReservationPeriodEmployeeSummary = {
+    employeeId: string;
+    employeeFullName: string;
+    employeeEmail: string;
+    employeeAvatar: string;
+    employeeUserId: string;
+    isOpen: boolean;
+    currentOpenUntil: Date | null;
+    daysRemaining: number | null;
+};
+
+export type ReservationPeriodsSummary = {
+    companyId: string;
+    status: "missing" | "expired" | "near-ending" | "open";
+    worstDaysRemaining: number | null;
+    currentOpenUntil: Date | null;
+    nearEndingThresholdDays: number;
+    employees: ReservationPeriodEmployeeSummary[];
+};
+
 export type DeleteSchedulesEnabledByCompanyParams = {
     companyId: string;
 };
@@ -94,4 +137,6 @@ export interface ISchedulesEnabledManager {
     exists(data: CheckSchedulesEnabledParams): Promise<boolean>;
     deleteSchedulesEnabledByCompany(data: DeleteSchedulesEnabledByCompanyParams): Promise<void>;
     deleteSchedulesEnabledByEmployee(data: DeleteSchedulesEnabledByEmployeeParams): Promise<void>;
+    summarizeReservationPeriods(data: ReservationPeriodsSummaryParams): Promise<ReservationPeriodsSummary>;
+    extendReservationPeriods(data: ExtendReservationPeriodsParams): Promise<ReservationPeriodsSummary>;
 }

server/src/Models/SchedulesEnabled/SchedulesEnabled.ts

@@ -9,6 +9,10 @@ import {
     FindSchedulesEnabledParams,
     ISchedulesEnabled,
     ISchedulesEnabledManager,
+    ReservationPeriodEmployeeSummary,
+    ReservationPeriodsSummary,
+    ReservationPeriodsSummaryParams,
+    ExtendReservationPeriodsParams,
     SchedulesEnabledView,
 } from "./SchedulesEnabled.Interface";
 import { EmployeeRoles } from "../Employees/Employees.Interface";
@@ -21,10 +25,26 @@ import { joinStrings } from "../../helpers/String";
 import getAvatar from "../../helpers/getAvatar";
 import { NotificationsManager } from "../Notifications/Notifications";
 import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc";
+import timezone from "dayjs/plugin/timezone";
+import "dayjs/locale/es";
 import { NotificationType } from "../../Models/SystemNotifications/SystemNotification.Interface";
+import { validatePermissionsByCompany, validateSessionUser } from "../../helpers/check";
 
+dayjs.extend(utc);
+dayjs.extend(timezone);
 dayjs.locale("es");
 
+const SCHEDULE_BOUNDARY_TIMEZONE = "America/Argentina/Buenos_Aires";
+const NEAR_ENDING_THRESHOLD_DAYS = 14;
+const ALLOWED_RESERVATION_PERIOD_DURATIONS = [
+    { unit: "week", value: 1 },
+    { unit: "week", value: 2 },
+    { unit: "week", value: 3 },
+    { unit: "month", value: 1 },
+    { unit: "month", value: 2 },
+] as const;
+
 class SchedulesEnabledManager implements ISchedulesEnabledManager {
     schedulesEnabled: SchedulesEnabledAdapterMongoose;
 
@@ -73,8 +93,8 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
         const schedulesEnabledCheck = await this.schedulesEnabled.findOne({
             employeeId: data.employeeId,
             companyId: data.companyId,
-            startDate: dayjs(data.startDate).startOf("day").toDate(),
+            startDate: this.normalizeScheduleStartDate(data.startDate),
-            endDate: dayjs(data.endDate).endOf("day").toDate(),
+            endDate: this.normalizeScheduleEndDate(data.endDate),
         });
 
         if (schedulesEnabledCheck) {
@@ -84,8 +104,8 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
         const newEmplyeesEnabled = await this.schedulesEnabled.create({
             employeeId: data.employeeId,
             companyId: data.companyId,
-            startDate: dayjs(data.startDate).startOf("day").toDate(),
+            startDate: this.normalizeScheduleStartDate(data.startDate),
-            endDate: dayjs(data.endDate).endOf("day").toDate(),
+            endDate: this.normalizeScheduleEndDate(data.endDate),
             sessionUser: data.sessionUser,
         });
 
@@ -125,7 +145,8 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
             const employeeCheck = await EmployeesList.employees.findOne({
                 companyId: data.companyId,
                 _id: employeeId,
-            });
+                removed: { $ne: true },
+            } as any);
 
             if (!employeeCheck) {
                 continue;
@@ -134,8 +155,8 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
             const schedulesEnabledCheck = await this.schedulesEnabled.findOne({
                 employeeId: employeeId,
                 companyId: data.companyId,
-                startDate: dayjs(data.startDate).startOf("day").toDate(),
+                startDate: this.normalizeScheduleStartDate(data.startDate),
-                endDate: dayjs(data.endDate).endOf("day").toDate(),
+                endDate: this.normalizeScheduleEndDate(data.endDate),
             });
 
             if (schedulesEnabledCheck) {
@@ -145,8 +166,8 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
             await this.schedulesEnabled.create({
                 employeeId: employeeId,
                 companyId: data.companyId,
-                startDate: dayjs(data.startDate).startOf("day").toDate(),
+                startDate: this.normalizeScheduleStartDate(data.startDate),
-                endDate: dayjs(data.endDate).endOf("day").toDate(),
+                endDate: this.normalizeScheduleEndDate(data.endDate),
                 sessionUser: data.sessionUser,
             });
 
@@ -185,7 +206,8 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
             const employeeCheck = await EmployeesList.employees.findOne({
                 companyId: data.companyId,
                 _id: employeeId,
-            });
+                removed: { $ne: true },
+            } as any);
 
             if (!employeeCheck) {
                 continue;
@@ -194,8 +216,8 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
             const schedulesEnabledCheck = await this.schedulesEnabled.findOne({
                 employeeId: employeeId,
                 companyId: data.companyId,
-                startDate: dayjs(data.startDate).startOf("day").toDate(),
+                startDate: this.normalizeScheduleStartDate(data.startDate),
-                endDate: dayjs(data.endDate).endOf("day").toDate(),
+                endDate: this.normalizeScheduleEndDate(data.endDate),
             });
 
             if (schedulesEnabledCheck) {
@@ -229,11 +251,16 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
     }
 
     public async find(data: FindSchedulesEnabledParams): Promise<SchedulesEnabledView[]> {
-        let employeeFilter: any = { companyId: data.companyId };
+        const rangeStart = this.normalizeScheduleStartDate(data.startDate);
+        const rangeEnd = this.normalizeScheduleEndDate(data.endDate);
+        let employeeFilter: any = {
+            companyId: data.companyId,
+            removed: { $ne: true },
+        };
         if (data.employeeId) {
             employeeFilter = {
                 ...employeeFilter,
-                employeeId: data.employeeId,
+                _id: data.employeeId,
             };
         }
         const employees = await EmployeesList.employees.find(employeeFilter);
@@ -244,8 +271,8 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
             const schedulesEnabled = await this.schedulesEnabled.schedulesEnabledList.findOne({
                 employeeId: employee.id,
                 companyId: data.companyId,
-                startDate: dayjs(data.startDate).startOf("day").toDate(),
+                startDate: { $lte: rangeStart },
-                endDate: dayjs(data.endDate).endOf("day").toDate(),
+                endDate: { $gte: rangeEnd },
             });
 
             const employUser = await UsersManager.users.findOne({
@@ -297,6 +324,189 @@ class SchedulesEnabledManager implements ISchedulesEnabledManager {
 
         await this.schedulesEnabled.delete(String(data.id));
     }
+
+    public async summarizeReservationPeriods(
+        data: ReservationPeriodsSummaryParams
+    ): Promise<ReservationPeriodsSummary> {
+        await validateSessionUser({ sessionUser: data.sessionUser });
+        await validatePermissionsByCompany({ companyId: data.companyId, sessionUser: data.sessionUser });
+
+        return this.buildReservationPeriodsSummary(data.companyId);
+    }
+
+    public async extendReservationPeriods(
+        data: ExtendReservationPeriodsParams
+    ): Promise<ReservationPeriodsSummary> {
+        await validateSessionUser({ sessionUser: data.sessionUser });
+        await validatePermissionsByCompany({ companyId: data.companyId, sessionUser: data.sessionUser });
+
+        const duration = data.duration || (data.weeks ? { unit: "week" as const, value: Number(data.weeks) } : null);
+
+        if (!duration || !ALLOWED_RESERVATION_PERIOD_DURATIONS.some(option => option.unit === duration.unit && option.value === Number(duration.value))) {
+            throw new Error("El período seleccionado no es válido");
+        }
+
+        const employees = await EmployeesList.employees.find({
+            companyId: data.companyId,
+            removed: { $ne: true },
+        } as any);
+
+        let targetEmployees = employees;
+
+        if (data.scope === "employee") {
+            if (!data.employeeId) {
+                throw new Error("Debe seleccionar un colaborador");
+            }
+
+            targetEmployees = employees.filter(employee => String(employee.id) === String(data.employeeId));
+
+            if (targetEmployees.length === 0) {
+                throw new Error("El colaborador no existe o no pertenece a la organización");
+            }
+        } else if (data.scope !== "all") {
+            throw new Error("El alcance seleccionado no es válido");
+        }
+
+        if (targetEmployees.length === 0) {
+            throw new Error("No hay colaboradores disponibles para extender el período de reservas");
+        }
+
+        const today = dayjs().startOf("day");
+        const summary = await this.buildReservationPeriodsSummary(data.companyId);
+        const operations = targetEmployees.flatMap(employee => {
+            const employeeSummary = summary.employees.find(item => String(item.employeeId) === String(employee.id));
+            const startDate = employeeSummary?.currentOpenUntil && !dayjs(employeeSummary.currentOpenUntil).endOf("day").isBefore(today)
+                ? this.getNextWeekStartAfter(dayjs(employeeSummary.currentOpenUntil))
+                : this.getWeekStart(today);
+            const weekRanges = this.buildReservationPeriodWeekRanges(startDate, duration);
+
+            return weekRanges.map(range => ({
+                updateOne: {
+                    filter: {
+                        employeeId: employee.id,
+                        companyId: data.companyId,
+                        startDate: this.normalizeScheduleStartDate(range.startDate),
+                        endDate: this.normalizeScheduleEndDate(range.endDate),
+                    },
+                    update: {
+                        $setOnInsert: {
+                            employeeId: employee.id,
+                            companyId: data.companyId,
+                            startDate: this.normalizeScheduleStartDate(range.startDate),
+                            endDate: this.normalizeScheduleEndDate(range.endDate),
+                        },
+                    },
+                    upsert: true,
+                },
+            }));
+        });
+
+        await this.schedulesEnabled.schedulesEnabledList.bulkWrite(operations, { ordered: true });
+
+        return this.buildReservationPeriodsSummary(data.companyId);
+    }
+
+    private getWeekStart(date: dayjs.Dayjs): dayjs.Dayjs {
+        return date.startOf("day").subtract((date.day() + 6) % 7, "day");
+    }
+
+    private getNextWeekStartAfter(date: dayjs.Dayjs): dayjs.Dayjs {
+        const nextDay = date.add(1, "day").startOf("day");
+        const weekStart = this.getWeekStart(nextDay);
+
+        return weekStart.isBefore(nextDay) ? weekStart.add(1, "week") : weekStart;
+    }
+
+    private buildReservationPeriodWeekRanges(
+        startWeek: dayjs.Dayjs,
+        duration: { unit: "week" | "month"; value: number }
+    ): { startDate: dayjs.Dayjs; endDate: dayjs.Dayjs }[] {
+        const ranges: { startDate: dayjs.Dayjs; endDate: dayjs.Dayjs }[] = [];
+        const targetEnd = duration.unit === "week"
+            ? startWeek.add(Number(duration.value), "week").subtract(1, "day").endOf("day")
+            : startWeek.add(Number(duration.value), "month").subtract(1, "day").endOf("day");
+        let currentWeekStart = startWeek.startOf("day");
+
+        while (!currentWeekStart.isAfter(targetEnd)) {
+            ranges.push({
+                startDate: currentWeekStart,
+                endDate: currentWeekStart.add(6, "day").endOf("day"),
+            });
+            currentWeekStart = currentWeekStart.add(1, "week");
+        }
+
+        return ranges;
+    }
+
+    private normalizeScheduleStartDate(date: string | Date | dayjs.Dayjs): Date {
+        return dayjs.tz(this.getScheduleDateOnly(date), SCHEDULE_BOUNDARY_TIMEZONE).startOf("day").toDate();
+    }
+
+    private normalizeScheduleEndDate(date: string | Date | dayjs.Dayjs): Date {
+        return dayjs.tz(this.getScheduleDateOnly(date), SCHEDULE_BOUNDARY_TIMEZONE).endOf("day").toDate();
+    }
+
+    private getScheduleDateOnly(date: string | Date | dayjs.Dayjs): string {
+        if (typeof date === "string") {
+            return date.slice(0, 10);
+        }
+
+        if (dayjs.isDayjs(date)) {
+            return date.format("YYYY-MM-DD");
+        }
+
+        return date.toISOString().slice(0, 10);
+    }
+
+    private async buildReservationPeriodsSummary(companyId: string): Promise<ReservationPeriodsSummary> {
+        const today = dayjs().startOf("day");
+        const employees = await EmployeesList.findByCompanyId({ companyId });
+        const employeeSummaries: ReservationPeriodEmployeeSummary[] = [];
+
+        for (const employee of employees) {
+            const latestPeriod = await this.schedulesEnabled.schedulesEnabledList
+                .findOne({ companyId, employeeId: employee.id })
+                .sort({ endDate: -1 })
+                .exec();
+
+            const currentOpenUntil = latestPeriod ? latestPeriod.endDate : null;
+            const daysRemaining = currentOpenUntil
+                ? dayjs(currentOpenUntil).endOf("day").diff(today, "day")
+                : null;
+
+            employeeSummaries.push({
+                employeeId: employee.id,
+                employeeFullName: employee.fullName,
+                employeeEmail: employee.email,
+                employeeAvatar: employee.avatar,
+                employeeUserId: employee.userId,
+                isOpen: daysRemaining !== null && daysRemaining >= 0,
+                currentOpenUntil,
+                daysRemaining,
+            });
+        }
+
+        const currentOpenUntilDates = employeeSummaries
+            .map(employee => employee.currentOpenUntil)
+            .filter((date): date is Date => Boolean(date));
+        const remainingValues = employeeSummaries
+            .map(employee => employee.daysRemaining)
+            .filter((days): days is number => days !== null);
+        const hasMissing = employeeSummaries.some(employee => employee.currentOpenUntil === null);
+        const hasExpired = employeeSummaries.some(employee => employee.daysRemaining !== null && employee.daysRemaining < 0);
+        const hasNearEnding = employeeSummaries.some(employee => employee.daysRemaining !== null && employee.daysRemaining <= NEAR_ENDING_THRESHOLD_DAYS);
+
+        return {
+            companyId,
+            status: hasMissing ? "missing" : hasExpired ? "expired" : hasNearEnding ? "near-ending" : "open",
+            worstDaysRemaining: remainingValues.length > 0 ? Math.min(...remainingValues) : null,
+            currentOpenUntil: currentOpenUntilDates.length > 0
+                ? currentOpenUntilDates.reduce((max, date) => dayjs(date).isAfter(max) ? date : max, currentOpenUntilDates[0])
+                : null,
+            nearEndingThresholdDays: NEAR_ENDING_THRESHOLD_DAYS,
+            employees: employeeSummaries,
+        };
+    }
 }
 
 const SchedulesEnabledList = new SchedulesEnabledManager();

server/src/Models/Services/Service.Adapter.Mongoose.ts

@@ -42,6 +42,8 @@ export class ServicesAdapterMongoose implements IServicesAdapter {
             longitude: { type: Number, required: false, default: 0 },
             published: { type: String, required: false },
             banned: { type: Boolean, required: false, default: false },
+            showPublicScores: { type: Boolean, required: false, default: true },
+            showPublicOpinions: { type: Boolean, required: false, default: true },
         });
 
         this.serviceList = model<IServiceDocument>("Service", this.schema);
@@ -93,6 +95,8 @@ export class ServicesAdapterMongoose implements IServicesAdapter {
         if (data.latitude) updateService.latitude = data.latitude;
         if (data.longitude) updateService.longitude = data.longitude;
         if (data.banned !== undefined) updateService.banned = data.banned;
+        if (data.showPublicScores !== undefined) updateService.showPublicScores = data.showPublicScores;
+        if (data.showPublicOpinions !== undefined) updateService.showPublicOpinions = data.showPublicOpinions;
 
         await updateService.save();
     }