@blackcode_sa/metaestetics-api 1.13.3 → 1.13.5

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

@@ -1,405 +1,405 @@
-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,
-          isManual: 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;
-    }
-  }
-}
+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,
+          isManual: 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;
+    }
+  }
+}