@blackcode_sa/metaestetics-api 1.12.31 → 1.12.33

package/src/services/appointment/utils/zone-management.utils.ts

@@ -0,0 +1,335 @@
+import { Firestore, getDoc, updateDoc, serverTimestamp } from 'firebase/firestore';
+import {
+  ZoneItemData,
+  AppointmentMetadata,
+  FinalBilling,
+  Appointment,
+  APPOINTMENTS_COLLECTION,
+} from '../../../types/appointment';
+import { getAppointmentByIdUtil } from './appointment.utils';
+import { doc } from 'firebase/firestore';
+
+/**
+ * Validates that a zone key follows the category.zone format
+ * @param zoneKey Zone key to validate
+ * @throws Error if format is invalid
+ */
+export function validateZoneKeyFormat(zoneKey: string): void {
+  const parts = zoneKey.split('.');
+  if (parts.length !== 2) {
+    throw new Error(
+      `Invalid zone key format: "${zoneKey}". Must be "category.zone" (e.g., "face.forehead")`
+    );
+  }
+}
+
+/**
+ * Calculates subtotal for a zone item
+ * @param item Zone item data
+ * @returns Calculated subtotal
+ */
+export function calculateItemSubtotal(item: Partial<ZoneItemData>): number {
+  if (item.type === 'note') {
+    return 0;
+  }
+
+  // If price override amount is set, use it
+  if (item.priceOverrideAmount !== undefined && item.priceOverrideAmount !== null) {
+    return item.priceOverrideAmount;
+  }
+
+  // Calculate normally: price * quantity
+  const price = item.price || 0;
+  const quantity = item.quantity || 0;
+  return price * quantity;
+}
+
+/**
+ * Recalculates final billing based on all zone items
+ * @param zonesData Zone items data
+ * @param taxRate Tax rate (e.g., 0.20 for 20%)
+ * @returns Calculated final billing
+ */
+export function calculateFinalBilling(
+  zonesData: Record<string, ZoneItemData[]>,
+  taxRate: number = 0.20
+): FinalBilling {
+  let subtotalAll = 0;
+
+  // Sum up all zone items
+  Object.values(zonesData).forEach(items => {
+    items.forEach(item => {
+      if (item.type === 'item' && item.subtotal) {
+        subtotalAll += item.subtotal;
+      }
+    });
+  });
+
+  const taxPrice = subtotalAll * taxRate;
+  const finalPrice = subtotalAll + taxPrice;
+
+  // Get currency from first item (assuming all same currency)
+  let currency: any = 'CHF'; // Default
+
+  for (const items of Object.values(zonesData)) {
+    const firstItem = items.find(i => i.type === 'item');
+    if (firstItem) {
+      currency = firstItem.currency || currency;
+      break;
+    }
+  }
+
+  return {
+    subtotalAll,
+    taxRate,
+    taxPrice,
+    finalPrice,
+    currency,
+  };
+}
+
+/**
+ * Gets appointment and validates it exists
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @returns Appointment document
+ */
+export async function getAppointmentOrThrow(
+  db: Firestore,
+  appointmentId: string
+): Promise<Appointment> {
+  const appointment = await getAppointmentByIdUtil(db, appointmentId);
+  if (!appointment) {
+    throw new Error(`Appointment with ID ${appointmentId} not found`);
+  }
+  return appointment;
+}
+
+/**
+ * Initializes appointment metadata if it doesn't exist
+ * @param appointment Appointment document
+ * @returns Initialized metadata
+ */
+export function initializeMetadata(
+  appointment: Appointment
+): AppointmentMetadata {
+  return appointment.metadata || {
+    selectedZones: null,
+    zonePhotos: null,
+    zonesData: null,
+    appointmentProducts: [],
+    extendedProcedures: [],
+    finalbilling: null,
+    finalizationNotes: null,
+  };
+}
+
+/**
+ * Adds an item to a specific zone
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID (must be category.zone format)
+ * @param item Zone item data to add (without parentZone)
+ * @returns Updated appointment
+ */
+export async function addItemToZoneUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  item: Omit<ZoneItemData, 'subtotal' | 'parentZone'>
+): Promise<Appointment> {
+  // Validate zone key format
+  validateZoneKeyFormat(zoneId);
+
+  // Get appointment
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  // Initialize zonesData if needed
+  const zonesData = metadata.zonesData || {};
+
+  // Initialize zone array if needed
+  if (!zonesData[zoneId]) {
+    zonesData[zoneId] = [];
+  }
+
+  // Calculate subtotal for the item
+  const itemWithSubtotal: ZoneItemData = {
+    ...item,
+    parentZone: zoneId, // Set parentZone to the zone key
+    subtotal: calculateItemSubtotal(item),
+  };
+
+  // Add item to zone
+  zonesData[zoneId].push(itemWithSubtotal);
+
+  // Recalculate final billing
+  const finalbilling = calculateFinalBilling(zonesData); //TODO: add correct amount of tax
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.zonesData': zonesData,
+    'metadata.finalbilling': finalbilling,
+    updatedAt: serverTimestamp(),
+  });
+
+  // Return updated appointment
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Removes an item from a specific zone
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param itemIndex Index of item to remove
+ * @returns Updated appointment
+ */
+export async function removeItemFromZoneUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  itemIndex: number
+): Promise<Appointment> {
+  validateZoneKeyFormat(zoneId);
+
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  if (!metadata.zonesData || !metadata.zonesData[zoneId]) {
+    throw new Error(`No items found for zone ${zoneId}`);
+  }
+
+  const items = metadata.zonesData[zoneId];
+  if (itemIndex < 0 || itemIndex >= items.length) {
+    throw new Error(`Invalid item index ${itemIndex} for zone ${zoneId}`);
+  }
+
+  // Remove item
+  items.splice(itemIndex, 1);
+
+  // If zone is now empty, remove it
+  if (items.length === 0) {
+    delete metadata.zonesData[zoneId];
+  }
+
+  // Recalculate final billing
+  const finalbilling = calculateFinalBilling(metadata.zonesData); //TODO: add correct amount of tax
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.zonesData': metadata.zonesData,
+    'metadata.finalbilling': finalbilling,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Updates a specific item in a zone
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param itemIndex Index of item to update
+ * @param updates Partial updates to apply
+ * @returns Updated appointment
+ */
+export async function updateZoneItemUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  itemIndex: number,
+  updates: Partial<ZoneItemData>
+): Promise<Appointment> {
+  validateZoneKeyFormat(zoneId);
+
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  if (!metadata.zonesData || !metadata.zonesData[zoneId]) {
+    throw new Error(`No items found for zone ${zoneId}`);
+  }
+
+  const items = metadata.zonesData[zoneId];
+  if (itemIndex < 0 || itemIndex >= items.length) {
+    throw new Error(`Invalid item index ${itemIndex} for zone ${zoneId}`);
+  }
+
+  // Update item
+  items[itemIndex] = {
+    ...items[itemIndex],
+    ...updates,
+  };
+
+  // Recalculate subtotal for this item
+  items[itemIndex].subtotal = calculateItemSubtotal(items[itemIndex]);
+
+  // Recalculate final billing
+  const finalbilling = calculateFinalBilling(metadata.zonesData); //TODO: add correct amount of tax
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.zonesData': metadata.zonesData,
+    'metadata.finalbilling': finalbilling,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Overrides price for a specific zone item
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param itemIndex Index of item
+ * @param newPrice New price amount
+ * @returns Updated appointment
+ */
+export async function overridePriceForZoneItemUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  itemIndex: number,
+  newPrice: number
+): Promise<Appointment> {
+  return updateZoneItemUtil(db, appointmentId, zoneId, itemIndex, {
+    priceOverrideAmount: newPrice,
+  });
+}
+
+/**
+ * Updates subzones for a specific zone item
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param zoneId Zone ID
+ * @param itemIndex Index of item
+ * @param subzones Array of subzone keys (empty array = entire zone)
+ * @returns Updated appointment
+ */
+export async function updateSubzonesUtil(
+  db: Firestore,
+  appointmentId: string,
+  zoneId: string,
+  itemIndex: number,
+  subzones: string[]
+): Promise<Appointment> {
+  // Validate subzone format if provided
+  subzones.forEach(subzone => {
+    const parts = subzone.split('.');
+    if (parts.length !== 3) {
+      throw new Error(
+        `Invalid subzone format: "${subzone}". Must be "category.zone.subzone" (e.g., "face.forehead.left")`
+      );
+    }
+  });
+
+  return updateZoneItemUtil(db, appointmentId, zoneId, itemIndex, {
+    subzones,
+  });
+}
+

