@blackcode_sa/metaestetics-api 1.12.65 → 1.12.67

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

@@ -1,176 +1,176 @@
-import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
-import {
-  AestheticAnalysis,
-  CreateAestheticAnalysisData,
-  UpdateAestheticAnalysisData,
-  AESTHETIC_ANALYSIS_COLLECTION,
-  PATIENTS_COLLECTION,
-  AestheticAnalysisStatus,
-} from '../../../types/patient';
-import { UserRole } from '../../../types';
-import {
-  createAestheticAnalysisSchema,
-  updateAestheticAnalysisSchema,
-  aestheticAnalysisSchema,
-} from '../../../validations/patient/aesthetic-analysis.schema';
-import { getPatientDocRef } from './docs.utils';
-import { AuthError } from '../../../errors/auth.errors';
-import { getPractitionerProfileByUserRef } from './practitioner.utils';
-import { getClinicAdminByUserRef } from '../../clinic/utils/admin.utils';
-
-export const getAestheticAnalysisDocRef = (db: Firestore, patientId: string) => {
-  return doc(db, PATIENTS_COLLECTION, patientId, AESTHETIC_ANALYSIS_COLLECTION, patientId);
-};
-
-const checkAestheticAnalysisAccessUtil = async (
-  db: Firestore,
-  patientId: string,
-  requesterId: string,
-  requesterRoles: UserRole[]
-): Promise<void> => {
-  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
-  if (!patientDoc.exists()) {
-    throw new Error('Patient profile not found');
-  }
-  const patientData = patientDoc.data() as any;
-
-  if (patientData.userRef && patientData.userRef === requesterId) {
-    return;
-  }
-
-  if (requesterRoles.includes(UserRole.PRACTITIONER)) {
-    const practitionerProfile = await getPractitionerProfileByUserRef(db, requesterId);
-    if (practitionerProfile && patientData.doctorIds?.includes(practitionerProfile.id)) {
-      return;
-    }
-  }
-
-  if (requesterRoles.includes(UserRole.CLINIC_ADMIN)) {
-    const adminProfile = await getClinicAdminByUserRef(db, requesterId);
-    if (adminProfile && adminProfile.clinicsManaged) {
-      const hasAccess = adminProfile.clinicsManaged.some((managedClinicId) =>
-        patientData.clinicIds?.includes(managedClinicId)
-      );
-      if (hasAccess) {
-        return;
-      }
-    }
-  }
-
-  throw new AuthError(
-    'Unauthorized access to aesthetic analysis.',
-    'AUTH/UNAUTHORIZED_ACCESS',
-    403
-  );
-};
-
-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,
-  requesterId: string,
-  requesterRoles: UserRole[]
-): Promise<AestheticAnalysis | null> => {
-  await checkAestheticAnalysisAccessUtil(db, patientId, requesterId, requesterRoles);
-  
-  const docRef = getAestheticAnalysisDocRef(db, patientId);
-  const snapshot = await getDoc(docRef);
-  
-  if (!snapshot.exists()) {
-    return null;
-  }
-  
-  const data = snapshot.data();
-  return aestheticAnalysisSchema.parse({
-    ...data,
-    id: patientId,
-  });
-};
-
-export const createOrUpdateAestheticAnalysisUtil = async (
-  db: Firestore,
-  patientId: string,
-  data: CreateAestheticAnalysisData | UpdateAestheticAnalysisData,
-  requesterId: string,
-  requesterRoles: UserRole[],
-  isUpdate: boolean = false
-): Promise<void> => {
-  await checkAestheticAnalysisAccessUtil(db, patientId, requesterId, requesterRoles);
-  
-  const validatedData = isUpdate
-    ? updateAestheticAnalysisSchema.parse(data)
-    : createAestheticAnalysisSchema.parse(data);
-  
-  const docRef = getAestheticAnalysisDocRef(db, patientId);
-  const snapshot = await getDoc(docRef);
-  
-  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(),
-      updatedAt: serverTimestamp(),
-    });
-  } else {
-    await updateDoc(docRef, {
-      ...validatedData,
-      completionPercentage,
-      status,
-      lastUpdatedBy: requesterId,
-      lastUpdatedByRole: requesterRole,
-      updatedAt: serverTimestamp(),
-    });
-  }
-};
+import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
+import {
+  AestheticAnalysis,
+  CreateAestheticAnalysisData,
+  UpdateAestheticAnalysisData,
+  AESTHETIC_ANALYSIS_COLLECTION,
+  PATIENTS_COLLECTION,
+  AestheticAnalysisStatus,
+} from '../../../types/patient';
+import { UserRole } from '../../../types';
+import {
+  createAestheticAnalysisSchema,
+  updateAestheticAnalysisSchema,
+  aestheticAnalysisSchema,
+} from '../../../validations/patient/aesthetic-analysis.schema';
+import { getPatientDocRef } from './docs.utils';
+import { AuthError } from '../../../errors/auth.errors';
+import { getPractitionerProfileByUserRef } from './practitioner.utils';
+import { getClinicAdminByUserRef } from '../../clinic/utils/admin.utils';
+
+export const getAestheticAnalysisDocRef = (db: Firestore, patientId: string) => {
+  return doc(db, PATIENTS_COLLECTION, patientId, AESTHETIC_ANALYSIS_COLLECTION, patientId);
+};
+
+const checkAestheticAnalysisAccessUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<void> => {
+  const patientDoc = await getDoc(getPatientDocRef(db, patientId));
+  if (!patientDoc.exists()) {
+    throw new Error('Patient profile not found');
+  }
+  const patientData = patientDoc.data() as any;
+
+  if (patientData.userRef && patientData.userRef === requesterId) {
+    return;
+  }
+
+  if (requesterRoles.includes(UserRole.PRACTITIONER)) {
+    const practitionerProfile = await getPractitionerProfileByUserRef(db, requesterId);
+    if (practitionerProfile && patientData.doctorIds?.includes(practitionerProfile.id)) {
+      return;
+    }
+  }
+
+  if (requesterRoles.includes(UserRole.CLINIC_ADMIN)) {
+    const adminProfile = await getClinicAdminByUserRef(db, requesterId);
+    if (adminProfile && adminProfile.clinicsManaged) {
+      const hasAccess = adminProfile.clinicsManaged.some((managedClinicId) =>
+        patientData.clinicIds?.includes(managedClinicId)
+      );
+      if (hasAccess) {
+        return;
+      }
+    }
+  }
+
+  throw new AuthError(
+    'Unauthorized access to aesthetic analysis.',
+    'AUTH/UNAUTHORIZED_ACCESS',
+    403
+  );
+};
+
+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,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<AestheticAnalysis | null> => {
+  await checkAestheticAnalysisAccessUtil(db, patientId, requesterId, requesterRoles);
+  
+  const docRef = getAestheticAnalysisDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+  
+  if (!snapshot.exists()) {
+    return null;
+  }
+  
+  const data = snapshot.data();
+  return aestheticAnalysisSchema.parse({
+    ...data,
+    id: patientId,
+  });
+};
+
+export const createOrUpdateAestheticAnalysisUtil = async (
+  db: Firestore,
+  patientId: string,
+  data: CreateAestheticAnalysisData | UpdateAestheticAnalysisData,
+  requesterId: string,
+  requesterRoles: UserRole[],
+  isUpdate: boolean = false
+): Promise<void> => {
+  await checkAestheticAnalysisAccessUtil(db, patientId, requesterId, requesterRoles);
+  
+  const validatedData = isUpdate
+    ? updateAestheticAnalysisSchema.parse(data)
+    : createAestheticAnalysisSchema.parse(data);
+  
+  const docRef = getAestheticAnalysisDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+  
+  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(),
+      updatedAt: serverTimestamp(),
+    });
+  } else {
+    await updateDoc(docRef, {
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      updatedAt: serverTimestamp(),
+    });
+  }
+};

