@blackcode_sa/metaestetics-api 1.12.61 → 1.12.62

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

@@ -1,195 +1,195 @@
-import { Firestore, updateDoc, serverTimestamp, doc } from 'firebase/firestore';
-import {
-  Appointment,
-  RecommendedProcedure,
-  ExtendedProcedureInfo,
-  APPOINTMENTS_COLLECTION,
-} from '../../../types/appointment';
-import { getAppointmentOrThrow, initializeMetadata } from './zone-management.utils';
-import { PROCEDURES_COLLECTION } from '../../../types/procedure';
-import { getDoc } from 'firebase/firestore';
-
-/**
- * Creates ExtendedProcedureInfo from procedure document for recommended procedures
- * @param db Firestore instance
- * @param procedureId Procedure ID
- * @returns Extended procedure info
- */
-async function createExtendedProcedureInfoForRecommended(
-  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,
-    procedureCategoryId: data.category.id,
-    procedureCategoryName: data.category.name,
-    procedureSubCategoryId: data.subcategory.id,
-    procedureSubCategoryName: data.subcategory.name,
-    procedureTechnologyId: data.technology.id,
-    procedureTechnologyName: data.technology.name,
-    procedureProducts: (data.productsMetadata || [])
-      .filter((pp: any) => pp && pp.product) // Safety check for product-free procedures
-      .map((pp: any) => ({
-      productId: pp.product.id,
-      productName: pp.product.name,
-      brandId: pp.product.brandId,
-      brandName: pp.product.brandName,
-    })),
-  };
-}
-
-/**
- * Adds a recommended procedure to an appointment
- * Multiple recommendations of the same procedure are allowed (e.g., touch-up in 2 weeks, full treatment in 3 months)
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param procedureId Procedure ID to recommend
- * @param note Note explaining the recommendation
- * @param timeframe Suggested timeframe for the procedure
- * @returns Updated appointment
- */
-export async function addRecommendedProcedureUtil(
-  db: Firestore,
-  appointmentId: string,
-  procedureId: string,
-  note: string,
-  timeframe: { value: number; unit: 'day' | 'week' | 'month' | 'year' }
-): Promise<Appointment> {
-  const appointment = await getAppointmentOrThrow(db, appointmentId);
-  const metadata = initializeMetadata(appointment);
-
-  // Create extended procedure info
-  const procedureInfo = await createExtendedProcedureInfoForRecommended(db, procedureId);
-
-  // Create recommended procedure object
-  const recommendedProcedure: RecommendedProcedure = {
-    procedure: procedureInfo,
-    note,
-    timeframe,
-  };
-
-  // Add to recommended procedures array
-  const recommendedProcedures = [...(metadata.recommendedProcedures || []), recommendedProcedure];
-
-  // Update appointment
-  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
-  await updateDoc(appointmentRef, {
-    'metadata.recommendedProcedures': recommendedProcedures,
-    updatedAt: serverTimestamp(),
-  });
-
-  return getAppointmentOrThrow(db, appointmentId);
-}
-
-/**
- * Removes a recommended procedure from an appointment by index
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param recommendationIndex Index of the recommendation to remove in the array
- * @returns Updated appointment
- */
-export async function removeRecommendedProcedureUtil(
-  db: Firestore,
-  appointmentId: string,
-  recommendationIndex: number
-): Promise<Appointment> {
-  const appointment = await getAppointmentOrThrow(db, appointmentId);
-  const metadata = initializeMetadata(appointment);
-
-  if (!metadata.recommendedProcedures || metadata.recommendedProcedures.length === 0) {
-    throw new Error('No recommended procedures found for this appointment');
-  }
-
-  // Validate index
-  if (recommendationIndex < 0 || recommendationIndex >= metadata.recommendedProcedures.length) {
-    throw new Error(`Invalid recommendation index ${recommendationIndex}. Must be between 0 and ${metadata.recommendedProcedures.length - 1}`);
-  }
-
-  // Remove recommendation
-  const updatedRecommendedProcedures = [...metadata.recommendedProcedures];
-  updatedRecommendedProcedures.splice(recommendationIndex, 1);
-
-  // Update appointment
-  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
-  await updateDoc(appointmentRef, {
-    'metadata.recommendedProcedures': updatedRecommendedProcedures,
-    updatedAt: serverTimestamp(),
-  });
-
-  return getAppointmentOrThrow(db, appointmentId);
-}
-
-/**
- * Updates a recommended procedure in an appointment by index
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @param recommendationIndex Index of the recommendation to update
- * @param updates Partial updates (note and/or timeframe)
- * @returns Updated appointment
- */
-export async function updateRecommendedProcedureUtil(
-  db: Firestore,
-  appointmentId: string,
-  recommendationIndex: number,
-  updates: {
-    note?: string;
-    timeframe?: { value: number; unit: 'day' | 'week' | 'month' | 'year' };
-  }
-): Promise<Appointment> {
-  const appointment = await getAppointmentOrThrow(db, appointmentId);
-  const metadata = initializeMetadata(appointment);
-
-  if (!metadata.recommendedProcedures || metadata.recommendedProcedures.length === 0) {
-    throw new Error('No recommended procedures found for this appointment');
-  }
-
-  // Validate index
-  if (recommendationIndex < 0 || recommendationIndex >= metadata.recommendedProcedures.length) {
-    throw new Error(`Invalid recommendation index ${recommendationIndex}. Must be between 0 and ${metadata.recommendedProcedures.length - 1}`);
-  }
-
-  // Update the recommendation
-  const updatedRecommendedProcedures = [...metadata.recommendedProcedures];
-  const existingRecommendation = updatedRecommendedProcedures[recommendationIndex];
-
-  updatedRecommendedProcedures[recommendationIndex] = {
-    ...existingRecommendation,
-    ...(updates.note !== undefined && { note: updates.note }),
-    ...(updates.timeframe !== undefined && { timeframe: updates.timeframe }),
-  };
-
-  // Update appointment
-  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
-  await updateDoc(appointmentRef, {
-    'metadata.recommendedProcedures': updatedRecommendedProcedures,
-    updatedAt: serverTimestamp(),
-  });
-
-  return getAppointmentOrThrow(db, appointmentId);
-}
-
-/**
- * Gets all recommended procedures for an appointment
- * @param db Firestore instance
- * @param appointmentId Appointment ID
- * @returns Array of recommended procedures
- */
-export async function getRecommendedProceduresUtil(
-  db: Firestore,
-  appointmentId: string
-): Promise<RecommendedProcedure[]> {
-  const appointment = await getAppointmentOrThrow(db, appointmentId);
-  return appointment.metadata?.recommendedProcedures || [];
-}
-
+import { Firestore, updateDoc, serverTimestamp, doc } from 'firebase/firestore';
+import {
+  Appointment,
+  RecommendedProcedure,
+  ExtendedProcedureInfo,
+  APPOINTMENTS_COLLECTION,
+} from '../../../types/appointment';
+import { getAppointmentOrThrow, initializeMetadata } from './zone-management.utils';
+import { PROCEDURES_COLLECTION } from '../../../types/procedure';
+import { getDoc } from 'firebase/firestore';
+
+/**
+ * Creates ExtendedProcedureInfo from procedure document for recommended procedures
+ * @param db Firestore instance
+ * @param procedureId Procedure ID
+ * @returns Extended procedure info
+ */
+async function createExtendedProcedureInfoForRecommended(
+  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,
+    procedureCategoryId: data.category.id,
+    procedureCategoryName: data.category.name,
+    procedureSubCategoryId: data.subcategory.id,
+    procedureSubCategoryName: data.subcategory.name,
+    procedureTechnologyId: data.technology.id,
+    procedureTechnologyName: data.technology.name,
+    procedureProducts: (data.productsMetadata || [])
+      .filter((pp: any) => pp && pp.product) // Safety check for product-free procedures
+      .map((pp: any) => ({
+      productId: pp.product.id,
+      productName: pp.product.name,
+      brandId: pp.product.brandId,
+      brandName: pp.product.brandName,
+    })),
+  };
+}
+
+/**
+ * Adds a recommended procedure to an appointment
+ * Multiple recommendations of the same procedure are allowed (e.g., touch-up in 2 weeks, full treatment in 3 months)
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param procedureId Procedure ID to recommend
+ * @param note Note explaining the recommendation
+ * @param timeframe Suggested timeframe for the procedure
+ * @returns Updated appointment
+ */
+export async function addRecommendedProcedureUtil(
+  db: Firestore,
+  appointmentId: string,
+  procedureId: string,
+  note: string,
+  timeframe: { value: number; unit: 'day' | 'week' | 'month' | 'year' }
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  // Create extended procedure info
+  const procedureInfo = await createExtendedProcedureInfoForRecommended(db, procedureId);
+
+  // Create recommended procedure object
+  const recommendedProcedure: RecommendedProcedure = {
+    procedure: procedureInfo,
+    note,
+    timeframe,
+  };
+
+  // Add to recommended procedures array
+  const recommendedProcedures = [...(metadata.recommendedProcedures || []), recommendedProcedure];
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.recommendedProcedures': recommendedProcedures,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Removes a recommended procedure from an appointment by index
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param recommendationIndex Index of the recommendation to remove in the array
+ * @returns Updated appointment
+ */
+export async function removeRecommendedProcedureUtil(
+  db: Firestore,
+  appointmentId: string,
+  recommendationIndex: number
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  if (!metadata.recommendedProcedures || metadata.recommendedProcedures.length === 0) {
+    throw new Error('No recommended procedures found for this appointment');
+  }
+
+  // Validate index
+  if (recommendationIndex < 0 || recommendationIndex >= metadata.recommendedProcedures.length) {
+    throw new Error(`Invalid recommendation index ${recommendationIndex}. Must be between 0 and ${metadata.recommendedProcedures.length - 1}`);
+  }
+
+  // Remove recommendation
+  const updatedRecommendedProcedures = [...metadata.recommendedProcedures];
+  updatedRecommendedProcedures.splice(recommendationIndex, 1);
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.recommendedProcedures': updatedRecommendedProcedures,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Updates a recommended procedure in an appointment by index
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @param recommendationIndex Index of the recommendation to update
+ * @param updates Partial updates (note and/or timeframe)
+ * @returns Updated appointment
+ */
+export async function updateRecommendedProcedureUtil(
+  db: Firestore,
+  appointmentId: string,
+  recommendationIndex: number,
+  updates: {
+    note?: string;
+    timeframe?: { value: number; unit: 'day' | 'week' | 'month' | 'year' };
+  }
+): Promise<Appointment> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  const metadata = initializeMetadata(appointment);
+
+  if (!metadata.recommendedProcedures || metadata.recommendedProcedures.length === 0) {
+    throw new Error('No recommended procedures found for this appointment');
+  }
+
+  // Validate index
+  if (recommendationIndex < 0 || recommendationIndex >= metadata.recommendedProcedures.length) {
+    throw new Error(`Invalid recommendation index ${recommendationIndex}. Must be between 0 and ${metadata.recommendedProcedures.length - 1}`);
+  }
+
+  // Update the recommendation
+  const updatedRecommendedProcedures = [...metadata.recommendedProcedures];
+  const existingRecommendation = updatedRecommendedProcedures[recommendationIndex];
+
+  updatedRecommendedProcedures[recommendationIndex] = {
+    ...existingRecommendation,
+    ...(updates.note !== undefined && { note: updates.note }),
+    ...(updates.timeframe !== undefined && { timeframe: updates.timeframe }),
+  };
+
+  // Update appointment
+  const appointmentRef = doc(db, APPOINTMENTS_COLLECTION, appointmentId);
+  await updateDoc(appointmentRef, {
+    'metadata.recommendedProcedures': updatedRecommendedProcedures,
+    updatedAt: serverTimestamp(),
+  });
+
+  return getAppointmentOrThrow(db, appointmentId);
+}
+
+/**
+ * Gets all recommended procedures for an appointment
+ * @param db Firestore instance
+ * @param appointmentId Appointment ID
+ * @returns Array of recommended procedures
+ */
+export async function getRecommendedProceduresUtil(
+  db: Firestore,
+  appointmentId: string
+): Promise<RecommendedProcedure[]> {
+  const appointment = await getAppointmentOrThrow(db, appointmentId);
+  return appointment.metadata?.recommendedProcedures || [];
+}
+