@blackcode_sa/metaestetics-api 1.6.16 → 1.6.18

package/src/admin/users/user-profile.admin.ts

@@ -0,0 +1,404 @@
+import * as admin from "firebase-admin";
+import { User, UserRole, USERS_COLLECTION } from "../../types";
+import {
+  PatientProfile,
+  PATIENTS_COLLECTION,
+  CreatePatientProfileData,
+  PatientSensitiveInfo,
+  PATIENT_SENSITIVE_INFO_COLLECTION,
+  CreatePatientSensitiveInfoData,
+  Gender,
+  PatientMedicalInfo,
+  PATIENT_MEDICAL_INFO_COLLECTION,
+} from "../../types/patient";
+
+/**
+ * @class UserProfileAdminService
+ * @description Handles user profile management operations for admin tasks
+ */
+export class UserProfileAdminService {
+  private db: admin.firestore.Firestore;
+
+  /**
+   * Constructor for UserProfileAdminService
+   * @param firestore Optional Firestore instance. If not provided, uses the default admin SDK instance.
+   */
+  constructor(firestore?: admin.firestore.Firestore) {
+    this.db = firestore || admin.firestore();
+  }
+
+  /**
+   * Creates a blank user profile with minimal information
+   * @param authUserData Basic user data from Firebase Auth
+   * @returns The created user document
+   */
+  async createBlankUserProfile(authUserData: {
+    uid: string;
+    email: string | null;
+    isAnonymous: boolean;
+  }): Promise<User> {
+    console.log(
+      `[UserProfileAdminService] Creating blank user profile for user ${authUserData.uid}`
+    );
+
+    const userData: User = {
+      uid: authUserData.uid,
+      email: authUserData.email,
+      roles: [], // Empty roles array as requested
+      isAnonymous: authUserData.isAnonymous,
+      createdAt: admin.firestore.FieldValue.serverTimestamp(),
+      updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+      lastLoginAt: admin.firestore.FieldValue.serverTimestamp(),
+    };
+
+    try {
+      const userRef = this.db
+        .collection(USERS_COLLECTION)
+        .doc(authUserData.uid);
+      await userRef.set(userData);
+
+      // Fetch the created document to return with server timestamps
+      const userDoc = await userRef.get();
+      return userDoc.data() as User;
+    } catch (error) {
+      console.error(
+        `[UserProfileAdminService] Error creating blank user profile for ${authUserData.uid}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Initializes patient role for a user and creates all required patient documents
+   * Creates patient profile, sensitive info, and medical info in one operation
+   *
+   * @param userId The user ID to initialize with patient role
+   * @param options Optional data for different aspects of patient initialization
+   * @returns Object containing the updated user and all created patient documents
+   */
+  async initializePatientRole(
+    userId: string,
+    options?: {
+      profileData?: Partial<CreatePatientProfileData>;
+      sensitiveData?: Partial<CreatePatientSensitiveInfoData>;
+    }
+  ): Promise<{
+    user: User;
+    patientProfile: PatientProfile;
+    patientSensitiveInfo: PatientSensitiveInfo;
+    patientMedicalInfo: PatientMedicalInfo;
+  }> {
+    console.log(
+      `[UserProfileAdminService] Initializing complete patient role for user ${userId}`
+    );
+
+    try {
+      // Get user document
+      const userRef = this.db.collection(USERS_COLLECTION).doc(userId);
+      const userDoc = await userRef.get();
+
+      if (!userDoc.exists) {
+        throw new Error(`User ${userId} not found`);
+      }
+
+      const userData = userDoc.data() as User;
+      let patientProfileId: string | undefined = userData.patientProfile;
+
+      // Create patient profile if it doesn't exist
+      let patientProfile: PatientProfile;
+      if (!patientProfileId) {
+        // Create patient profile
+        const patientProfileRef = this.db.collection(PATIENTS_COLLECTION).doc();
+        patientProfileId = patientProfileRef.id;
+
+        // Set default profile data
+        const defaultProfileData: CreatePatientProfileData = {
+          userRef: userId,
+          displayName: "Patient", // Default display name
+          expoTokens: [],
+          gamification: {
+            level: 1,
+            points: 0,
+          },
+          isActive: true,
+          isVerified: false,
+          doctors: [],
+          clinics: [],
+          doctorIds: [],
+          clinicIds: [],
+        };
+
+        // Merge with any provided profile data
+        const mergedProfileData = {
+          ...defaultProfileData,
+          ...options?.profileData,
+        };
+
+        // Create the patient profile document with explicit properties
+        const patientProfileData = {
+          id: patientProfileId,
+          userRef: mergedProfileData.userRef,
+          displayName: mergedProfileData.displayName,
+          profilePhoto: null,
+          gamification: mergedProfileData.gamification || {
+            level: 1,
+            points: 0,
+          },
+          expoTokens: mergedProfileData.expoTokens || [],
+          isActive: mergedProfileData.isActive,
+          isVerified: mergedProfileData.isVerified,
+          doctors: mergedProfileData.doctors || [],
+          clinics: mergedProfileData.clinics || [],
+          doctorIds: mergedProfileData.doctorIds || [],
+          clinicIds: mergedProfileData.clinicIds || [],
+          createdAt: admin.firestore.FieldValue.serverTimestamp(),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        };
+
+        // Store the document
+        await patientProfileRef.set(patientProfileData);
+
+        // For returning to the client, use type assertions
+        patientProfile = {
+          ...patientProfileData,
+          createdAt: null as any,
+          updatedAt: null as any,
+        } as unknown as PatientProfile;
+
+        console.log(
+          `[UserProfileAdminService] Creating patient profile with ID ${patientProfileId}`
+        );
+      } else {
+        // Get existing patient profile
+        const patientProfileRef = this.db
+          .collection(PATIENTS_COLLECTION)
+          .doc(patientProfileId);
+        const patientProfileDoc = await patientProfileRef.get();
+
+        if (!patientProfileDoc.exists) {
+          throw new Error(
+            `Patient profile ${patientProfileId} exists in user but not in patients collection`
+          );
+        }
+
+        patientProfile = patientProfileDoc.data() as PatientProfile;
+      }
+
+      // Create sensitive information document
+      const sensitiveInfoRef = this.db
+        .collection(PATIENTS_COLLECTION)
+        .doc(patientProfileId)
+        .collection(PATIENT_SENSITIVE_INFO_COLLECTION)
+        .doc("info"); // Use 'info' as standard document ID for subcollection
+
+      // Check if sensitive info document already exists
+      const sensitiveInfoDoc = await sensitiveInfoRef.get();
+      let patientSensitiveInfo: PatientSensitiveInfo;
+
+      if (!sensitiveInfoDoc.exists) {
+        // Create default sensitive info data
+        const defaultSensitiveData: CreatePatientSensitiveInfoData = {
+          patientId: patientProfileId,
+          userRef: userId,
+          firstName: "",
+          lastName: "",
+          dateOfBirth: null,
+          gender: Gender.PREFER_NOT_TO_SAY,
+        };
+
+        // Merge with provided data
+        const mergedSensitiveData = {
+          ...defaultSensitiveData,
+          ...options?.sensitiveData,
+        };
+
+        // Create sensitive info
+        const sensitiveInfoData = {
+          ...mergedSensitiveData,
+          createdAt: admin.firestore.FieldValue.serverTimestamp(),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+          // Leave dateOfBirth as is
+        };
+
+        // Store the document
+        await sensitiveInfoRef.set(sensitiveInfoData);
+
+        // Convert for client return with type assertions
+        patientSensitiveInfo = {
+          ...sensitiveInfoData,
+          createdAt: null as any,
+          updatedAt: null as any,
+        } as unknown as PatientSensitiveInfo;
+
+        console.log(
+          `[UserProfileAdminService] Creating sensitive info in subcollection for patient ${patientProfileId}`
+        );
+      } else {
+        patientSensitiveInfo = sensitiveInfoDoc.data() as PatientSensitiveInfo;
+      }
+
+      // Create medical info document as a subcollection
+      const medicalInfoRef = this.db
+        .collection(PATIENTS_COLLECTION)
+        .doc(patientProfileId)
+        .collection(PATIENT_MEDICAL_INFO_COLLECTION)
+        .doc("info"); // Use 'info' as standard document ID for subcollection
+
+      // Check if medical info document already exists
+      const medicalInfoDoc = await medicalInfoRef.get();
+      let patientMedicalInfo: PatientMedicalInfo;
+
+      if (!medicalInfoDoc.exists) {
+        // Create medical info
+        const medicalInfoData = {
+          patientId: patientProfileId,
+          vitalStats: {},
+          blockingConditions: [],
+          contraindications: [],
+          allergies: [],
+          currentMedications: [],
+          lastUpdated: admin.firestore.FieldValue.serverTimestamp(),
+          updatedBy: userId,
+        };
+
+        // Store the document
+        await medicalInfoRef.set(medicalInfoData);
+
+        // Convert for client return with type assertions
+        patientMedicalInfo = {
+          ...medicalInfoData,
+          lastUpdated: null as any,
+        } as unknown as PatientMedicalInfo;
+
+        console.log(
+          `[UserProfileAdminService] Creating medical info in subcollection for patient ${patientProfileId}`
+        );
+      } else {
+        patientMedicalInfo = medicalInfoDoc.data() as PatientMedicalInfo;
+      }
+
+      // Update user document with patient role and profile reference
+      const batch = this.db.batch();
+
+      // Add patient role if not already present
+      if (!userData.roles.includes(UserRole.PATIENT)) {
+        batch.update(userRef, {
+          roles: admin.firestore.FieldValue.arrayUnion(UserRole.PATIENT),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      }
+
+      // Add patient profile reference if not already set
+      if (!userData.patientProfile) {
+        batch.update(userRef, {
+          patientProfile: patientProfileId,
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      }
+
+      await batch.commit();
+
+      // Get updated user document
+      const updatedUserDoc = await userRef.get();
+      const updatedUser = updatedUserDoc.data() as User;
+
+      console.log(
+        `[UserProfileAdminService] Successfully initialized patient role for user ${userId}`
+      );
+
+      return {
+        user: updatedUser,
+        patientProfile,
+        patientSensitiveInfo,
+        patientMedicalInfo,
+      };
+    } catch (error) {
+      console.error(
+        `[UserProfileAdminService] Error initializing patient role for user ${userId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Initializes clinic admin role for a user
+   * @param userId The user ID to initialize with clinic admin role
+   * @returns The updated user document
+   */
+  async initializeClinicAdminRole(userId: string): Promise<User> {
+    console.log(
+      `[UserProfileAdminService] Initializing clinic admin role for user ${userId}`
+    );
+
+    try {
+      const userRef = this.db.collection(USERS_COLLECTION).doc(userId);
+      const userDoc = await userRef.get();
+
+      if (!userDoc.exists) {
+        throw new Error(`User ${userId} not found`);
+      }
+
+      const userData = userDoc.data() as User;
+
+      // Only add the role if it doesn't already exist
+      if (!userData.roles.includes(UserRole.CLINIC_ADMIN)) {
+        await userRef.update({
+          roles: admin.firestore.FieldValue.arrayUnion(UserRole.CLINIC_ADMIN),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      }
+
+      // Return the updated user document
+      const updatedUserDoc = await userRef.get();
+      return updatedUserDoc.data() as User;
+    } catch (error) {
+      console.error(
+        `[UserProfileAdminService] Error initializing clinic admin role for user ${userId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Initializes practitioner role for a user
+   * @param userId The user ID to initialize with practitioner role
+   * @returns The updated user document
+   */
+  async initializePractitionerRole(userId: string): Promise<User> {
+    console.log(
+      `[UserProfileAdminService] Initializing practitioner role for user ${userId}`
+    );
+
+    try {
+      const userRef = this.db.collection(USERS_COLLECTION).doc(userId);
+      const userDoc = await userRef.get();
+
+      if (!userDoc.exists) {
+        throw new Error(`User ${userId} not found`);
+      }
+
+      const userData = userDoc.data() as User;
+
+      // Only add the role if it doesn't already exist
+      if (!userData.roles.includes(UserRole.PRACTITIONER)) {
+        await userRef.update({
+          roles: admin.firestore.FieldValue.arrayUnion(UserRole.PRACTITIONER),
+          updatedAt: admin.firestore.FieldValue.serverTimestamp(),
+        });
+      }
+
+      // Return the updated user document
+      const updatedUserDoc = await userRef.get();
+      return updatedUserDoc.data() as User;
+    } catch (error) {
+      console.error(
+        `[UserProfileAdminService] Error initializing practitioner role for user ${userId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+}

package/src/config/firebase.ts

@@ -3,12 +3,16 @@ import { Firestore, getFirestore } from "firebase/firestore";
 import { Auth, getAuth } from "firebase/auth";
 import { Analytics, getAnalytics } from "firebase/analytics";
 import { Platform } from "react-native";
+import { FirebaseStorage, getStorage } from "firebase/storage";
+import { Functions, getFunctions } from "firebase/functions";
 
 interface FirebaseInstance {
   app: FirebaseApp;
   db: Firestore;
   auth: Auth;
   analytics: Analytics | null;
+  storage: FirebaseStorage;
+  functions: Functions;
 }
 
 let firebaseInstance: FirebaseInstance | null = null;
@@ -26,13 +30,15 @@ export const initializeFirebase = (config: {
     const app = initializeApp(config);
     const db = getFirestore(app);
     const auth = getAuth(app);
+    const storage = getStorage(app);
+    const functions = getFunctions(app);
 
     let analytics = null;
     if (typeof window !== "undefined" && Platform.OS === "web") {
       analytics = getAnalytics(app);
     }
 
-    firebaseInstance = { app, db, auth, analytics };
+    firebaseInstance = { app, db, auth, analytics, storage, functions };
   }
   return firebaseInstance;
 };
@@ -60,3 +66,13 @@ export const getFirebaseApp = async (): Promise<FirebaseApp> => {
   const instance = await getFirebaseInstance();
   return instance.app;
 };
+
+export const getFirebaseStorage = async (): Promise<FirebaseStorage> => {
+  const instance = await getFirebaseInstance();
+  return instance.storage;
+};
+
+export const getFirebaseFunctions = async (): Promise<Functions> => {
+  const instance = await getFirebaseInstance();
+  return instance.functions;
+};

package/src/services/appointment/appointment.service.ts

@@ -5,6 +5,14 @@ import {
   serverTimestamp,
   arrayUnion,
   arrayRemove,
+  QueryConstraint,
+  where,
+  orderBy,
+  collection,
+  query,
+  limit,
+  startAfter,
+  getDocs,
 } from "firebase/firestore";
 import { Auth } from "firebase/auth";
 import { FirebaseApp } from "firebase/app";
@@ -21,6 +29,7 @@ import {
   PatientReviewInfo,
   LinkedFormInfo,
   type CreateAppointmentHttpData,
+  APPOINTMENTS_COLLECTION,
 } from "../../types/appointment";
 import {
   createAppointmentSchema,
@@ -1002,4 +1011,233 @@ export class AppointmentService extends BaseService {
 
     return this.updateAppointment(appointmentId, updateData);
   }
+
+  /**
+   * Gets upcoming appointments for a specific patient.
+   * These include appointments with statuses: PENDING, CONFIRMED, CHECKED_IN, IN_PROGRESS
+   *
+   * @param patientId ID of the patient
+   * @param options Optional parameters for filtering and pagination
+   * @returns Found appointments and the last document for pagination
+   */
+  async getUpcomingPatientAppointments(
+    patientId: string,
+    options?: {
+      startDate?: Date; // Optional starting date (defaults to now)
+      endDate?: Date;
+      limit?: number;
+      startAfter?: DocumentSnapshot;
+    }
+  ): Promise<{
+    appointments: Appointment[];
+    lastDoc: DocumentSnapshot | null;
+  }> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting upcoming appointments for patient: ${patientId}`
+      );
+
+      // Default to current date/time if no startDate provided
+      const effectiveStartDate = options?.startDate || new Date();
+
+      // Define the statuses considered as "upcoming"
+      const upcomingStatuses = [
+        AppointmentStatus.PENDING,
+        AppointmentStatus.CONFIRMED,
+        AppointmentStatus.CHECKED_IN,
+        AppointmentStatus.IN_PROGRESS,
+        AppointmentStatus.RESCHEDULED_BY_CLINIC,
+      ];
+
+      // Build query constraints
+      const constraints: QueryConstraint[] = [];
+
+      // Patient ID filter
+      constraints.push(where("patientId", "==", patientId));
+
+      // Status filter - multiple statuses
+      constraints.push(where("status", "in", upcomingStatuses));
+
+      // Date range filters
+      constraints.push(
+        where(
+          "appointmentStartTime",
+          ">=",
+          Timestamp.fromDate(effectiveStartDate)
+        )
+      );
+
+      if (options?.endDate) {
+        constraints.push(
+          where(
+            "appointmentStartTime",
+            "<=",
+            Timestamp.fromDate(options.endDate)
+          )
+        );
+      }
+
+      // Order by appointment start time (ascending for upcoming - closest first)
+      constraints.push(orderBy("appointmentStartTime", "asc"));
+
+      // Add pagination if specified
+      if (options?.limit) {
+        constraints.push(limit(options.limit));
+      }
+
+      if (options?.startAfter) {
+        constraints.push(startAfter(options.startAfter));
+      }
+
+      // Execute query
+      const q = query(
+        collection(this.db, APPOINTMENTS_COLLECTION),
+        ...constraints
+      );
+      const querySnapshot = await getDocs(q);
+
+      // Extract results
+      const appointments = querySnapshot.docs.map(
+        (doc) => doc.data() as Appointment
+      );
+
+      // Get last document for pagination
+      const lastDoc =
+        querySnapshot.docs.length > 0
+          ? querySnapshot.docs[querySnapshot.docs.length - 1]
+          : null;
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${appointments.length} upcoming appointments for patient ${patientId}`
+      );
+
+      return { appointments, lastDoc };
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error getting upcoming appointments for patient ${patientId}:`,
+        error
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * Gets past appointments for a specific patient.
+   * These include appointments with statuses: COMPLETED, CANCELED_PATIENT,
+   * CANCELED_PATIENT_RESCHEDULED, CANCELED_CLINIC, NO_SHOW
+   *
+   * @param patientId ID of the patient
+   * @param options Optional parameters for filtering and pagination
+   * @returns Found appointments and the last document for pagination
+   */
+  async getPastPatientAppointments(
+    patientId: string,
+    options?: {
+      startDate?: Date;
+      endDate?: Date; // Optional end date (defaults to now)
+      showCanceled?: boolean; // Whether to include canceled appointments
+      showNoShow?: boolean; // Whether to include no-show appointments
+      limit?: number;
+      startAfter?: DocumentSnapshot;
+    }
+  ): Promise<{
+    appointments: Appointment[];
+    lastDoc: DocumentSnapshot | null;
+  }> {
+    try {
+      console.log(
+        `[APPOINTMENT_SERVICE] Getting past appointments for patient: ${patientId}`
+      );
+
+      // Default to current date/time if no endDate provided
+      const effectiveEndDate = options?.endDate || new Date();
+
+      // Define the base status for past appointments
+      const pastStatuses: AppointmentStatus[] = [AppointmentStatus.COMPLETED];
+
+      // Add canceled statuses if requested
+      if (options?.showCanceled) {
+        pastStatuses.push(
+          AppointmentStatus.CANCELED_PATIENT,
+          AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
+          AppointmentStatus.CANCELED_CLINIC
+        );
+      }
+
+      // Add no-show status if requested
+      if (options?.showNoShow) {
+        pastStatuses.push(AppointmentStatus.NO_SHOW);
+      }
+
+      // Build query constraints
+      const constraints: QueryConstraint[] = [];
+
+      // Patient ID filter
+      constraints.push(where("patientId", "==", patientId));
+
+      // Status filter - multiple statuses
+      constraints.push(where("status", "in", pastStatuses));
+
+      // Date range filters
+      if (options?.startDate) {
+        constraints.push(
+          where(
+            "appointmentStartTime",
+            ">=",
+            Timestamp.fromDate(options.startDate)
+          )
+        );
+      }
+
+      constraints.push(
+        where(
+          "appointmentStartTime",
+          "<=",
+          Timestamp.fromDate(effectiveEndDate)
+        )
+      );
+
+      // Order by appointment start time (descending for past - most recent first)
+      constraints.push(orderBy("appointmentStartTime", "desc"));
+
+      // Add pagination if specified
+      if (options?.limit) {
+        constraints.push(limit(options.limit));
+      }
+
+      if (options?.startAfter) {
+        constraints.push(startAfter(options.startAfter));
+      }
+
+      // Execute query
+      const q = query(
+        collection(this.db, APPOINTMENTS_COLLECTION),
+        ...constraints
+      );
+      const querySnapshot = await getDocs(q);
+
+      // Extract results
+      const appointments = querySnapshot.docs.map(
+        (doc) => doc.data() as Appointment
+      );
+
+      // Get last document for pagination
+      const lastDoc =
+        querySnapshot.docs.length > 0
+          ? querySnapshot.docs[querySnapshot.docs.length - 1]
+          : null;
+
+      console.log(
+        `[APPOINTMENT_SERVICE] Found ${appointments.length} past appointments for patient ${patientId}`
+      );
+
+      return { appointments, lastDoc };
+    } catch (error) {
+      console.error(
+        `[APPOINTMENT_SERVICE] Error getting past appointments for patient ${patientId}:`,
+        error
+      );
+      throw error;
+    }
+  }
 }