@blackcode_sa/metaestetics-api 1.6.17 → 1.6.19

package/src/services/user.v2.service.ts

@@ -0,0 +1,466 @@
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  deleteDoc,
+  QueryConstraint,
+  Timestamp,
+  setDoc,
+  serverTimestamp,
+  FieldValue,
+} from "firebase/firestore";
+import { initializeFirebase } from "../config/firebase";
+import { User, UserRole, USERS_COLLECTION, CreateUserData } from "../types";
+import { userSchema } from "../validations/schemas";
+import { AuthError } from "../errors/auth.errors";
+import { USER_ERRORS } from "../errors/user.errors";
+import { AUTH_ERRORS } from "../errors/auth.errors";
+import { z } from "zod";
+import { BaseService } from "./base.service";
+import { PatientService } from "./patient/patient.service";
+import { ClinicAdminService } from "./clinic/clinic-admin.service";
+import { PatientProfile, PATIENTS_COLLECTION } from "../types/patient";
+import { User as FirebaseUser } from "firebase/auth";
+import { Auth } from "firebase/auth";
+import { PractitionerService } from "./practitioner/practitioner.service";
+import { CertificationLevel } from "../backoffice/types/static/certification.types";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+
+export class UserServiceV2 extends BaseService {
+  private patientService: PatientService;
+  private clinicAdminService: ClinicAdminService;
+  private practitionerService: PractitionerService;
+
+  constructor(
+    db: Firestore,
+    auth: Auth,
+    app: FirebaseApp,
+    patientService?: PatientService,
+    clinicAdminService?: ClinicAdminService,
+    practitionerService?: PractitionerService
+  ) {
+    super(db, auth, app);
+
+    // Kreiramo servise samo ako nisu prosleđeni
+    if (!patientService) {
+      patientService = new PatientService(db, auth, app);
+    }
+    if (!clinicAdminService) {
+      clinicAdminService = new ClinicAdminService(db, auth, app);
+    }
+    if (!practitionerService) {
+      practitionerService = new PractitionerService(db, auth, app);
+    }
+
+    this.patientService = patientService;
+    this.clinicAdminService = clinicAdminService;
+    this.practitionerService = practitionerService;
+  }
+
+  private getPatientService(): PatientService {
+    return this.patientService;
+  }
+
+  private getClinicAdminService(): ClinicAdminService {
+    return this.clinicAdminService;
+  }
+
+  private getPractitionerService(): PractitionerService {
+    return this.practitionerService;
+  }
+
+  /**
+   * Kreira novog korisnika na osnovu Firebase korisnika
+   */
+  async createUser(
+    firebaseUser: FirebaseUser,
+    roles: UserRole[] = [UserRole.PATIENT],
+    options?: {
+      clinicAdminData?: {
+        isGroupOwner: boolean;
+        groupToken?: string;
+        groupId?: string;
+      };
+      skipProfileCreation?: boolean;
+    }
+  ): Promise<User> {
+    const userData: CreateUserData = {
+      uid: firebaseUser.uid,
+      email: firebaseUser.email,
+      roles: roles.length > 0 ? roles : [UserRole.PATIENT],
+      isAnonymous: firebaseUser.isAnonymous,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+      lastLoginAt: serverTimestamp(),
+    };
+
+    // Kreiramo osnovnog korisnika
+    await setDoc(doc(this.db, USERS_COLLECTION, userData.uid), userData);
+
+    // Kreiramo odgovarajuće profile na osnovu rola
+    const profiles = await this.createProfilesForRoles(
+      userData.uid,
+      roles,
+      options
+    );
+
+    // Ažuriramo korisnika sa referencama na profile
+    await updateDoc(doc(this.db, USERS_COLLECTION, userData.uid), profiles);
+
+    return this.getUserById(userData.uid);
+  }
+
+  /**
+   * Dohvata ili kreira korisnika na osnovu Firebase korisnika
+   */
+  async getOrCreateUser(
+    firebaseUser: FirebaseUser,
+    initialRole?: UserRole
+  ): Promise<User> {
+    try {
+      const existingUser = await this.getUserById(firebaseUser.uid);
+      await this.updateUserLoginTimestamp(firebaseUser.uid);
+      return existingUser;
+    } catch (error) {
+      return this.createUser(firebaseUser, [initialRole || UserRole.PATIENT]);
+    }
+  }
+
+  /**
+   * Kreira profile za odgovarajuće role
+   */
+  private async createProfilesForRoles(
+    userId: string,
+    roles: UserRole[],
+    options?: {
+      clinicAdminData?: {
+        isGroupOwner: boolean;
+        groupToken?: string;
+        groupId?: string;
+      };
+      skipProfileCreation?: boolean;
+    }
+  ): Promise<{
+    patientProfile?: string;
+    practitionerProfile?: string;
+    adminProfile?: string;
+  }> {
+    const profiles: {
+      patientProfile?: string;
+      practitionerProfile?: string;
+      adminProfile?: string;
+    } = {};
+
+    for (const role of roles) {
+      switch (role) {
+        case UserRole.PATIENT:
+          const patientProfile =
+            await this.getPatientService().createPatientProfile({
+              userRef: userId,
+              displayName: "Patient", // Default displayName, može se kasnije promeniti
+              expoTokens: [],
+              gamification: {
+                level: 1,
+                points: 0,
+              },
+              isActive: true,
+              isVerified: false,
+            });
+          profiles.patientProfile = patientProfile.id;
+          break;
+        case UserRole.CLINIC_ADMIN:
+          // Skip profile creation if explicitly requested
+          // This is used when we know the profile will be created elsewhere (e.g. in signUpClinicAdmin)
+          if (options?.skipProfileCreation) {
+            break;
+          }
+
+          // Ako imamo token, verifikujemo ga i dodajemo admina u postojeću grupu
+          if (
+            options?.clinicAdminData?.groupToken &&
+            options?.clinicAdminData?.groupId
+          ) {
+            const isValid = await this.getClinicAdminService()
+              .getClinicGroupService()
+              .verifyAndUseAdminToken(
+                options.clinicAdminData.groupId,
+                options.clinicAdminData.groupToken,
+                userId
+              );
+
+            if (!isValid) {
+              throw new Error("Invalid admin token");
+            }
+          }
+
+          const clinicAdminProfile =
+            await this.getClinicAdminService().createClinicAdmin({
+              userRef: userId,
+              clinicGroupId: options?.clinicAdminData?.groupId || "",
+              isGroupOwner: options?.clinicAdminData?.isGroupOwner || false,
+              clinicsManaged: [],
+              contactInfo: {
+                firstName: "",
+                lastName: "",
+                title: "Clinic Administrator",
+                email: "",
+                phoneNumber: "",
+              },
+              roleTitle: "Clinic Administrator",
+              isActive: true,
+            });
+          profiles.adminProfile = clinicAdminProfile.id;
+          break;
+        case UserRole.PRACTITIONER:
+          const practitionerProfile =
+            await this.getPractitionerService().createPractitioner({
+              userRef: userId,
+              basicInfo: {
+                firstName: "",
+                lastName: "",
+                email: "",
+                phoneNumber: "",
+                title: "",
+                dateOfBirth: Timestamp.now(),
+                gender: "other",
+                languages: ["Serbian"],
+              },
+              certification: {
+                level: CertificationLevel.AESTHETICIAN,
+                specialties: [],
+                licenseNumber: "",
+                issuingAuthority: "",
+                issueDate: Timestamp.now(),
+                verificationStatus: "pending",
+              },
+              isActive: true,
+              isVerified: false,
+            });
+          profiles.practitionerProfile = practitionerProfile.id;
+          break;
+      }
+    }
+
+    return profiles;
+  }
+
+  /**
+   * Dohvata korisnika po ID-u
+   */
+  async getUserById(uid: string): Promise<User> {
+    const userDoc = await getDoc(doc(this.db, USERS_COLLECTION, uid));
+
+    if (!userDoc.exists()) {
+      throw USER_ERRORS.NOT_FOUND;
+    }
+
+    const userData = userDoc.data();
+    return userSchema.parse(userData);
+  }
+
+  /**
+   * Dohvata korisnika po email-u
+   */
+  async getUserByEmail(email: string): Promise<User | null> {
+    const usersRef = collection(this.db, USERS_COLLECTION);
+    const q = query(usersRef, where("email", "==", email));
+    const querySnapshot = await getDocs(q);
+
+    if (querySnapshot.empty) return null;
+
+    const userData = querySnapshot.docs[0].data();
+    return userSchema.parse(userData);
+  }
+
+  async getUsersByRole(role: UserRole): Promise<User[]> {
+    const constraints: QueryConstraint[] = [
+      where("roles", "array-contains", role),
+    ];
+    const q = query(collection(this.db, USERS_COLLECTION), ...constraints);
+    const querySnapshot = await getDocs(q);
+
+    const users = querySnapshot.docs.map((doc) => doc.data());
+    return Promise.all(users.map((userData) => userSchema.parse(userData)));
+  }
+
+  /**
+   * Ažurira timestamp poslednjeg logovanja
+   */
+  async updateUserLoginTimestamp(uid: string): Promise<User> {
+    const userRef = doc(this.db, USERS_COLLECTION, uid);
+    const userDoc = await getDoc(userRef);
+
+    if (!userDoc.exists()) {
+      throw AUTH_ERRORS.USER_NOT_FOUND;
+    }
+
+    await updateDoc(userRef, {
+      lastLoginAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+
+    return this.getUserById(uid);
+  }
+
+  async upgradeAnonymousUser(uid: string, email: string): Promise<User> {
+    const userRef = doc(this.db, USERS_COLLECTION, uid);
+    const userDoc = await getDoc(userRef);
+
+    if (!userDoc.exists()) {
+      throw USER_ERRORS.NOT_FOUND;
+    }
+
+    await updateDoc(userRef, {
+      email: email,
+      isAnonymous: false,
+      updatedAt: serverTimestamp(),
+    });
+
+    return this.getUserById(uid);
+  }
+
+  async updateUser(
+    uid: string,
+    updates: Partial<Omit<User, "uid">>
+  ): Promise<User> {
+    const userRef = doc(this.db, USERS_COLLECTION, uid);
+    const userDoc = await getDoc(userRef);
+
+    if (!userDoc.exists()) {
+      throw USER_ERRORS.NOT_FOUND;
+    }
+
+    try {
+      const currentUser = userDoc.data() as User;
+      const updatedUser = {
+        ...currentUser,
+        ...updates,
+        updatedAt: serverTimestamp(),
+      };
+
+      // Validate the complete updated user object
+      userSchema.parse(updatedUser);
+
+      // Update only the specified fields plus updatedAt
+      await updateDoc(userRef, {
+        ...updates,
+        updatedAt: serverTimestamp(),
+      });
+
+      return this.getUserById(uid);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw USER_ERRORS.VALIDATION_ERROR;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Dodaje novu rolu korisniku
+   */
+  async addRole(
+    uid: string,
+    role: UserRole,
+    options?: {
+      clinicAdminData?: {
+        isGroupOwner: boolean;
+        groupToken?: string;
+        groupId?: string;
+      };
+    }
+  ): Promise<void> {
+    const user = await this.getUserById(uid);
+    if (user.roles.includes(role)) return;
+
+    const profiles = await this.createProfilesForRoles(uid, [role], options);
+
+    await updateDoc(doc(this.db, USERS_COLLECTION, uid), {
+      roles: [...user.roles, role],
+      ...profiles,
+      updatedAt: serverTimestamp(),
+    });
+  }
+
+  /**
+   * Uklanja rolu korisniku i briše odgovarajući profil
+   */
+  async removeRoleAndProfile(uid: string, role: UserRole): Promise<void> {
+    const user = await this.getUserById(uid);
+    if (!user.roles.includes(role)) return;
+
+    // Prvo brišemo profil
+    switch (role) {
+      case UserRole.PATIENT:
+        if (user.patientProfile) {
+          await this.getPatientService().deletePatientProfile(
+            user.patientProfile
+          );
+        }
+        break;
+      case UserRole.CLINIC_ADMIN:
+        if (user.adminProfile) {
+          await this.getClinicAdminService().deleteClinicAdmin(
+            user.adminProfile
+          );
+        }
+        break;
+      case UserRole.PRACTITIONER:
+        if (user.practitionerProfile) {
+          await this.getPractitionerService().deletePractitioner(
+            user.practitionerProfile
+          );
+        }
+        break;
+      // Dodati ostale role po potrebi
+    }
+
+    // Zatim uklanjamo rolu
+    await updateDoc(doc(this.db, USERS_COLLECTION, uid), {
+      roles: user.roles.filter((r) => r !== role),
+      updatedAt: serverTimestamp(),
+    });
+  }
+
+  // Delete operations
+  async deleteUser(uid: string): Promise<void> {
+    const userRef = doc(this.db, USERS_COLLECTION, uid);
+    const userDoc = await getDoc(userRef);
+
+    if (!userDoc.exists()) {
+      throw USER_ERRORS.NOT_FOUND;
+    }
+
+    const userData = userDoc.data() as User;
+
+    try {
+      // Delete all associated profiles
+      if (userData.patientProfile) {
+        await this.getPatientService().deletePatientProfile(
+          userData.patientProfile
+        );
+      }
+
+      if (userData.practitionerProfile) {
+        await this.getPractitionerService().deletePractitioner(
+          userData.practitionerProfile
+        );
+      }
+
+      if (userData.adminProfile) {
+        await this.getClinicAdminService().deleteClinicAdmin(
+          userData.adminProfile
+        );
+      }
+
+      await deleteDoc(userRef);
+    } catch (error) {
+      throw error;
+    }
+  }
+}