package/src/services/patient/utils/clinic.utils.ts

@@ -1,80 +1,80 @@
-import {
-  collection,
-  query,
-  where,
-  getDocs,
-  Firestore,
-  limit,
-  startAfter,
-  doc,
-  getDoc,
-  QueryConstraint,
-} from "firebase/firestore";
-import { PatientProfile, PATIENTS_COLLECTION } from "../../../types/patient";
-
-/**
- * Retrieves all patients associated with a specific clinic with pagination support.
- *
- * @param {Firestore} db - Firestore instance
- * @param {string} clinicId - ID of the clinic whose patients to retrieve
- * @param {Object} options - Optional parameters for pagination
- * @param {number} options.limit - Maximum number of profiles to return
- * @param {string} options.startAfter - The ID of the document to start after (for pagination)
- * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
- */
-export const getPatientsByClinicUtil = async (
-  db: Firestore,
-  clinicId: string,
-  options?: { limit?: number; startAfter?: string }
-): Promise<PatientProfile[]> => {
-  try {
-    console.log(
-      `[getPatientsByClinicUtil] Fetching patients for clinic ID: ${clinicId} with options:`,
-      options
-    );
-
-    const patientsCollection = collection(db, PATIENTS_COLLECTION);
-    const constraints: QueryConstraint[] = [
-      where("clinicIds", "array-contains", clinicId),
-    ];
-
-    let q = query(patientsCollection, ...constraints);
-
-    // Apply pagination if needed
-    if (options?.limit) {
-      q = query(q, limit(options.limit));
-    }
-
-    // If startAfter is provided, get that document and use it for pagination
-    if (options?.startAfter) {
-      const startAfterDoc = await getDoc(
-        doc(db, PATIENTS_COLLECTION, options.startAfter)
-      );
-      if (startAfterDoc.exists()) {
-        q = query(q, startAfter(startAfterDoc));
-      }
-    }
-
-    const patientsSnapshot = await getDocs(q);
-
-    const patients: PatientProfile[] = [];
-    patientsSnapshot.forEach((doc) => {
-      patients.push(doc.data() as PatientProfile);
-    });
-
-    console.log(
-      `[getPatientsByClinicUtil] Found ${patients.length} patients for clinic ID: ${clinicId}`
-    );
-    return patients;
-  } catch (error) {
-    console.error(
-      `[getPatientsByClinicUtil] Error fetching patients for clinic:`,
-      error
-    );
-    throw new Error(
-      `Failed to retrieve patients for clinic: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-};
+import {
+  collection,
+  query,
+  where,
+  getDocs,
+  Firestore,
+  limit,
+  startAfter,
+  doc,
+  getDoc,
+  QueryConstraint,
+} from "firebase/firestore";
+import { PatientProfile, PATIENTS_COLLECTION } from "../../../types/patient";
+
+/**
+ * Retrieves all patients associated with a specific clinic with pagination support.
+ *
+ * @param {Firestore} db - Firestore instance
+ * @param {string} clinicId - ID of the clinic whose patients to retrieve
+ * @param {Object} options - Optional parameters for pagination
+ * @param {number} options.limit - Maximum number of profiles to return
+ * @param {string} options.startAfter - The ID of the document to start after (for pagination)
+ * @returns {Promise<PatientProfile[]>} A promise resolving to an array of patient profiles
+ */
+export const getPatientsByClinicUtil = async (
+  db: Firestore,
+  clinicId: string,
+  options?: { limit?: number; startAfter?: string }
+): Promise<PatientProfile[]> => {
+  try {
+    console.log(
+      `[getPatientsByClinicUtil] Fetching patients for clinic ID: ${clinicId} with options:`,
+      options
+    );
+
+    const patientsCollection = collection(db, PATIENTS_COLLECTION);
+    const constraints: QueryConstraint[] = [
+      where("clinicIds", "array-contains", clinicId),
+    ];
+
+    let q = query(patientsCollection, ...constraints);
+
+    // Apply pagination if needed
+    if (options?.limit) {
+      q = query(q, limit(options.limit));
+    }
+
+    // If startAfter is provided, get that document and use it for pagination
+    if (options?.startAfter) {
+      const startAfterDoc = await getDoc(
+        doc(db, PATIENTS_COLLECTION, options.startAfter)
+      );
+      if (startAfterDoc.exists()) {
+        q = query(q, startAfter(startAfterDoc));
+      }
+    }
+
+    const patientsSnapshot = await getDocs(q);
+
+    const patients: PatientProfile[] = [];
+    patientsSnapshot.forEach((doc) => {
+      patients.push(doc.data() as PatientProfile);
+    });
+
+    console.log(
+      `[getPatientsByClinicUtil] Found ${patients.length} patients for clinic ID: ${clinicId}`
+    );
+    return patients;
+  } catch (error) {
+    console.error(
+      `[getPatientsByClinicUtil] Error fetching patients for clinic:`,
+      error
+    );
+    throw new Error(
+      `Failed to retrieve patients for clinic: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};