@blackcode_sa/metaestetics-api 1.5.0 → 1.5.1

package/dist/index.js

@@ -71,8 +71,11 @@ __export(index_exports, {
   PatientService: () => PatientService,
   PracticeType: () => PracticeType,
   PractitionerService: () => PractitionerService,
+  PractitionerStatus: () => PractitionerStatus,
+  PractitionerTokenStatus: () => PractitionerTokenStatus,
   PricingMeasure: () => PricingMeasure,
   ProcedureFamily: () => ProcedureFamily,
+  REGISTER_TOKENS_COLLECTION: () => REGISTER_TOKENS_COLLECTION,
   SYNCED_CALENDARS_COLLECTION: () => SYNCED_CALENDARS_COLLECTION,
   SubscriptionModel: () => SubscriptionModel,
   SyncedCalendarProvider: () => SyncedCalendarProvider,
@@ -117,11 +120,13 @@ __export(index_exports, {
   createClinicSchema: () => createClinicSchema,
   createDefaultClinicGroupSchema: () => createDefaultClinicGroupSchema,
   createDocumentTemplateSchema: () => createDocumentTemplateSchema,
+  createDraftPractitionerSchema: () => createDraftPractitionerSchema,
   createPatientLocationInfoSchema: () => createPatientLocationInfoSchema,
   createPatientMedicalInfoSchema: () => createPatientMedicalInfoSchema,
   createPatientProfileSchema: () => createPatientProfileSchema,
   createPatientSensitiveInfoSchema: () => createPatientSensitiveInfoSchema,
   createPractitionerSchema: () => createPractitionerSchema,
+  createPractitionerTokenSchema: () => createPractitionerTokenSchema,
   createUserOptionsSchema: () => createUserOptionsSchema,
   doctorInfoSchema: () => doctorInfoSchema,
   documentElementSchema: () => documentElementSchema,
@@ -154,6 +159,7 @@ __export(index_exports, {
   practitionerProfileInfoSchema: () => practitionerProfileInfoSchema,
   practitionerReviewSchema: () => practitionerReviewSchema,
   practitionerSchema: () => practitionerSchema,
+  practitionerTokenSchema: () => practitionerTokenSchema,
   practitionerWorkingHoursSchema: () => practitionerWorkingHoursSchema,
   preRequirementNotificationSchema: () => preRequirementNotificationSchema,
   procedureCategorizationSchema: () => procedureCategorizationSchema,
@@ -3135,6 +3141,19 @@ var import_firestore13 = require("firebase/firestore");
 
 // src/types/practitioner/index.ts
 var PRACTITIONERS_COLLECTION = "practitioners";
+var REGISTER_TOKENS_COLLECTION = "register_tokens";
+var PractitionerStatus = /* @__PURE__ */ ((PractitionerStatus2) => {
+  PractitionerStatus2["DRAFT"] = "draft";
+  PractitionerStatus2["ACTIVE"] = "active";
+  return PractitionerStatus2;
+})(PractitionerStatus || {});
+var PractitionerTokenStatus = /* @__PURE__ */ ((PractitionerTokenStatus2) => {
+  PractitionerTokenStatus2["ACTIVE"] = "active";
+  PractitionerTokenStatus2["USED"] = "used";
+  PractitionerTokenStatus2["EXPIRED"] = "expired";
+  PractitionerTokenStatus2["REVOKED"] = "revoked";
+  return PractitionerTokenStatus2;
+})(PractitionerTokenStatus || {});
 
 // src/validations/practitioner.schema.ts
 var import_zod10 = require("zod");
@@ -3246,6 +3265,7 @@ var practitionerSchema = import_zod10.z.object({
   clinicWorkingHours: import_zod10.z.array(practitionerClinicWorkingHoursSchema),
   isActive: import_zod10.z.boolean(),
   isVerified: import_zod10.z.boolean(),
+  status: import_zod10.z.nativeEnum(PractitionerStatus),
   createdAt: import_zod10.z.instanceof(import_firestore12.Timestamp),
   updatedAt: import_zod10.z.instanceof(import_firestore12.Timestamp)
 });
@@ -3256,7 +3276,35 @@ var createPractitionerSchema = import_zod10.z.object({
   clinics: import_zod10.z.array(import_zod10.z.string()).optional(),
   clinicWorkingHours: import_zod10.z.array(practitionerClinicWorkingHoursSchema).optional(),
   isActive: import_zod10.z.boolean(),
-  isVerified: import_zod10.z.boolean()
+  isVerified: import_zod10.z.boolean(),
+  status: import_zod10.z.nativeEnum(PractitionerStatus).optional()
+});
+var createDraftPractitionerSchema = import_zod10.z.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: import_zod10.z.array(import_zod10.z.string()).optional(),
+  clinicWorkingHours: import_zod10.z.array(practitionerClinicWorkingHoursSchema).optional(),
+  isActive: import_zod10.z.boolean().optional().default(false),
+  isVerified: import_zod10.z.boolean().optional().default(false)
+});
+var practitionerTokenSchema = import_zod10.z.object({
+  id: import_zod10.z.string().min(1),
+  token: import_zod10.z.string().min(6),
+  practitionerId: import_zod10.z.string().min(1),
+  email: import_zod10.z.string().email(),
+  clinicId: import_zod10.z.string().min(1),
+  status: import_zod10.z.nativeEnum(PractitionerTokenStatus),
+  createdBy: import_zod10.z.string().min(1),
+  createdAt: import_zod10.z.instanceof(import_firestore12.Timestamp),
+  expiresAt: import_zod10.z.instanceof(import_firestore12.Timestamp),
+  usedBy: import_zod10.z.string().optional(),
+  usedAt: import_zod10.z.instanceof(import_firestore12.Timestamp).optional()
+});
+var createPractitionerTokenSchema = import_zod10.z.object({
+  practitionerId: import_zod10.z.string().min(1),
+  email: import_zod10.z.string().email(),
+  clinicId: import_zod10.z.string().min(1),
+  expiresAt: import_zod10.z.date().optional()
 });
 
 // src/services/practitioner/practitioner.service.ts
@@ -3307,6 +3355,7 @@ var PractitionerService = class extends BaseService {
         clinicWorkingHours: validatedData.clinicWorkingHours || [],
         isActive: validatedData.isActive,
         isVerified: validatedData.isVerified,
+        status: validatedData.status || "active" /* ACTIVE */,
         createdAt: (0, import_firestore13.serverTimestamp)(),
         updatedAt: (0, import_firestore13.serverTimestamp)()
       };
@@ -3331,6 +3380,200 @@ var PractitionerService = class extends BaseService {
       throw error;
     }
   }
+  /**
+   * Kreira novi draft profil zdravstvenog radnika bez povezanog korisnika
+   * Koristi se od strane administratora klinike za kreiranje profila i kasnije pozivanje
+   * @param data Podaci za kreiranje draft profila
+   * @param createdBy ID administratora koji kreira profil
+   * @param clinicId ID klinike za koju se kreira profil
+   * @returns Objekt koji sadrži kreirani draft profil i token za registraciju
+   */
+  async createDraftPractitioner(data, createdBy, clinicId) {
+    try {
+      const validatedData = createDraftPractitionerSchema.parse(data);
+      const clinic = await this.getClinicService().getClinic(clinicId);
+      if (!clinic) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+      const clinics = data.clinics || [clinicId];
+      if (data.clinics) {
+        for (const cId of data.clinics) {
+          if (cId !== clinicId) {
+            const otherClinic = await this.getClinicService().getClinic(cId);
+            if (!otherClinic) {
+              throw new Error(`Clinic ${cId} not found`);
+            }
+          }
+        }
+      }
+      const practitionerId = this.generateId();
+      const practitionerData = {
+        id: practitionerId,
+        userRef: "",
+        // Prazno - biće popunjeno kada korisnik kreira nalog
+        basicInfo: validatedData.basicInfo,
+        certification: validatedData.certification,
+        clinics,
+        clinicWorkingHours: validatedData.clinicWorkingHours || [],
+        isActive: validatedData.isActive !== void 0 ? validatedData.isActive : false,
+        isVerified: validatedData.isVerified !== void 0 ? validatedData.isVerified : false,
+        status: "draft" /* DRAFT */,
+        createdAt: (0, import_firestore13.serverTimestamp)(),
+        updatedAt: (0, import_firestore13.serverTimestamp)()
+      };
+      practitionerSchema.parse({
+        ...practitionerData,
+        userRef: "temp-for-validation",
+        createdAt: import_firestore13.Timestamp.now(),
+        updatedAt: import_firestore13.Timestamp.now()
+      });
+      await (0, import_firestore13.setDoc)(
+        (0, import_firestore13.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerData.id),
+        practitionerData
+      );
+      const savedPractitioner = await this.getPractitioner(practitionerData.id);
+      if (!savedPractitioner) {
+        throw new Error("Failed to create draft practitioner profile");
+      }
+      const tokenString = this.generateId().slice(0, 6).toUpperCase();
+      const expiration = new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
+      const token = {
+        id: this.generateId(),
+        token: tokenString,
+        practitionerId,
+        email: practitionerData.basicInfo.email,
+        clinicId,
+        status: "active" /* ACTIVE */,
+        createdBy,
+        createdAt: import_firestore13.Timestamp.now(),
+        expiresAt: import_firestore13.Timestamp.fromDate(expiration)
+      };
+      practitionerTokenSchema.parse(token);
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await (0, import_firestore13.setDoc)((0, import_firestore13.doc)(this.db, tokenPath), token);
+      return { practitioner: savedPractitioner, token };
+    } catch (error) {
+      if (error instanceof import_zod11.z.ZodError) {
+        throw new Error("Invalid practitioner data: " + error.message);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Creates a token for inviting practitioner to claim their profile
+   * @param data Data for creating token
+   * @param createdBy ID of the user creating the token
+   * @returns Created token
+   */
+  async createPractitionerToken(data, createdBy) {
+    try {
+      const validatedData = createPractitionerTokenSchema.parse(data);
+      const practitioner = await this.getPractitioner(
+        validatedData.practitionerId
+      );
+      if (!practitioner) {
+        throw new Error("Practitioner not found");
+      }
+      if (practitioner.status !== "draft" /* DRAFT */) {
+        throw new Error(
+          "Can only create tokens for practitioners in DRAFT status"
+        );
+      }
+      const clinic = await this.getClinicService().getClinic(
+        validatedData.clinicId
+      );
+      if (!clinic) {
+        throw new Error(`Clinic ${validatedData.clinicId} not found`);
+      }
+      if (!practitioner.clinics.includes(validatedData.clinicId)) {
+        throw new Error("Practitioner is not associated with this clinic");
+      }
+      const expiration = validatedData.expiresAt || new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
+      const tokenString = this.generateId().slice(0, 6).toUpperCase();
+      const token = {
+        id: this.generateId(),
+        token: tokenString,
+        practitionerId: validatedData.practitionerId,
+        email: validatedData.email,
+        clinicId: validatedData.clinicId,
+        status: "active" /* ACTIVE */,
+        createdBy,
+        createdAt: import_firestore13.Timestamp.now(),
+        expiresAt: import_firestore13.Timestamp.fromDate(expiration)
+      };
+      practitionerTokenSchema.parse(token);
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${validatedData.practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await (0, import_firestore13.setDoc)((0, import_firestore13.doc)(this.db, tokenPath), token);
+      return token;
+    } catch (error) {
+      if (error instanceof import_zod11.z.ZodError) {
+        throw new Error("Invalid token data: " + error.message);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Gets active tokens for a practitioner
+   * @param practitionerId ID of the practitioner
+   * @returns Array of active tokens
+   */
+  async getPractitionerActiveTokens(practitionerId) {
+    const tokensRef = (0, import_firestore13.collection)(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+    );
+    const q = (0, import_firestore13.query)(
+      tokensRef,
+      (0, import_firestore13.where)("status", "==", "active" /* ACTIVE */),
+      (0, import_firestore13.where)("expiresAt", ">", import_firestore13.Timestamp.now())
+    );
+    const querySnapshot = await (0, import_firestore13.getDocs)(q);
+    return querySnapshot.docs.map((doc20) => doc20.data());
+  }
+  /**
+   * Gets a token by its string value and validates it
+   * @param tokenString The token string to find
+   * @returns The token if found and valid, null otherwise
+   */
+  async validateToken(tokenString) {
+    const practitionersRef = (0, import_firestore13.collection)(this.db, PRACTITIONERS_COLLECTION);
+    const practitionersSnapshot = await (0, import_firestore13.getDocs)(practitionersRef);
+    for (const practitionerDoc of practitionersSnapshot.docs) {
+      const practitionerId = practitionerDoc.id;
+      const tokensRef = (0, import_firestore13.collection)(
+        this.db,
+        `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+      );
+      const q = (0, import_firestore13.query)(
+        tokensRef,
+        (0, import_firestore13.where)("token", "==", tokenString),
+        (0, import_firestore13.where)("status", "==", "active" /* ACTIVE */),
+        (0, import_firestore13.where)("expiresAt", ">", import_firestore13.Timestamp.now())
+      );
+      const tokenSnapshot = await (0, import_firestore13.getDocs)(q);
+      if (!tokenSnapshot.empty) {
+        return tokenSnapshot.docs[0].data();
+      }
+    }
+    return null;
+  }
+  /**
+   * Marks a token as used
+   * @param tokenId ID of the token
+   * @param practitionerId ID of the practitioner
+   * @param userId ID of the user using the token
+   */
+  async markTokenAsUsed(tokenId, practitionerId, userId) {
+    const tokenRef = (0, import_firestore13.doc)(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${tokenId}`
+    );
+    await (0, import_firestore13.updateDoc)(tokenRef, {
+      status: "used" /* USED */,
+      usedBy: userId,
+      usedAt: import_firestore13.Timestamp.now()
+    });
+  }
   /**
    * Dohvata zdravstvenog radnika po ID-u
    */
@@ -3364,7 +3607,20 @@ var PractitionerService = class extends BaseService {
     const q = (0, import_firestore13.query)(
       (0, import_firestore13.collection)(this.db, PRACTITIONERS_COLLECTION),
       (0, import_firestore13.where)("clinics", "array-contains", clinicId),
-      (0, import_firestore13.where)("isActive", "==", true)
+      (0, import_firestore13.where)("isActive", "==", true),
+      (0, import_firestore13.where)("status", "==", "active" /* ACTIVE */)
+    );
+    const querySnapshot = await (0, import_firestore13.getDocs)(q);
+    return querySnapshot.docs.map((doc20) => doc20.data());
+  }
+  /**
+   * Dohvata sve draft zdravstvene radnike za određenu kliniku
+   */
+  async getDraftPractitionersByClinic(clinicId) {
+    const q = (0, import_firestore13.query)(
+      (0, import_firestore13.collection)(this.db, PRACTITIONERS_COLLECTION),
+      (0, import_firestore13.where)("clinics", "array-contains", clinicId),
+      (0, import_firestore13.where)("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await (0, import_firestore13.getDocs)(q);
     return querySnapshot.docs.map((doc20) => doc20.data());
@@ -3473,6 +3729,35 @@ var PractitionerService = class extends BaseService {
     }
     await (0, import_firestore13.deleteDoc)((0, import_firestore13.doc)(this.db, PRACTITIONERS_COLLECTION, practitionerId));
   }
+  /**
+   * Validates a registration token and claims the associated draft practitioner profile
+   * @param tokenString The token provided by the practitioner
+   * @param userId The ID of the user claiming the profile
+   * @returns The claimed practitioner profile or null if token is invalid
+   */
+  async validateTokenAndClaimProfile(tokenString, userId) {
+    const token = await this.validateToken(tokenString);
+    if (!token) {
+      return null;
+    }
+    const practitioner = await this.getPractitioner(token.practitionerId);
+    if (!practitioner) {
+      return null;
+    }
+    if (practitioner.status !== "draft" /* DRAFT */) {
+      throw new Error("This practitioner profile has already been claimed");
+    }
+    const existingPractitioner = await this.getPractitionerByUserRef(userId);
+    if (existingPractitioner) {
+      throw new Error("User already has a practitioner profile");
+    }
+    const updatedPractitioner = await this.updatePractitioner(practitioner.id, {
+      userRef: userId,
+      status: "active" /* ACTIVE */
+    });
+    await this.markTokenAsUsed(token.id, token.practitionerId, userId);
+    return updatedPractitioner;
+  }
 };
 
 // src/services/user.service.ts
@@ -9080,8 +9365,11 @@ var notificationSchema = import_zod18.z.discriminatedUnion("notificationType", [
   PatientService,
   PracticeType,
   PractitionerService,
+  PractitionerStatus,
+  PractitionerTokenStatus,
   PricingMeasure,
   ProcedureFamily,
+  REGISTER_TOKENS_COLLECTION,
   SYNCED_CALENDARS_COLLECTION,
   SubscriptionModel,
   SyncedCalendarProvider,
@@ -9126,11 +9414,13 @@ var notificationSchema = import_zod18.z.discriminatedUnion("notificationType", [
   createClinicSchema,
   createDefaultClinicGroupSchema,
   createDocumentTemplateSchema,
+  createDraftPractitionerSchema,
   createPatientLocationInfoSchema,
   createPatientMedicalInfoSchema,
   createPatientProfileSchema,
   createPatientSensitiveInfoSchema,
   createPractitionerSchema,
+  createPractitionerTokenSchema,
   createUserOptionsSchema,
   doctorInfoSchema,
   documentElementSchema,
@@ -9163,6 +9453,7 @@ var notificationSchema = import_zod18.z.discriminatedUnion("notificationType", [
   practitionerProfileInfoSchema,
   practitionerReviewSchema,
   practitionerSchema,
+  practitionerTokenSchema,
   practitionerWorkingHoursSchema,
   preRequirementNotificationSchema,
   procedureCategorizationSchema,