package/src/services/patient/patient.service.ts

@@ -93,6 +93,17 @@ import {
   getActiveInviteTokensByPatientUtil,
 } from './utils';
 
+import {
+  getAestheticAnalysisUtil,
+  createOrUpdateAestheticAnalysisUtil,
+} from './utils/aesthetic-analysis.utils';
+
+import {
+  AestheticAnalysis,
+  CreateAestheticAnalysisData,
+  UpdateAestheticAnalysisData,
+} from '../../types/patient';
+
 import { CreatePatientTokenData, PatientToken } from '../../types/patient/token.types';
 
 export class PatientService extends BaseService {
@@ -834,4 +845,39 @@ export class PatientService extends BaseService {
     // the admin has permission to view this patient's tokens.
     return getActiveInviteTokensByPatientUtil(this.db, patientId);
   }
+
+  async getAestheticAnalysis(patientId: string): Promise<AestheticAnalysis | null> {
+    const currentUser = await this.getCurrentUser();
+    return getAestheticAnalysisUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createAestheticAnalysis(
+    patientId: string,
+    data: CreateAestheticAnalysisData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateAestheticAnalysisUtil(
+      this.db,
+      patientId,
+      data,
+      currentUser.uid,
+      currentUser.roles,
+      false
+    );
+  }
+
+  async updateAestheticAnalysis(
+    patientId: string,
+    data: UpdateAestheticAnalysisData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateAestheticAnalysisUtil(
+      this.db,
+      patientId,
+      data,
+      currentUser.uid,
+      currentUser.roles,
+      true
+    );
+  }
 }

package/src/services/patient/utils/aesthetic-analysis.utils.ts

@@ -5,6 +5,7 @@ import {
   UpdateAestheticAnalysisData,
   AESTHETIC_ANALYSIS_COLLECTION,
   PATIENTS_COLLECTION,
+  AestheticAnalysisStatus,
 } from '../../../types/patient';
 import { UserRole } from '../../../types';
 import {
@@ -63,6 +64,37 @@ const checkAestheticAnalysisAccessUtil = async (
   );
 };
 
+export const calculateCompletionPercentage = (data: Partial<AestheticAnalysis>): number => {
+  let completed = 0;
+  const total = 4;
+
+  if (data.selectedConcerns && data.selectedConcerns.length > 0) completed++;
+  
+  if (data.patientGoals && (
+    data.patientGoals.timeline || 
+    data.patientGoals.budget || 
+    data.patientGoals.selectedTemplate
+  )) completed++;
+  
+  if (data.assessmentScales && Object.keys(data.assessmentScales).length > 0) completed++;
+  
+  if (data.clinicalFindings && Object.keys(data.clinicalFindings).length > 0) completed++;
+
+  return Math.round((completed / total) * 100);
+};
+
+export const determineStatus = (completionPercentage: number, selectedConcerns: string[]): AestheticAnalysisStatus => {
+  if (completionPercentage < 50) {
+    return 'incomplete';
+  }
+  
+  if (completionPercentage >= 50 && selectedConcerns.length > 0) {
+    return 'ready_for_planning';
+  }
+  
+  return 'incomplete';
+};
+
 export const getAestheticAnalysisUtil = async (
   db: Firestore,
   patientId: string,
@@ -78,7 +110,11 @@ export const getAestheticAnalysisUtil = async (
     return null;
   }
   
-  return aestheticAnalysisSchema.parse(snapshot.data());
+  const data = snapshot.data();
+  return aestheticAnalysisSchema.parse({
+    ...data,
+    id: patientId,
+  });
 };
 
 export const createOrUpdateAestheticAnalysisUtil = async (
@@ -100,10 +136,28 @@ export const createOrUpdateAestheticAnalysisUtil = async (
   
   const requesterRole = requesterRoles.includes(UserRole.PRACTITIONER) ? 'PRACTITIONER' : 'PATIENT';
   
+  const existingData = snapshot.exists() ? snapshot.data() : null;
+  const mergedData: any = {
+    ...(existingData || {}),
+    ...validatedData,
+  };
+
+  const completionPercentage = calculateCompletionPercentage(mergedData);
+  const status = determineStatus(
+    completionPercentage,
+    mergedData.selectedConcerns || []
+  );
+  
   if (!snapshot.exists()) {
     await setDoc(docRef, {
+      id: patientId,
       patientId,
+      selectedConcerns: [],
+      clinicalFindings: {},
+      assessmentScales: {},
       ...validatedData,
+      completionPercentage,
+      status,
       lastUpdatedBy: requesterId,
       lastUpdatedByRole: requesterRole,
       createdAt: serverTimestamp(),
@@ -112,10 +166,11 @@ export const createOrUpdateAestheticAnalysisUtil = async (
   } else {
     await updateDoc(docRef, {
       ...validatedData,
+      completionPercentage,
+      status,
       lastUpdatedBy: requesterId,
       lastUpdatedByRole: requesterRole,
       updatedAt: serverTimestamp(),
     });
   }
 };
-

package/src/services/procedure/procedure.service.ts

@@ -1508,4 +1508,58 @@ export class ProcedureService extends BaseService {
     });
     return proceduresForMap;
   }
+
+  /**
+   * Gets procedures filtered by clinic and practitioner with optional family filter
+   * @param clinicBranchId Clinic branch ID to filter by
+   * @param practitionerId Practitioner ID to filter by
+   * @param filterByFamily If true, shows only procedures of the same family as the default procedure
+   * @param defaultProcedureId Optional default procedure ID to determine the family
+   * @returns Array of procedures
+   */
+  async getProceduresForConsultation(
+    clinicBranchId: string,
+    practitionerId: string,
+    filterByFamily: boolean = true,
+    defaultProcedureId?: string
+  ): Promise<Procedure[]> {
+    let familyToFilter: ProcedureFamily | null = null;
+
+    // If family filtering is enabled and we have a default procedure, get its family
+    if (filterByFamily && defaultProcedureId) {
+      const defaultProcedureRef = doc(this.db, PROCEDURES_COLLECTION, defaultProcedureId);
+      const defaultProcedureSnap = await getDoc(defaultProcedureRef);
+      
+      if (defaultProcedureSnap.exists()) {
+        const defaultProcedure = defaultProcedureSnap.data() as Procedure;
+        familyToFilter = defaultProcedure.family;
+      }
+    }
+
+    // Build query constraints
+    const constraints: QueryConstraint[] = [
+      where('clinicBranchId', '==', clinicBranchId),
+      where('practitionerId', '==', practitionerId),
+      where('isActive', '==', true),
+    ];
+
+    // Add family filter if applicable
+    if (filterByFamily && familyToFilter) {
+      constraints.push(where('family', '==', familyToFilter));
+    }
+
+    // Execute query
+    const proceduresQuery = query(
+      collection(this.db, PROCEDURES_COLLECTION),
+      ...constraints,
+      orderBy('name', 'asc')
+    );
+
+    const querySnapshot = await getDocs(proceduresQuery);
+    
+    return querySnapshot.docs.map(doc => ({
+      id: doc.id,
+      ...doc.data(),
+    } as Procedure));
+  }
 }

package/src/types/appointment/index.ts

@@ -76,8 +76,12 @@ export interface ProcedureExtendedInfo {
   procedureTechnologyName: string;
   procedureProductBrandId: string;
   procedureProductBrandName: string;
-  procedureProductId: string; // We need to have more than one product allowed in this data, this is coming from aggregation, so please update aggregation and this data type
-  procedureProductName: string; // We need to have more than one product allowed in this data, this is coming from aggregation, so please update aggregation and this data type
+  procedureProducts: Array<{
+    productId: string;
+    productName: string;
+    brandId: string;
+    brandName: string;
+  }>;
 }
 
 /**
@@ -132,26 +136,39 @@ export interface ZonePhotoUploadData {
 }
 
 /**
- * Interface for billing information per zone
+ * Interface for zone item data (products or notes per zone)
  */
-export interface BillingPerZone { // We should rename this to ZoneItemData and we should expend it as per our documentations (will be used for both zone items in step 3 and summary and pricing in the step 4)
-  /** Product name/description */
+export interface ZoneItemData {
+  productId?: string;
+  productName?: string;
+  productBrandId?: string;
+  productBrandName?: string;
+  belongingProcedureId: string;
+  type: 'item' | 'note';
+  price?: number;
+  currency?: Currency;
+  unitOfMeasurement?: PricingMeasure;
+  priceOverrideAmount?: number; // If set, takes precedence over price
+  quantity?: number;
+  parentZone: string; // Zone key in format "category.zone" (e.g., "face.forehead")
+  subzones: string[];
+  notes?: string;
+  subtotal?: number;
+  ionNumber?: string;
+}
+
+/**
+ * @deprecated Use ZoneItemData instead
+ */
+export interface BillingPerZone {
   Product: string;
-  /** Product ID */
   ProductId: string | null;
-  /** Quantity used (can be decimal) */
   Quantity: number;
-  /** Unit of measurement */
   UnitOfMeasurement: PricingMeasure;
-  /** Unit price for the product */
   UnitPrice: number;
-  /** Currency for the unit price */
   UnitCurency: Currency;
-  /** Calculated subtotal */
   Subtotal: number;
-  /** Optional billing note */
   Note: string | null;
-  /** Ion/Batch number for traceability */
   IonNumber: string | null;
 }
 
@@ -167,29 +184,61 @@ export interface FinalBilling {
   taxPrice: number;
   /** Final price including tax */
   finalPrice: number;
-  /** Total final quantity across all zones */
-  finalQuantity: number; // Not sure we should keep this as well, we keep track of this per item
   /** Currency for the final billing */
   currency: Currency;
-  /** Unit of measurement for the final billing */
-  unitOfMeasurement: PricingMeasure; // NO need to keep this, we keep track of this per item
+}
+
+/**
+ * Interface for product metadata in appointment
+ */
+export interface AppointmentProductMetadata {
+  productId: string;
+  productName: string;
+  brandId: string;
+  brandName: string;
+  procedureId: string;
+  price: number;
+  currency: Currency;
+  unitOfMeasurement: PricingMeasure;
+}
+
+/**
+ * Interface for extended procedures in appointment
+ */
+export interface ExtendedProcedureInfo {
+  procedureId: string;
+  procedureName: string;
+  procedureFamily?: ProcedureFamily;
+  procedureCategoryId: string;
+  procedureCategoryName: string;
+  procedureSubCategoryId: string;
+  procedureSubCategoryName: string;
+  procedureTechnologyId: string;
+  procedureTechnologyName: string;
+  procedureProducts: Array<{
+    productId: string;
+    productName: string;
+    brandId: string;
+    brandName: string;
+  }>;
 }
 
 /**
  * Interface for appointment metadata containing zone-specific information
  */
 export interface AppointmentMetadata {
-  /** Array of selected zones for the appointment */
-  selectedZones: string[] | null; // We are not going to accept any structure (category.zone.subzone), here we will only accept zone (category.zone), nothing more, nothing less
-  /** Map of zone photos with before/after images and notes */
-  zonePhotos: Record<string, BeforeAfterPerZone> | null; // head.forhead: {object}, head: {object}, but it can't have head.forhead.forhedLeft: {object}
-  /** Map of billing information per zone */
-  zoneBilling: Record<string, BillingPerZone> | null; // This is going to change, name it zonesData, and expand this to accept more than one item per key (which is basically zone like category.zone)
-  /** Final billing calculations for the appointment */
+  selectedZones: string[] | null;
+  zonePhotos: Record<string, BeforeAfterPerZone> | null;
+  zonesData?: Record<string, ZoneItemData[]> | null;
+  appointmentProducts?: AppointmentProductMetadata[];
+  extendedProcedures?: ExtendedProcedureInfo[];
   finalbilling: FinalBilling | null;
-  /** Final note for the appointment */
   finalizationNotes: string | null;
-  // TO-DO: We need to add extended procedures info (when we add multiple procedures, different than default one defined above)
+  
+  /**
+   * @deprecated Use zonesData instead
+   */
+  zoneBilling?: Record<string, BillingPerZone> | null;
 }
 
 /**