@blackcode_sa/metaestetics-api 1.13.4 → 1.13.6

package/src/admin/aggregation/clinic/clinic.aggregation.service.ts

@@ -5,7 +5,7 @@ import {
   Practitioner,
 } from "../../../types/practitioner"; // Corrected path
 import { PROCEDURES_COLLECTION } from "../../../types/procedure"; // Added procedure collection
-import { CLINIC_GROUPS_COLLECTION, ClinicGroup } from "../../../types/clinic"; // Added clinic group collection
+import { CLINIC_GROUPS_COLLECTION, ClinicGroup, CLINICS_COLLECTION } from "../../../types/clinic"; // Added clinic group collection
 import { ClinicLocation } from "../../../types/clinic"; // Added ClinicLocation type
 import { CALENDAR_COLLECTION } from "../../../types/calendar"; // Added calendar collection
 import { PATIENTS_COLLECTION } from "../../../types/patient"; // Added patient collection
@@ -430,10 +430,12 @@ export class ClinicAggregationService {
    * Removes clinic from practitioners when a clinic is deleted.
    * @param practitionerIds IDs of practitioners associated with the clinic.
    * @param clinicId The ID of the deleted clinic.
+   * @param checkAndDeactivateDoctors If true, checks if doctors have remaining active clinics and deactivates them if not.
    */
   async removeClinicFromPractitioners(
     practitionerIds: string[],
-    clinicId: string
+    clinicId: string,
+    checkAndDeactivateDoctors: boolean = false
   ): Promise<void> {
     if (!practitionerIds || practitionerIds.length === 0) {
       console.log(
@@ -443,6 +445,7 @@ export class ClinicAggregationService {
     }
 
     const batch = this.db.batch();
+    const practitionersToCheck: string[] = [];
 
     console.log(
       `[ClinicAggregationService] Starting batch removal of Clinic (ID: ${clinicId}) from ${practitionerIds.length} practitioners.`
@@ -474,6 +477,11 @@ export class ClinicAggregationService {
           clinicsInfo: filteredClinicsInfo,
           updatedAt: admin.firestore.FieldValue.serverTimestamp(),
         });
+
+        // If we need to check for remaining active clinics, collect practitioner IDs
+        if (checkAndDeactivateDoctors) {
+          practitionersToCheck.push(practitionerId);
+        }
       }
     }
 
@@ -482,6 +490,13 @@ export class ClinicAggregationService {
       console.log(
         `[ClinicAggregationService] Successfully removed Clinic (ID: ${clinicId}) from ${practitionerIds.length} practitioners.`
       );
+
+      // Check and deactivate doctors with no remaining active clinics
+      if (checkAndDeactivateDoctors && practitionersToCheck.length > 0) {
+        await this.checkAndDeactivateDoctorsWithNoActiveClinics(
+          practitionersToCheck
+        );
+      }
     } catch (error) {
       console.error(
         `[ClinicAggregationService] Error committing batch removal for Clinic (ID: ${clinicId}) from practitioners:`,
@@ -491,6 +506,194 @@ export class ClinicAggregationService {
     }
   }
 
+  /**
+   * Checks if practitioners have any remaining active clinics and deactivates them if not.
+   * @param practitionerIds IDs of practitioners to check
+   */
+  async checkAndDeactivateDoctorsWithNoActiveClinics(
+    practitionerIds: string[]
+  ): Promise<void> {
+    if (!practitionerIds || practitionerIds.length === 0) {
+      return;
+    }
+
+    console.log(
+      `[ClinicAggregationService] Checking ${practitionerIds.length} practitioners for remaining active clinics.`
+    );
+
+    const batch = this.db.batch();
+    let deactivationCount = 0;
+
+    for (const practitionerId of practitionerIds) {
+      const practitionerRef = this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(practitionerId);
+      const practitionerDoc = await practitionerRef.get();
+
+      if (!practitionerDoc.exists) {
+        continue;
+      }
+
+      const practitionerData = practitionerDoc.data() as Practitioner;
+      const clinicIds = practitionerData?.clinics || [];
+
+      if (clinicIds.length === 0) {
+        // No clinics remaining, deactivate the doctor
+        console.log(
+          `[ClinicAggregationService] Practitioner ${practitionerId} has no remaining clinics. Deactivating.`
+        );
+        batch.update(practitionerRef, {
+          isActive: false,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+        deactivationCount++;
+      } else {
+        // Check if any of the remaining clinics are active
+        const clinicRefs = clinicIds.map((id: string) =>
+          this.db.collection(CLINICS_COLLECTION).doc(id)
+        );
+        const clinicDocs = await Promise.all(
+          clinicRefs.map((ref) => ref.get())
+        );
+
+        const hasActiveClinic = clinicDocs.some(
+          (doc) => doc.exists && (doc.data() as any)?.isActive === true
+        );
+
+        if (!hasActiveClinic) {
+          // No active clinics remaining, deactivate the doctor
+          console.log(
+            `[ClinicAggregationService] Practitioner ${practitionerId} has no remaining active clinics. Deactivating.`
+          );
+          batch.update(practitionerRef, {
+            isActive: false,
+            updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+          });
+          deactivationCount++;
+        }
+      }
+    }
+
+    if (deactivationCount > 0) {
+      try {
+        await batch.commit();
+        console.log(
+          `[ClinicAggregationService] Successfully deactivated ${deactivationCount} practitioners with no remaining active clinics.`
+        );
+      } catch (error) {
+        console.error(
+          `[ClinicAggregationService] Error deactivating practitioners:`,
+          error
+        );
+        throw error;
+      }
+    } else {
+        console.log(
+          `[ClinicAggregationService] All practitioners have remaining active clinics. No deactivations needed.`
+        );
+    }
+  }
+
+  /**
+   * Checks if practitioners were deactivated because they had no active clinics,
+   * and reactivates them if this clinic was their only clinic.
+   * @param practitionerIds IDs of practitioners associated with the reactivated clinic
+   * @param clinicId ID of the reactivated clinic
+   */
+  async checkAndReactivateDoctorsForClinic(
+    practitionerIds: string[],
+    clinicId: string
+  ): Promise<void> {
+    if (!practitionerIds || practitionerIds.length === 0) {
+      return;
+    }
+
+    console.log(
+      `[ClinicAggregationService] Checking ${practitionerIds.length} practitioners for reactivation after clinic ${clinicId} was reactivated.`
+    );
+
+    const batch = this.db.batch();
+    let reactivationCount = 0;
+
+    for (const practitionerId of practitionerIds) {
+      const practitionerRef = this.db
+        .collection(PRACTITIONERS_COLLECTION)
+        .doc(practitionerId);
+      const practitionerDoc = await practitionerRef.get();
+
+      if (!practitionerDoc.exists) {
+        continue;
+      }
+
+      const practitionerData = practitionerDoc.data() as Practitioner;
+      
+      // Check if practitioner is inactive
+      if (practitionerData?.isActive === false) {
+        // Check if this clinic is in their clinics list (meaning it was their clinic)
+        const clinicIds = practitionerData?.clinics || [];
+        if (clinicIds.includes(clinicId)) {
+          // Check if they have any other active clinics
+          const otherClinicIds = clinicIds.filter((id: string) => id !== clinicId);
+          
+          if (otherClinicIds.length === 0) {
+            // This was their only clinic, reactivate them
+            console.log(
+              `[ClinicAggregationService] Practitioner ${practitionerId} was deactivated because clinic ${clinicId} was their only clinic. Reactivating.`
+            );
+            batch.update(practitionerRef, {
+              isActive: true,
+              updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+            });
+            reactivationCount++;
+          } else {
+            // Check if any other clinics are active
+            const otherClinicRefs = otherClinicIds.map((id: string) =>
+              this.db.collection(CLINICS_COLLECTION).doc(id)
+            );
+            const otherClinicDocs = await Promise.all(
+              otherClinicRefs.map((ref) => ref.get())
+            );
+
+            const hasOtherActiveClinic = otherClinicDocs.some(
+              (doc) => doc.exists && (doc.data() as any)?.isActive === true
+            );
+
+            if (!hasOtherActiveClinic) {
+              // All their other clinics are also inactive, so this clinic reactivation should reactivate them
+              console.log(
+                `[ClinicAggregationService] Practitioner ${practitionerId} has no other active clinics. Reactivating because clinic ${clinicId} was reactivated.`
+              );
+              batch.update(practitionerRef, {
+                isActive: true,
+                updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+              });
+              reactivationCount++;
+            }
+          }
+        }
+      }
+    }
+
+    if (reactivationCount > 0) {
+      try {
+        await batch.commit();
+        console.log(
+          `[ClinicAggregationService] Successfully reactivated ${reactivationCount} practitioners.`
+        );
+      } catch (error) {
+        console.error(
+          `[ClinicAggregationService] Error reactivating practitioners:`,
+          error
+        );
+        throw error;
+      }
+    } else {
+      console.log(
+        `[ClinicAggregationService] No practitioners needed reactivation.`
+      );
+    }
+  }
+
   /**
    * Inactivates all procedures associated with a deleted clinic
    * @param procedureIds IDs of procedures associated with the clinic
@@ -534,6 +737,66 @@ export class ClinicAggregationService {
     }
   }
 
+  /**
+   * Reactivates all procedures associated with a reactivated clinic
+   * Only reactivates procedures that still exist (haven't been deleted)
+   * @param procedureIds IDs of procedures associated with the clinic
+   */
+  async reactivateProceduresForClinic(procedureIds: string[]): Promise<void> {
+    if (!procedureIds || procedureIds.length === 0) {
+      console.log(
+        "[ClinicAggregationService] No procedure IDs provided for reactivation. Skipping."
+      );
+      return;
+    }
+
+    const batch = this.db.batch();
+    let reactivationCount = 0;
+
+    console.log(
+      `[ClinicAggregationService] Starting reactivation of ${procedureIds.length} procedures.`
+    );
+
+    for (const procedureId of procedureIds) {
+      const procedureRef = this.db
+        .collection(PROCEDURES_COLLECTION)
+        .doc(procedureId);
+      
+      // Check if procedure still exists (hasn't been deleted)
+      const procedureDoc = await procedureRef.get();
+      if (procedureDoc.exists) {
+        batch.update(procedureRef, {
+          isActive: true,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+        reactivationCount++;
+      } else {
+        console.log(
+          `[ClinicAggregationService] Procedure ${procedureId} no longer exists. Skipping reactivation.`
+        );
+      }
+    }
+
+    if (reactivationCount > 0) {
+      try {
+        await batch.commit();
+        console.log(
+          `[ClinicAggregationService] Successfully reactivated ${reactivationCount} procedures.`
+        );
+      } catch (error) {
+        console.error(
+          `[ClinicAggregationService] Error committing batch reactivation of procedures:`,
+          error
+        );
+        throw error;
+      }
+    } else {
+      console.log(
+        `[ClinicAggregationService] No procedures to reactivate (all may have been deleted).`
+      );
+    }
+  }
+
   /**
    * Removes clinic from clinic group when a clinic is deleted
    * @param clinicGroupId ID of the parent clinic group

package/src/types/clinic/index.ts

@@ -37,6 +37,15 @@ export interface ClinicLocation {
   tz?: string | null;
 }
 
+/**
+ * Interface for a break period during working hours
+ */
+export interface Break {
+  title?: string;
+  start: string;
+  end: string;
+}
+
 /**
  * Interface for working hours
  */
@@ -44,37 +53,37 @@ export interface WorkingHours {
   monday: {
     open: string;
     close: string;
-    breaks?: { start: string; end: string }[];
+    breaks?: Break[];
   } | null;
   tuesday: {
     open: string;
     close: string;
-    breaks?: { start: string; end: string }[];
+    breaks?: Break[];
   } | null;
   wednesday: {
     open: string;
     close: string;
-    breaks?: { start: string; end: string }[];
+    breaks?: Break[];
   } | null;
   thursday: {
     open: string;
     close: string;
-    breaks?: { start: string; end: string }[];
+    breaks?: Break[];
   } | null;
   friday: {
     open: string;
     close: string;
-    breaks?: { start: string; end: string }[];
+    breaks?: Break[];
   } | null;
   saturday: {
     open: string;
     close: string;
-    breaks?: { start: string; end: string }[];
+    breaks?: Break[];
   } | null;
   sunday: {
     open: string;
     close: string;
-    breaks?: { start: string; end: string }[];
+    breaks?: Break[];
   } | null;
 }
 

package/src/validations/clinic.schema.ts

@@ -47,6 +47,7 @@ const workingHoursTimeSchema = z.object({
   breaks: z
     .array(
       z.object({
+        title: z.string().optional(),
         start: z.string(),
         end: z.string(),
       }),