@blackcode_sa/metaestetics-api 1.14.78 → 1.15.2

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

@@ -103,8 +103,40 @@ import {
   AestheticAnalysis,
   CreateAestheticAnalysisData,
   UpdateAestheticAnalysisData,
+  SkinQualityAssessment,
+  CreateSkinQualityAssessmentData,
+  UpdateSkinQualityAssessmentData,
+  BodyAssessment,
+  CreateBodyAssessmentData,
+  UpdateBodyAssessmentData,
+  HairScalpAssessment,
+  CreateHairScalpAssessmentData,
+  UpdateHairScalpAssessmentData,
+  PreSurgicalAssessment,
+  CreatePreSurgicalAssessmentData,
+  UpdatePreSurgicalAssessmentData,
 } from '../../types/patient';
 
+import {
+  getSkinQualityAssessmentUtil,
+  createOrUpdateSkinQualityAssessmentUtil,
+} from './utils/skin-quality-assessment.utils';
+
+import {
+  getBodyAssessmentUtil,
+  createOrUpdateBodyAssessmentUtil,
+} from './utils/body-assessment.utils';
+
+import {
+  getHairScalpAssessmentUtil,
+  createOrUpdateHairScalpAssessmentUtil,
+} from './utils/hair-scalp-assessment.utils';
+
+import {
+  getPreSurgicalAssessmentUtil,
+  createOrUpdatePreSurgicalAssessmentUtil,
+} from './utils/pre-surgical-assessment.utils';
+
 import { CreatePatientTokenData, PatientToken } from '../../types/patient/token.types';
 
 export class PatientService extends BaseService {
@@ -882,4 +914,108 @@ export class PatientService extends BaseService {
       true
     );
   }
+
+  // Skin Quality Assessment methods
+  async getSkinQualityAssessment(patientId: string): Promise<SkinQualityAssessment | null> {
+    const currentUser = await this.getCurrentUser();
+    return getSkinQualityAssessmentUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createSkinQualityAssessment(
+    patientId: string,
+    data: CreateSkinQualityAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateSkinQualityAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, false
+    );
+  }
+
+  async updateSkinQualityAssessment(
+    patientId: string,
+    data: UpdateSkinQualityAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateSkinQualityAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, true
+    );
+  }
+
+  // Body Assessment methods
+  async getBodyAssessment(patientId: string): Promise<BodyAssessment | null> {
+    const currentUser = await this.getCurrentUser();
+    return getBodyAssessmentUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createBodyAssessment(
+    patientId: string,
+    data: CreateBodyAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateBodyAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, false
+    );
+  }
+
+  async updateBodyAssessment(
+    patientId: string,
+    data: UpdateBodyAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateBodyAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, true
+    );
+  }
+
+  // Hair & Scalp Assessment methods
+  async getHairScalpAssessment(patientId: string): Promise<HairScalpAssessment | null> {
+    const currentUser = await this.getCurrentUser();
+    return getHairScalpAssessmentUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createHairScalpAssessment(
+    patientId: string,
+    data: CreateHairScalpAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateHairScalpAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, false
+    );
+  }
+
+  async updateHairScalpAssessment(
+    patientId: string,
+    data: UpdateHairScalpAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdateHairScalpAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, true
+    );
+  }
+
+  // Pre-Surgical Assessment methods
+  async getPreSurgicalAssessment(patientId: string): Promise<PreSurgicalAssessment | null> {
+    const currentUser = await this.getCurrentUser();
+    return getPreSurgicalAssessmentUtil(this.db, patientId, currentUser.uid, currentUser.roles);
+  }
+
+  async createPreSurgicalAssessment(
+    patientId: string,
+    data: CreatePreSurgicalAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdatePreSurgicalAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, false
+    );
+  }
+
+  async updatePreSurgicalAssessment(
+    patientId: string,
+    data: UpdatePreSurgicalAssessmentData
+  ): Promise<void> {
+    const currentUser = await this.getCurrentUser();
+    return createOrUpdatePreSurgicalAssessmentUtil(
+      this.db, patientId, data, currentUser.uid, currentUser.roles, true
+    );
+  }
 }

package/src/services/patient/utils/body-assessment.utils.ts

