@blackcode_sa/metaestetics-api 1.12.32 → 1.12.33

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.12.32",
+  "version": "1.12.33",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/admin/booking/booking.admin.ts

@@ -840,6 +840,9 @@ export class BookingAdmin {
         allLinkedFormTemplateIds = formInitResult.allLinkedTemplateIds;
       }
 
+      // --- Generate appointment products from procedure ---
+      const appointmentProducts = this._generateAppointmentProductsFromProcedure(procedure);
+
       // --- Construct Appointment Object ---
       const newAppointmentData: Appointment = {
         id: newAppointmentId,
@@ -884,6 +887,15 @@ export class BookingAdmin {
         linkedForms: initializedFormsInfo,
         media: [],
         reviewInfo: null,
+        metadata: {
+          selectedZones: null,
+          zonePhotos: null,
+          zonesData: null,
+          appointmentProducts: appointmentProducts,
+          extendedProcedures: [],
+          finalbilling: null,
+          finalizationNotes: null,
+        },
         finalizedDetails: {
           by: "",
           at: adminTsNow as any,
@@ -974,6 +986,8 @@ export class BookingAdmin {
     const procedureSubCategory = procedure.subcategory as Subcategory;
     const procedureTechnology = procedure.technology as Technology;
     const procedureProduct = procedure.product as Product;
+    const productsMetadata = procedure.productsMetadata || [];
+    
     return {
       id: procedure.id,
       name: procedure.name,
@@ -987,10 +1001,32 @@ export class BookingAdmin {
       procedureSubCategoryName: procedureSubCategory?.name || "",
       procedureTechnologyId: procedureTechnology?.id || "",
       procedureTechnologyName: procedureTechnology?.name || "",
-      procedureProductBrandId: (procedureProduct as any)?.brand?.id || "",
-      procedureProductBrandName: (procedureProduct as any)?.brand?.name || "",
-      procedureProductId: procedureProduct?.id || "",
-      procedureProductName: procedureProduct?.name || "",
+      procedureProductBrandId: procedureProduct?.brandId || "",
+      procedureProductBrandName: procedureProduct?.brandName || "",
+      procedureProducts: productsMetadata.map((pp: any) => ({
+        productId: pp.product.id,
+        productName: pp.product.name,
+        brandId: pp.product.brandId,
+        brandName: pp.product.brandName,
+      })),
     };
   }
+
+  private _generateAppointmentProductsFromProcedure(procedure: Procedure): any[] {
+    const productsMetadata = procedure.productsMetadata || [];
+    
+    return productsMetadata.map((pp: any) => {
+      const product = pp.product;
+      return {
+        productId: product.id,
+        productName: product.name,
+        brandId: product.brandId,
+        brandName: product.brandName,
+        procedureId: procedure.id,
+        price: pp.price,
+        currency: pp.currency,
+        unitOfMeasurement: pp.pricingMeasure,
+      };
+    });
+  }
 }

package/src/services/appointment/appointment.service.ts

@@ -30,6 +30,9 @@ import {
   type CreateAppointmentHttpData,
   type ZonePhotoUploadData,
   BeforeAfterPerZone,
+  ZoneItemData,
+  ExtendedProcedureInfo,
+  AppointmentProductMetadata,
   APPOINTMENTS_COLLECTION,
 } from '../../types/appointment';
 import {
@@ -53,6 +56,20 @@ import {
   getAppointmentByIdUtil,
   searchAppointmentsUtil,
 } from './utils/appointment.utils';
+import {
+  addItemToZoneUtil,
+  removeItemFromZoneUtil,
+  updateZoneItemUtil,
+  overridePriceForZoneItemUtil,
+  updateSubzonesUtil,
+  calculateFinalBilling,
+} from './utils/zone-management.utils';
+import {
+  addExtendedProcedureUtil,
+  removeExtendedProcedureUtil,
+  getExtendedProceduresUtil,
+  getAppointmentProductsUtil,
+} from './utils/extended-procedure.utils';
 
 /**
  * Interface for available booking slot
@@ -1254,6 +1271,9 @@ export class AppointmentService extends BaseService {
       const currentMetadata = appointment.metadata || {
         selectedZones: null,
         zonePhotos: null,
+        zonesData: null,
+        appointmentProducts: [],
+        extendedProcedures: [],
         zoneBilling: null,
         finalbilling: null,
         finalizationNotes: null,
@@ -1290,6 +1310,9 @@ export class AppointmentService extends BaseService {
         metadata: {
           selectedZones: currentMetadata.selectedZones,
           zonePhotos: currentZonePhotos,
+          zonesData: currentMetadata.zonesData || null,
+          appointmentProducts: currentMetadata.appointmentProducts || [],
+          extendedProcedures: currentMetadata.extendedProcedures || [],
           zoneBilling: currentMetadata.zoneBilling,
           finalbilling: currentMetadata.finalbilling,
           finalizationNotes: currentMetadata.finalizationNotes,
@@ -1422,6 +1445,9 @@ export class AppointmentService extends BaseService {
         metadata: {
           selectedZones: appointment.metadata?.selectedZones || null,
           zonePhotos: updatedZonePhotos,
+          zonesData: appointment.metadata?.zonesData || null,
+          appointmentProducts: appointment.metadata?.appointmentProducts || [],
+          extendedProcedures: appointment.metadata?.extendedProcedures || [],
           zoneBilling: appointment.metadata?.zoneBilling || null,
           finalbilling: appointment.metadata?.finalbilling || null,
           finalizationNotes: appointment.metadata?.finalizationNotes || null,
@@ -1441,4 +1467,256 @@ export class AppointmentService extends BaseService {
       throw error;
     }
   }
+
+  /**
+   * Adds an item (product or note) to a specific zone
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID (must be category.zone format, e.g., "face.forehead")
+   * @param item Zone item data to add (without parentZone - it's inferred from zoneId)
+   * @returns The updated appointment
+   */
+  async addItemToZone(
+    appointmentId: string,
+    zoneId: string,
+    item: Omit<ZoneItemData, 'subtotal' | 'parentZone'>
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Adding item to zone ${zoneId} in appointment ${appointmentId}`,
+      );
+      return await addItemToZoneUtil(this.db, appointmentId, zoneId, item);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error adding item to zone:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Removes an item from a specific zone
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID
+   * @param itemIndex Index of the item to remove in the zone's items array
+   * @returns The updated appointment
+   */
+  async removeItemFromZone(
+    appointmentId: string,
+    zoneId: string,
+    itemIndex: number,
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Removing item ${itemIndex} from zone ${zoneId} in appointment ${appointmentId}`,
+      );
+      return await removeItemFromZoneUtil(this.db, appointmentId, zoneId, itemIndex);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error removing item from zone:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates a specific item in a zone
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID
+   * @param itemIndex Index of the item to update
+   * @param updates Partial updates to apply to the item
+   * @returns The updated appointment
+   */
+  async updateZoneItem(
+    appointmentId: string,
+    zoneId: string,
+    itemIndex: number,
+    updates: Partial<ZoneItemData>,
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Updating item ${itemIndex} in zone ${zoneId} in appointment ${appointmentId}`,
+      );
+      return await updateZoneItemUtil(this.db, appointmentId, zoneId, itemIndex, updates);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error updating zone item:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Overrides the price for a specific zone item
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID
+   * @param itemIndex Index of the item
+   * @param newPrice New price amount to set
+   * @returns The updated appointment
+   */
+  async overridePriceForZoneItem(
+    appointmentId: string,
+    zoneId: string,
+    itemIndex: number,
+    newPrice: number,
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Overriding price for item ${itemIndex} in zone ${zoneId} to ${newPrice}`,
+      );
+      return await overridePriceForZoneItemUtil(this.db, appointmentId, zoneId, itemIndex, newPrice);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error overriding price:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates subzones for a specific zone item
+   *
+   * @param appointmentId ID of the appointment
+   * @param zoneId Zone ID
+   * @param itemIndex Index of the item
+   * @param subzones Array of subzone keys (category.zone.subzone format)
+   * @returns The updated appointment
+   */
+  async updateSubzones(
+    appointmentId: string,
+    zoneId: string,
+    itemIndex: number,
+    subzones: string[],
+  ): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Updating subzones for item ${itemIndex} in zone ${zoneId}`,
+      );
+      return await updateSubzonesUtil(this.db, appointmentId, zoneId, itemIndex, subzones);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error updating subzones:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Adds an extended procedure to an appointment
+   * Automatically aggregates products into appointmentProducts
+   *
+   * @param appointmentId ID of the appointment
+   * @param procedureId ID of the procedure to add
+   * @returns The updated appointment
+   */
+  async addExtendedProcedure(appointmentId: string, procedureId: string): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Adding extended procedure ${procedureId} to appointment ${appointmentId}`,
+      );
+      return await addExtendedProcedureUtil(this.db, appointmentId, procedureId);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error adding extended procedure:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Removes an extended procedure from an appointment
+   * Also removes associated products from appointmentProducts
+   *
+   * @param appointmentId ID of the appointment
+   * @param procedureId ID of the procedure to remove
+   * @returns The updated appointment
+   */
+  async removeExtendedProcedure(appointmentId: string, procedureId: string): Promise<Appointment> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Removing extended procedure ${procedureId} from appointment ${appointmentId}`,
+      );
+      return await removeExtendedProcedureUtil(this.db, appointmentId, procedureId);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error removing extended procedure:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Gets all extended procedures for an appointment
+   *
+   * @param appointmentId ID of the appointment
+   * @returns Array of extended procedures
+   */
+  async getExtendedProcedures(appointmentId: string): Promise<ExtendedProcedureInfo[]> {
+    try {
+      console.log(`[APPOINTMENT_SERVICE] Getting extended procedures for appointment ${appointmentId}`);
+      return await getExtendedProceduresUtil(this.db, appointmentId);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error getting extended procedures:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Gets all aggregated products for an appointment
+   * Includes products from main procedure and extended procedures
+   *
+   * @param appointmentId ID of the appointment
+   * @returns Array of appointment products
+   */
+  async getAppointmentProducts(appointmentId: string): Promise<AppointmentProductMetadata[]> {
+    try {
+      console.log(`[APPOINTMENT_SERVICE] Getting appointment products for appointment ${appointmentId}`);
+      return await getAppointmentProductsUtil(this.db, appointmentId);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error getting appointment products:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Recalculates final billing for an appointment based on zone items
+   *
+   * @param appointmentId ID of the appointment
+   * @param taxRate Tax rate (e.g., 0.20 for 20%)
+   * @returns The updated appointment with recalculated billing
+   */
+  async recalculateFinalBilling(appointmentId: string, taxRate?: number): Promise<Appointment> {
+    try {
+      console.log(`[APPOINTMENT_SERVICE] Recalculating final billing for appointment ${appointmentId}`);
+      
+      const appointment = await this.getAppointmentById(appointmentId);
+      if (!appointment) {
+        throw new Error(`Appointment with ID ${appointmentId} not found`);
+      }
+
+      const zonesData = appointment.metadata?.zonesData;
+      if (!zonesData || Object.keys(zonesData).length === 0) {
+        throw new Error('No zone data available for billing calculation');
+      }
+
+      const finalbilling = calculateFinalBilling(zonesData, taxRate);
+
+      const currentMetadata = appointment.metadata || {
+        selectedZones: null,
+        zonePhotos: null,
+        zonesData: null,
+        appointmentProducts: [],
+        extendedProcedures: [],
+        finalbilling: null,
+        finalizationNotes: null,
+      };
+
+      const updateData: UpdateAppointmentData = {
+        metadata: {
+          selectedZones: currentMetadata.selectedZones,
+          zonePhotos: currentMetadata.zonePhotos,
+          zonesData: currentMetadata.zonesData,
+          appointmentProducts: currentMetadata.appointmentProducts || [],
+          extendedProcedures: currentMetadata.extendedProcedures || [],
+          finalbilling,
+          finalizationNotes: currentMetadata.finalizationNotes,
+        },
+        updatedAt: serverTimestamp(),
+      };
+
+      return await this.updateAppointment(appointmentId, updateData);
+    } catch (error) {
+      console.error(`[APPOINTMENT_SERVICE] Error recalculating final billing:`, error);
+      throw error;
+    }
+  }
 }

package/src/services/appointment/utils/extended-procedure.utils.ts

@@ -0,0 +1,232 @@
+import { Firestore, updateDoc, serverTimestamp, doc, getDoc } from 'firebase/firestore';
+import {
+  Appointment,
+  ExtendedProcedureInfo,
+  AppointmentProductMetadata,
+  APPOINTMENTS_COLLECTION,
+} from '../../../types/appointment';
+import { getAppointmentOrThrow, initializeMetadata } from './zone-management.utils';
+import { PROCEDURES_COLLECTION } from '../../../types/procedure';
+
+/**
+ * Aggregates products from a procedure into appointmentProducts
+ * @param db Firestore instance
+ * @param procedureId Procedure ID to fetch
+ * @param existingProducts Current appointment products
+ * @returns Updated appointment products array
+ */
+async function aggregateProductsFromProcedure(
+  db: Firestore,
+  procedureId: string,
+  existingProducts: AppointmentProductMetadata[]
+): Promise<AppointmentProductMetadata[]> {
+  const procedureRef = doc(db, PROCEDURES_COLLECTION, procedureId);
+  const procedureSnap = await getDoc(procedureRef);
+
+  if (!procedureSnap.exists()) {
+    throw new Error(`Procedure with ID ${procedureId} not found`);
+  }
+
+  const procedureData = procedureSnap.data();
+
+  // Get procedure products from productsMetadata array
+  const productsMetadata = procedureData.productsMetadata || [];
+
+  // Map procedure products to AppointmentProductMetadata
+  const newProducts: AppointmentProductMetadata[] = productsMetadata.map((pp: any) => {
+    // Each item in productsMetadata is a ProcedureProduct with embedded Product
+    const product = pp.product;
+    
+    return {
+      productId: product.id,
+      productName: product.name,
+      brandId: product.brandId,
+      brandName: product.brandName,
+      procedureId: procedureId,
+      price: pp.price,                    // Price from ProcedureProduct
+      currency: pp.currency,              // Currency from ProcedureProduct
+      unitOfMeasurement: pp.pricingMeasure, // PricingMeasure from ProcedureProduct
+    };
+  });
+
+  // Merge with existing products, avoiding duplicates
+  const productMap = new Map<string, AppointmentProductMetadata>();
+
+  // Add existing products
+  existingProducts.forEach(p => {
+    const key = `${p.productId}-${p.procedureId}`;
+    productMap.set(key, p);
+  });
+
+  // Add new products
+  newProducts.forEach(p => {
+    const key = `${p.productId}-${p.procedureId}`;
+    if (!productMap.has(key)) {
+      productMap.set(key, p);
+    }
+  });
+
+  return Array.from(productMap.values());
+}
+
+/**
+ * Creates ExtendedProcedureInfo from procedure document
+ * @param db Firestore instance
+ * @param procedureId Procedure ID
+ * @returns Extended procedure info
+ */
+async function createExtendedProcedureInfo(
+  db: Firestore,
+  procedureId: string
+): Promise<ExtendedProcedureInfo> {
+  const procedureRef = doc(db, PROCEDURES_COLLECTION, procedureId);
+  const procedureSnap = await getDoc(procedureRef);
+
+  if (!procedureSnap.exists()) {
+    throw new Error(`Procedure with ID ${procedureId} not found`);
+  }
+
+  const data = procedureSnap.data();
+
+  return {
+    procedureId: procedureId,
+    procedureName: data.name,
+    procedureFamily: data.family,                    // Use embedded family object
+    procedureCategoryId: data.category.id,           // Access embedded category
+    procedureCategoryName: data.category.name,       // Access embedded category
+    procedureSubCategoryId: data.subcategory.id,    // Access embedded subcategory
+    procedureSubCategoryName: data.subcategory.name, // Access embedded subcategory
+    procedureTechnologyId: data.technology.id,     // Access embedded technology
+    procedureTechnologyName: data.technology.name,  // Access embedded technology
+    procedureProducts: (data.productsMetadata || []).map((pp: any) => ({
+      productId: pp.product.id,                     // Access embedded product
+      productName: pp.product.name,                  // Access embedded product
+      brandId: pp.product.brandId,                   // Access embedded product
+      brandName: pp.product.brandName,                // Access embedded product
+    })),
+  };
+}
+
+/**
+ * Adds an extended procedure to an appointment
+ * Automatically aggregates products into appointmentProducts
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID to add
+ * @returns Updated appointment
+ */
+export async function addExtendedProcedureUtil(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  // Check if procedure is already added
+  const existingProcedure = metadata.extendedProcedures?.find(
+    p => p.procedureId === procedureId
+  );
+  if (existingProcedure) {
+    throw new Error(`Procedure ${procedureId} is already added to this appointment`);
+  }
+
+  // Create extended procedure info
+  const extendedProcedureInfo = await createExtendedProcedureInfo(db, procedureId);
+
+  // Aggregate products
+  const updatedProducts = await aggregateProductsFromProcedure(
+    db,
+    procedureId,
+    metadata.appointmentProducts || []
+  );
+
+  // Add extended procedure
+  const extendedProcedures = [...(metadata.extendedProcedures || []), extendedProcedureInfo];
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.extendedProcedures': extendedProcedures,
+    'metadata.appointmentProducts': updatedProducts,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Removes an extended procedure from an appointment
+ * Also removes associated products from appointmentProducts
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID to remove
+ * @returns Updated appointment
+ */
+export async function removeExtendedProcedureUtil(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  if (!metadata.extendedProcedures || metadata.extendedProcedures.length === 0) {
+    throw new Error('No extended procedures found for this appointment');
+  }
+
+  // Find and remove the procedure
+  const procedureIndex = metadata.extendedProcedures.findIndex(
+    p => p.procedureId === procedureId
+  );
+  if (procedureIndex === -1) {
+    throw new Error(`Extended procedure ${procedureId} not found in this appointment`);
+  }
+
+  // Remove procedure
+  metadata.extendedProcedures.splice(procedureIndex, 1);
+
+  // Remove products associated with this procedure
+  const updatedProducts = (metadata.appointmentProducts || []).filter(
+    p => p.procedureId !== procedureId
+  );
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.extendedProcedures': metadata.extendedProcedures,
+    'metadata.appointmentProducts': updatedProducts,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Gets all extended procedures for an appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @returns Array of extended procedures
+ */
+export async function getExtendedProceduresUtil(
+  db: Firestore,
+  appointmentId: string
+): Promise<ExtendedProcedureInfo[]> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  return appointment.metadata?.extendedProcedures || [];
+}
+
+/**
+ * Gets all aggregated products for an appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @returns Array of appointment products
+ */
+export async function getAppointmentProductsUtil(
+  db: Firestore,
+  appointmentId: string
+): Promise<AppointmentProductMetadata[]> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  return appointment.metadata?.appointmentProducts || [];
+}
+