@blackcode_sa/metaestetics-api 1.7.22 → 1.7.24

package/src/services/clinic/practitioner-invite.service.ts

@@ -0,0 +1,519 @@
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  setDoc,
+  deleteDoc,
+  Timestamp,
+  serverTimestamp,
+  QueryConstraint,
+  orderBy,
+  limit,
+  and,
+  or,
+} from "firebase/firestore";
+import { BaseService } from "../base.service";
+import {
+  PractitionerInvite,
+  CreatePractitionerInviteData,
+  UpdatePractitionerInviteData,
+  PractitionerInviteFilters,
+  PractitionerInviteStatus,
+  PRACTITIONER_INVITES_COLLECTION,
+} from "../../types/clinic/practitioner-invite.types";
+import { ClinicInfo, PractitionerProfileInfo } from "../../types/profile";
+import {
+  PRACTITIONERS_COLLECTION,
+  Practitioner,
+} from "../../types/practitioner";
+import { CLINICS_COLLECTION, Clinic } from "../../types/clinic";
+import { Auth } from "firebase/auth";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+
+export class PractitionerInviteService extends BaseService {
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+  }
+
+  /**
+   * Creates a new practitioner invite
+   * @param practitionerId - Practitioner ID
+   * @param clinicId - Clinic ID
+   * @param proposedWorkingHours - Proposed working hours
+   * @param invitedBy - Admin ID who creates the invite
+   * @param message - Optional message
+   * @returns Created invite
+   */
+  async createInviteAdmin(
+    practitionerId: string,
+    clinicId: string,
+    proposedWorkingHours: any,
+    invitedBy: string,
+    message?: string
+  ): Promise<PractitionerInvite> {
+    try {
+      const inviteId = this.generateId();
+
+      // Fetch practitioner and clinic information
+      const [practitioner, clinic] = await Promise.all([
+        this.getPractitionerById(practitionerId),
+        this.getClinicById(clinicId),
+      ]);
+
+      if (!practitioner) {
+        throw new Error(`Practitioner with ID ${practitionerId} not found`);
+      }
+
+      if (!clinic) {
+        throw new Error(`Clinic with ID ${clinicId} not found`);
+      }
+
+      // Check if there's already a pending invite for this practitioner-clinic pair
+      const existingInvite = await this.findExistingInvite(
+        practitionerId,
+        clinicId
+      );
+      if (
+        existingInvite &&
+        existingInvite.status === PractitionerInviteStatus.PENDING
+      ) {
+        throw new Error(
+          "There's already a pending invite for this practitioner at this clinic"
+        );
+      }
+
+      // Build practitioner info using existing aggregation type
+      const practitionerInfo: PractitionerProfileInfo = {
+        id: practitioner.id,
+        practitionerPhoto:
+          typeof practitioner.basicInfo.profileImageUrl === "string"
+            ? practitioner.basicInfo.profileImageUrl
+            : null,
+        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+        email: practitioner.basicInfo.email,
+        phone: practitioner.basicInfo.phoneNumber || null,
+        certification: practitioner.certification,
+      };
+
+      // Build clinic info using existing aggregation type
+      const clinicInfo: ClinicInfo = {
+        id: clinic.id,
+        featuredPhoto:
+          typeof clinic.coverPhoto === "string" ? clinic.coverPhoto : "",
+        name: clinic.name,
+        description: clinic.description || null,
+        location: clinic.location,
+        contactInfo: clinic.contactInfo,
+      };
+
+      const inviteData: CreatePractitionerInviteData = {
+        practitionerId,
+        clinicId,
+        practitionerInfo,
+        clinicInfo,
+        proposedWorkingHours,
+        invitedBy,
+        message: message || null,
+        status: PractitionerInviteStatus.PENDING,
+      };
+
+      const now = Timestamp.now();
+      const invite: PractitionerInvite = {
+        id: inviteId,
+        ...inviteData,
+        status: PractitionerInviteStatus.PENDING,
+        createdAt: now,
+        updatedAt: now,
+        acceptedAt: null,
+        rejectedAt: null,
+        cancelledAt: null,
+      };
+
+      const docRef = doc(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await setDoc(docRef, invite);
+
+      return invite;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error creating invite:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets all invites for a specific doctor/practitioner
+   * @param practitionerId - Practitioner ID
+   * @param statusFilter - Optional status filter
+   * @returns Array of invites
+   */
+  async getAllInvitesDoctor(
+    practitionerId: string,
+    statusFilter?: PractitionerInviteStatus[]
+  ): Promise<PractitionerInvite[]> {
+    try {
+      const constraints: QueryConstraint[] = [
+        where("practitionerId", "==", practitionerId),
+        orderBy("createdAt", "desc"),
+      ];
+
+      if (statusFilter && statusFilter.length > 0) {
+        constraints.push(where("status", "in", statusFilter));
+      }
+
+      const q = query(
+        collection(this.db, PRACTITIONER_INVITES_COLLECTION),
+        ...constraints
+      );
+
+      const querySnapshot = await getDocs(q);
+      return querySnapshot.docs.map((doc) => doc.data() as PractitionerInvite);
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error getting doctor invites:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets all invites for a specific clinic
+   * @param clinicId - Clinic ID
+   * @param statusFilter - Optional status filter
+   * @returns Array of invites
+   */
+  async getAllInvitesClinic(
+    clinicId: string,
+    statusFilter?: PractitionerInviteStatus[]
+  ): Promise<PractitionerInvite[]> {
+    try {
+      const constraints: QueryConstraint[] = [
+        where("clinicId", "==", clinicId),
+        orderBy("createdAt", "desc"),
+      ];
+
+      if (statusFilter && statusFilter.length > 0) {
+        constraints.push(where("status", "in", statusFilter));
+      }
+
+      const q = query(
+        collection(this.db, PRACTITIONER_INVITES_COLLECTION),
+        ...constraints
+      );
+
+      const querySnapshot = await getDocs(q);
+      return querySnapshot.docs.map((doc) => doc.data() as PractitionerInvite);
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error getting clinic invites:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Doctor accepts an invite
+   * @param inviteId - Invite ID
+   * @returns Updated invite
+   */
+  async acceptInviteDoctor(inviteId: string): Promise<PractitionerInvite> {
+    try {
+      const invite = await this.getInviteById(inviteId);
+      if (!invite) {
+        throw new Error(`Invite with ID ${inviteId} not found`);
+      }
+
+      if (invite.status !== PractitionerInviteStatus.PENDING) {
+        throw new Error("Only pending invites can be accepted");
+      }
+
+      const updateData = {
+        status: PractitionerInviteStatus.ACCEPTED,
+        acceptedAt: Timestamp.now(),
+        updatedAt: serverTimestamp(),
+      };
+
+      const docRef = doc(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await updateDoc(docRef, updateData);
+
+      // Return updated invite
+      return (await this.getInviteById(inviteId)) as PractitionerInvite;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error accepting invite:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Doctor rejects an invite
+   * @param inviteId - Invite ID
+   * @param rejectionReason - Optional reason for rejection
+   * @returns Updated invite
+   */
+  async rejectInviteDoctor(
+    inviteId: string,
+    rejectionReason?: string
+  ): Promise<PractitionerInvite> {
+    try {
+      const invite = await this.getInviteById(inviteId);
+      if (!invite) {
+        throw new Error(`Invite with ID ${inviteId} not found`);
+      }
+
+      if (invite.status !== PractitionerInviteStatus.PENDING) {
+        throw new Error("Only pending invites can be rejected");
+      }
+
+      const updateData = {
+        status: PractitionerInviteStatus.REJECTED,
+        rejectionReason: rejectionReason || null,
+        rejectedAt: Timestamp.now(),
+        updatedAt: serverTimestamp(),
+      };
+
+      const docRef = doc(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await updateDoc(docRef, updateData);
+
+      // Return updated invite
+      return (await this.getInviteById(inviteId)) as PractitionerInvite;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error rejecting invite:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Admin cancels an invite
+   * @param inviteId - Invite ID
+   * @param cancelReason - Optional reason for cancellation
+   * @returns Updated invite
+   */
+  async cancelInviteAdmin(
+    inviteId: string,
+    cancelReason?: string
+  ): Promise<PractitionerInvite> {
+    try {
+      const invite = await this.getInviteById(inviteId);
+      if (!invite) {
+        throw new Error(`Invite with ID ${inviteId} not found`);
+      }
+
+      if (invite.status !== PractitionerInviteStatus.PENDING) {
+        throw new Error("Only pending invites can be cancelled");
+      }
+
+      const updateData = {
+        status: PractitionerInviteStatus.CANCELLED,
+        cancelReason: cancelReason || null,
+        cancelledAt: Timestamp.now(),
+        updatedAt: serverTimestamp(),
+      };
+
+      const docRef = doc(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await updateDoc(docRef, updateData);
+
+      // Return updated invite
+      return (await this.getInviteById(inviteId)) as PractitionerInvite;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error cancelling invite:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets an invite by ID
+   * @param inviteId - Invite ID
+   * @returns Invite or null if not found
+   */
+  async getInviteById(inviteId: string): Promise<PractitionerInvite | null> {
+    try {
+      const docRef = doc(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      const docSnap = await getDoc(docRef);
+
+      if (docSnap.exists()) {
+        return docSnap.data() as PractitionerInvite;
+      }
+      return null;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error getting invite by ID:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets invites with advanced filtering options
+   * @param filters - Filter options
+   * @returns Array of filtered invites
+   */
+  async getInvitesWithFilters(
+    filters: PractitionerInviteFilters
+  ): Promise<PractitionerInvite[]> {
+    try {
+      const constraints: QueryConstraint[] = [];
+
+      // Add filters
+      if (filters.practitionerId) {
+        constraints.push(where("practitionerId", "==", filters.practitionerId));
+      }
+      if (filters.clinicId) {
+        constraints.push(where("clinicId", "==", filters.clinicId));
+      }
+      if (filters.invitedBy) {
+        constraints.push(where("invitedBy", "==", filters.invitedBy));
+      }
+      if (filters.status && filters.status.length > 0) {
+        constraints.push(where("status", "in", filters.status));
+      }
+
+      // Add ordering
+      const orderField = filters.orderBy || "createdAt";
+      const orderDirection = filters.orderDirection || "desc";
+      constraints.push(orderBy(orderField, orderDirection));
+
+      // Add limit
+      if (filters.limit) {
+        constraints.push(limit(filters.limit));
+      }
+
+      const q = query(
+        collection(this.db, PRACTITIONER_INVITES_COLLECTION),
+        ...constraints
+      );
+
+      const querySnapshot = await getDocs(q);
+      let invites = querySnapshot.docs.map(
+        (doc) => doc.data() as PractitionerInvite
+      );
+
+      // Apply date filters (client-side filtering due to Firestore limitations)
+      if (filters.fromDate) {
+        invites = invites.filter(
+          (invite) => invite.createdAt >= filters.fromDate!
+        );
+      }
+      if (filters.toDate) {
+        invites = invites.filter(
+          (invite) => invite.createdAt <= filters.toDate!
+        );
+      }
+
+      return invites;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error getting invites with filters:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Deletes an invite (admin only)
+   * @param inviteId - Invite ID
+   */
+  async deleteInvite(inviteId: string): Promise<void> {
+    try {
+      const docRef = doc(this.db, PRACTITIONER_INVITES_COLLECTION, inviteId);
+      await deleteDoc(docRef);
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error deleting invite:",
+        error
+      );
+      throw error;
+    }
+  }
+
+  // Private helper methods
+
+  /**
+   * Gets practitioner by ID
+   * @param practitionerId - Practitioner ID
+   * @returns Practitioner or null
+   */
+  private async getPractitionerById(
+    practitionerId: string
+  ): Promise<Practitioner | null> {
+    try {
+      const docRef = doc(this.db, PRACTITIONERS_COLLECTION, practitionerId);
+      const docSnap = await getDoc(docRef);
+      return docSnap.exists() ? (docSnap.data() as Practitioner) : null;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error getting practitioner:",
+        error
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Gets clinic by ID
+   * @param clinicId - Clinic ID
+   * @returns Clinic or null
+   */
+  private async getClinicById(clinicId: string): Promise<Clinic | null> {
+    try {
+      const docRef = doc(this.db, CLINICS_COLLECTION, clinicId);
+      const docSnap = await getDoc(docRef);
+      return docSnap.exists() ? (docSnap.data() as Clinic) : null;
+    } catch (error) {
+      console.error("[PractitionerInviteService] Error getting clinic:", error);
+      return null;
+    }
+  }
+
+  /**
+   * Finds existing invite between practitioner and clinic
+   * @param practitionerId - Practitioner ID
+   * @param clinicId - Clinic ID
+   * @returns Existing invite or null
+   */
+  private async findExistingInvite(
+    practitionerId: string,
+    clinicId: string
+  ): Promise<PractitionerInvite | null> {
+    try {
+      const q = query(
+        collection(this.db, PRACTITIONER_INVITES_COLLECTION),
+        where("practitionerId", "==", practitionerId),
+        where("clinicId", "==", clinicId),
+        orderBy("createdAt", "desc"),
+        limit(1)
+      );
+
+      const querySnapshot = await getDocs(q);
+      if (querySnapshot.empty) {
+        return null;
+      }
+
+      return querySnapshot.docs[0].data() as PractitionerInvite;
+    } catch (error) {
+      console.error(
+        "[PractitionerInviteService] Error finding existing invite:",
+        error
+      );
+      return null;
+    }
+  }
+}

package/src/types/clinic/index.ts

@@ -400,3 +400,6 @@ export interface ClinicBranchSetupData {
 export interface ClinicTags {
   tags: ClinicTag[];
 }
+
+// Export practitioner invite types
+export * from "./practitioner-invite.types";

package/src/types/clinic/practitioner-invite.types.ts

@@ -0,0 +1,91 @@
+import { Timestamp, FieldValue } from "firebase/firestore";
+import { ClinicInfo, PractitionerProfileInfo } from "../profile";
+
+export const PRACTITIONER_INVITES_COLLECTION = "practitioner-invites";
+
+/**
+ * Enum for practitioner invite status
+ */
+export enum PractitionerInviteStatus {
+  PENDING = "pending",
+  ACCEPTED = "accepted",
+  REJECTED = "rejected",
+  CANCELLED = "cancelled",
+}
+
+/**
+ * Interface for proposed working hours in practitioner invite
+ */
+export interface ProposedWorkingHours {
+  monday: { start: string; end: string } | null;
+  tuesday: { start: string; end: string } | null;
+  wednesday: { start: string; end: string } | null;
+  thursday: { start: string; end: string } | null;
+  friday: { start: string; end: string } | null;
+  saturday: { start: string; end: string } | null;
+  sunday: { start: string; end: string } | null;
+}
+
+/**
+ * Main interface for practitioner invite
+ */
+export interface PractitionerInvite {
+  id: string;
+  practitionerId: string;
+  clinicId: string;
+  practitionerInfo: PractitionerProfileInfo;
+  clinicInfo: ClinicInfo;
+  proposedWorkingHours: ProposedWorkingHours;
+  status: PractitionerInviteStatus;
+  invitedBy: string; // Admin ID who created the invite
+  message?: string | null; // Optional message from clinic to practitioner
+  rejectionReason?: string | null; // Optional reason for rejection
+  cancelReason?: string | null; // Optional reason for cancellation
+  createdAt: Timestamp;
+  updatedAt: Timestamp;
+  acceptedAt?: Timestamp | null;
+  rejectedAt?: Timestamp | null;
+  cancelledAt?: Timestamp | null;
+}
+
+/**
+ * Interface for creating a practitioner invite
+ */
+export interface CreatePractitionerInviteData {
+  practitionerId: string;
+  clinicId: string;
+  practitionerInfo: PractitionerProfileInfo;
+  clinicInfo: ClinicInfo;
+  proposedWorkingHours: ProposedWorkingHours;
+  invitedBy: string;
+  message?: string | null;
+  status?: PractitionerInviteStatus;
+}
+
+/**
+ * Interface for updating a practitioner invite
+ */
+export interface UpdatePractitionerInviteData {
+  status?: PractitionerInviteStatus;
+  rejectionReason?: string | null;
+  cancelReason?: string | null;
+  updatedAt?: FieldValue;
+  acceptedAt?: Timestamp | null;
+  rejectedAt?: Timestamp | null;
+  cancelledAt?: Timestamp | null;
+}
+
+/**
+ * Interface for filters when getting invites
+ */
+export interface PractitionerInviteFilters {
+  status?: PractitionerInviteStatus[];
+  practitionerId?: string;
+  clinicId?: string;
+  invitedBy?: string;
+  fromDate?: Timestamp;
+  toDate?: Timestamp;
+  limit?: number;
+  orderBy?: "createdAt" | "updatedAt";
+  orderDirection?: "asc" | "desc";
+}

package/src/validations/appointment.schema.ts

@@ -360,3 +360,36 @@ export const searchAppointmentsSchema = z
       path: ["endDate"],
     }
   );
+
+/**
+ * Schema for validating appointment reschedule data
+ */
+export const rescheduleAppointmentSchema = z.object({
+  appointmentId: z
+    .string()
+    .min(MIN_STRING_LENGTH, "Appointment ID is required"),
+  newStartTime: z
+    .any()
+    .refine(
+      (val) =>
+        val instanceof Date ||
+        val?._seconds !== undefined ||
+        val?.seconds !== undefined ||
+        typeof val === "number" ||
+        typeof val === "string" ||
+        (val && typeof val.toMillis === "function"),
+      "New start time must be a valid timestamp, Date object, number, or string"
+    ),
+  newEndTime: z
+    .any()
+    .refine(
+      (val) =>
+        val instanceof Date ||
+        val?._seconds !== undefined ||
+        val?.seconds !== undefined ||
+        typeof val === "number" ||
+        typeof val === "string" ||
+        (val && typeof val.toMillis === "function"),
+      "New end time must be a valid timestamp, Date object, number, or string"
+    ),
+});