@@ -0,0 +1,159 @@
+import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
+import {
+  BodyAssessment,
+  CreateBodyAssessmentData,
+  UpdateBodyAssessmentData,
+  BODY_ASSESSMENT_COLLECTION,
+  PATIENTS_COLLECTION,
+  BodyAssessmentStatus,
+} from '../../../types/patient';
+import { UserRole } from '../../../types';
+import {
+  createBodyAssessmentSchema,
+  updateBodyAssessmentSchema,
+  bodyAssessmentSchema,
+} from '../../../validations/patient/body-assessment.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 getBodyAssessmentDocRef = (db: Firestore, patientId: string) => {
+  return doc(db, PATIENTS_COLLECTION, patientId, BODY_ASSESSMENT_COLLECTION, patientId);
+};
+
+const checkBodyAssessmentAccessUtil = 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 body assessment.',
+    'AUTH/UNAUTHORIZED_ACCESS',
+    403
+  );
+};
+
+export const calculateBodyAssessmentCompletionPercentage = (data: Partial<BodyAssessment>): number => {
+  let completed = 0;
+  const total = 4;
+
+  if (data.selectedZones && data.selectedZones.length > 0) completed++;
+  if (data.zoneAssessments && data.zoneAssessments.length > 0) completed++;
+  if (data.composition && (data.composition.bmi || data.composition.bodyFatPercentage || data.composition.waistHipRatio)) completed++;
+  if ((data.measurements && data.measurements.waist) || (data.symmetry && data.symmetry.overallSymmetry)) completed++;
+
+  return Math.round((completed / total) * 100);
+};
+
+export const determineBodyAssessmentStatus = (completionPercentage: number): BodyAssessmentStatus => {
+  if (completionPercentage < 50) return 'incomplete';
+  if (completionPercentage >= 50) return 'ready_for_planning';
+  return 'incomplete';
+};
+
+export const getBodyAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<BodyAssessment | null> => {
+  await checkBodyAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const docRef = getBodyAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  if (!snapshot.exists()) {
+    return null;
+  }
+
+  const data = snapshot.data();
+  return bodyAssessmentSchema.parse({
+    ...data,
+    id: patientId,
+  });
+};
+
+export const createOrUpdateBodyAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  data: CreateBodyAssessmentData | UpdateBodyAssessmentData,
+  requesterId: string,
+  requesterRoles: UserRole[],
+  isUpdate: boolean = false
+): Promise<void> => {
+  await checkBodyAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const validatedData = isUpdate
+    ? updateBodyAssessmentSchema.parse(data)
+    : createBodyAssessmentSchema.parse(data);
+
+  const docRef = getBodyAssessmentDocRef(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 = calculateBodyAssessmentCompletionPercentage(mergedData);
+  const status = determineBodyAssessmentStatus(completionPercentage);
+
+  if (!snapshot.exists()) {
+    await setDoc(docRef, {
+      id: patientId,
+      patientId,
+      selectedZones: [],
+      zoneAssessments: [],
+      ...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/docs.utils.ts

@@ -120,7 +120,7 @@ export const initSensitiveInfoDocIfNotExists = async (
         )
       );
 
-      await createSensitiveInfoUtil(db, defaultSensitiveInfo, userRef);
+      await createSensitiveInfoUtil(db, defaultSensitiveInfo, userRef, []);
 
       // Verify document was created
       const verifyDoc = await getDoc(sensitiveInfoRef);

package/src/services/patient/utils/hair-scalp-assessment.utils.ts

@@ -0,0 +1,158 @@
+import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
+import {
+  HairScalpAssessment,
+  CreateHairScalpAssessmentData,
+  UpdateHairScalpAssessmentData,
+  HAIR_SCALP_ASSESSMENT_COLLECTION,
+  PATIENTS_COLLECTION,
+  HairScalpAssessmentStatus,
+} from '../../../types/patient';
+import { UserRole } from '../../../types';
+import {
+  createHairScalpAssessmentSchema,
+  updateHairScalpAssessmentSchema,
+  hairScalpAssessmentSchema,
+} from '../../../validations/patient/hair-scalp-assessment.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 getHairScalpAssessmentDocRef = (db: Firestore, patientId: string) => {
+  return doc(db, PATIENTS_COLLECTION, patientId, HAIR_SCALP_ASSESSMENT_COLLECTION, patientId);
+};
+
+const checkHairScalpAssessmentAccessUtil = 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 hair & scalp assessment.',
+    'AUTH/UNAUTHORIZED_ACCESS',
+    403
+  );
+};
+
+export const calculateHairScalpCompletionPercentage = (data: Partial<HairScalpAssessment>): number => {
+  let completed = 0;
+  const total = 4;
+
+  if (data.hairLossPattern && data.hairLossPattern.type) completed++;
+  if (data.hairCharacteristics && data.hairCharacteristics.type) completed++;
+  if (data.scalpCondition) completed++;
+  if (data.zoneAssessments && data.zoneAssessments.length > 0) completed++;
+
+  return Math.round((completed / total) * 100);
+};
+
+export const determineHairScalpStatus = (completionPercentage: number): HairScalpAssessmentStatus => {
+  if (completionPercentage < 50) return 'incomplete';
+  if (completionPercentage >= 50) return 'ready_for_planning';
+  return 'incomplete';
+};
+
+export const getHairScalpAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<HairScalpAssessment | null> => {
+  await checkHairScalpAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const docRef = getHairScalpAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  if (!snapshot.exists()) {
+    return null;
+  }
+
+  const data = snapshot.data();
+  return hairScalpAssessmentSchema.parse({
+    ...data,
+    id: patientId,
+  });
+};
+
+export const createOrUpdateHairScalpAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  data: CreateHairScalpAssessmentData | UpdateHairScalpAssessmentData,
+  requesterId: string,
+  requesterRoles: UserRole[],
+  isUpdate: boolean = false
+): Promise<void> => {
+  await checkHairScalpAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const validatedData = isUpdate
+    ? updateHairScalpAssessmentSchema.parse(data)
+    : createHairScalpAssessmentSchema.parse(data);
+
+  const docRef = getHairScalpAssessmentDocRef(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 = calculateHairScalpCompletionPercentage(mergedData);
+  const status = determineHairScalpStatus(completionPercentage);
+
+  if (!snapshot.exists()) {
+    await setDoc(docRef, {
+      id: patientId,
+      patientId,
+      zoneAssessments: [],
+      ...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/pre-surgical-assessment.utils.ts

@@ -0,0 +1,161 @@
+import { getDoc, updateDoc, setDoc, serverTimestamp, Firestore, doc } from 'firebase/firestore';
+import {
+  PreSurgicalAssessment,
+  CreatePreSurgicalAssessmentData,
+  UpdatePreSurgicalAssessmentData,
+  PRE_SURGICAL_ASSESSMENT_COLLECTION,
+  PATIENTS_COLLECTION,
+  PreSurgicalAssessmentStatus,
+} from '../../../types/patient';
+import { UserRole } from '../../../types';
+import {
+  createPreSurgicalAssessmentSchema,
+  updatePreSurgicalAssessmentSchema,
+  preSurgicalAssessmentSchema,
+} from '../../../validations/patient/pre-surgical-assessment.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 getPreSurgicalAssessmentDocRef = (db: Firestore, patientId: string) => {
+  return doc(db, PATIENTS_COLLECTION, patientId, PRE_SURGICAL_ASSESSMENT_COLLECTION, patientId);
+};
+
+const checkPreSurgicalAssessmentAccessUtil = 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 pre-surgical assessment.',
+    'AUTH/UNAUTHORIZED_ACCESS',
+    403
+  );
+};
+
+export const calculatePreSurgicalCompletionPercentage = (data: Partial<PreSurgicalAssessment>): number => {
+  let completed = 0;
+  const total = 5;
+
+  if (data.asaClassification) completed++;
+  if (data.anesthesiaHistory) completed++;
+  if (data.bleedingRisk) completed++;
+  if (data.surgicalSiteAssessments && data.surgicalSiteAssessments.length > 0) completed++;
+  if ((data.labResults && data.labResults.length > 0) || data.clearance === 'obtained') completed++;
+
+  return Math.round((completed / total) * 100);
+};
+
+export const determinePreSurgicalStatus = (completionPercentage: number): PreSurgicalAssessmentStatus => {
+  if (completionPercentage < 40) return 'incomplete';
+  if (completionPercentage >= 40) return 'ready_for_planning';
+  return 'incomplete';
+};
+
+export const getPreSurgicalAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  requesterId: string,
+  requesterRoles: UserRole[]
+): Promise<PreSurgicalAssessment | null> => {
+  await checkPreSurgicalAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const docRef = getPreSurgicalAssessmentDocRef(db, patientId);
+  const snapshot = await getDoc(docRef);
+
+  if (!snapshot.exists()) {
+    return null;
+  }
+
+  const data = snapshot.data();
+  return preSurgicalAssessmentSchema.parse({
+    ...data,
+    id: patientId,
+  });
+};
+
+export const createOrUpdatePreSurgicalAssessmentUtil = async (
+  db: Firestore,
+  patientId: string,
+  data: CreatePreSurgicalAssessmentData | UpdatePreSurgicalAssessmentData,
+  requesterId: string,
+  requesterRoles: UserRole[],
+  isUpdate: boolean = false
+): Promise<void> => {
+  await checkPreSurgicalAssessmentAccessUtil(db, patientId, requesterId, requesterRoles);
+
+  const validatedData = isUpdate
+    ? updatePreSurgicalAssessmentSchema.parse(data)
+    : createPreSurgicalAssessmentSchema.parse(data);
+
+  const docRef = getPreSurgicalAssessmentDocRef(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 = calculatePreSurgicalCompletionPercentage(mergedData);
+  const status = determinePreSurgicalStatus(completionPercentage);
+
+  if (!snapshot.exists()) {
+    await setDoc(docRef, {
+      id: patientId,
+      patientId,
+      surgicalSiteAssessments: [],
+      labResults: [],
+      clearance: 'not_required',
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+  } else {
+    await updateDoc(docRef, {
+      ...validatedData,
+      completionPercentage,
+      status,
+      lastUpdatedBy: requesterId,
+      lastUpdatedByRole: requesterRole,
+      updatedAt: serverTimestamp(),
+    });
+  }
+};