@blackcode_sa/metaestetics-api 1.5.0 → 1.5.2

package/dist/index.mjs

@@ -3053,6 +3053,19 @@ import {
 
 // 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
 import { z as z10 } from "zod";
@@ -3164,6 +3177,7 @@ var practitionerSchema = z10.object({
   clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema),
   isActive: z10.boolean(),
   isVerified: z10.boolean(),
+  status: z10.nativeEnum(PractitionerStatus),
   createdAt: z10.instanceof(Timestamp7),
   updatedAt: z10.instanceof(Timestamp7)
 });
@@ -3174,7 +3188,35 @@ var createPractitionerSchema = z10.object({
   clinics: z10.array(z10.string()).optional(),
   clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema).optional(),
   isActive: z10.boolean(),
-  isVerified: z10.boolean()
+  isVerified: z10.boolean(),
+  status: z10.nativeEnum(PractitionerStatus).optional()
+});
+var createDraftPractitionerSchema = z10.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: z10.array(z10.string()).optional(),
+  clinicWorkingHours: z10.array(practitionerClinicWorkingHoursSchema).optional(),
+  isActive: z10.boolean().optional().default(false),
+  isVerified: z10.boolean().optional().default(false)
+});
+var practitionerTokenSchema = z10.object({
+  id: z10.string().min(1),
+  token: z10.string().min(6),
+  practitionerId: z10.string().min(1),
+  email: z10.string().email(),
+  clinicId: z10.string().min(1),
+  status: z10.nativeEnum(PractitionerTokenStatus),
+  createdBy: z10.string().min(1),
+  createdAt: z10.instanceof(Timestamp7),
+  expiresAt: z10.instanceof(Timestamp7),
+  usedBy: z10.string().optional(),
+  usedAt: z10.instanceof(Timestamp7).optional()
+});
+var createPractitionerTokenSchema = z10.object({
+  practitionerId: z10.string().min(1),
+  email: z10.string().email(),
+  clinicId: z10.string().min(1),
+  expiresAt: z10.date().optional()
 });
 
 // src/services/practitioner/practitioner.service.ts
@@ -3225,6 +3267,7 @@ var PractitionerService = class extends BaseService {
         clinicWorkingHours: validatedData.clinicWorkingHours || [],
         isActive: validatedData.isActive,
         isVerified: validatedData.isVerified,
+        status: validatedData.status || "active" /* ACTIVE */,
         createdAt: serverTimestamp9(),
         updatedAt: serverTimestamp9()
       };
@@ -3249,6 +3292,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: serverTimestamp9(),
+        updatedAt: serverTimestamp9()
+      };
+      practitionerSchema.parse({
+        ...practitionerData,
+        userRef: "temp-for-validation",
+        createdAt: Timestamp8.now(),
+        updatedAt: Timestamp8.now()
+      });
+      await setDoc7(
+        doc5(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: Timestamp8.now(),
+        expiresAt: Timestamp8.fromDate(expiration)
+      };
+      practitionerTokenSchema.parse(token);
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await setDoc7(doc5(this.db, tokenPath), token);
+      return { practitioner: savedPractitioner, token };
+    } catch (error) {
+      if (error instanceof z11.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: Timestamp8.now(),
+        expiresAt: Timestamp8.fromDate(expiration)
+      };
+      practitionerTokenSchema.parse(token);
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${validatedData.practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await setDoc7(doc5(this.db, tokenPath), token);
+      return token;
+    } catch (error) {
+      if (error instanceof z11.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 = collection3(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+    );
+    const q = query3(
+      tokensRef,
+      where3("status", "==", "active" /* ACTIVE */),
+      where3("expiresAt", ">", Timestamp8.now())
+    );
+    const querySnapshot = await getDocs3(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 = collection3(this.db, PRACTITIONERS_COLLECTION);
+    const practitionersSnapshot = await getDocs3(practitionersRef);
+    for (const practitionerDoc of practitionersSnapshot.docs) {
+      const practitionerId = practitionerDoc.id;
+      const tokensRef = collection3(
+        this.db,
+        `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+      );
+      const q = query3(
+        tokensRef,
+        where3("token", "==", tokenString),
+        where3("status", "==", "active" /* ACTIVE */),
+        where3("expiresAt", ">", Timestamp8.now())
+      );
+      const tokenSnapshot = await getDocs3(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 = doc5(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${tokenId}`
+    );
+    await updateDoc8(tokenRef, {
+      status: "used" /* USED */,
+      usedBy: userId,
+      usedAt: Timestamp8.now()
+    });
+  }
   /**
    * Dohvata zdravstvenog radnika po ID-u
    */
@@ -3282,7 +3519,20 @@ var PractitionerService = class extends BaseService {
     const q = query3(
       collection3(this.db, PRACTITIONERS_COLLECTION),
       where3("clinics", "array-contains", clinicId),
-      where3("isActive", "==", true)
+      where3("isActive", "==", true),
+      where3("status", "==", "active" /* ACTIVE */)
+    );
+    const querySnapshot = await getDocs3(q);
+    return querySnapshot.docs.map((doc20) => doc20.data());
+  }
+  /**
+   * Dohvata sve draft zdravstvene radnike za određenu kliniku
+   */
+  async getDraftPractitionersByClinic(clinicId) {
+    const q = query3(
+      collection3(this.db, PRACTITIONERS_COLLECTION),
+      where3("clinics", "array-contains", clinicId),
+      where3("status", "==", "draft" /* DRAFT */)
     );
     const querySnapshot = await getDocs3(q);
     return querySnapshot.docs.map((doc20) => doc20.data());
@@ -3391,6 +3641,35 @@ var PractitionerService = class extends BaseService {
     }
     await deleteDoc2(doc5(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
@@ -3609,25 +3888,6 @@ var UserService = class extends BaseService {
         ...updates,
         updatedAt: serverTimestamp10()
       };
-      updatedUser.roles.forEach((role) => {
-        switch (role) {
-          case "patient" /* PATIENT */:
-            if (!updatedUser.patientProfile) {
-              throw new Error(`Missing patient profile for role ${role}`);
-            }
-            break;
-          case "practitioner" /* PRACTITIONER */:
-            if (!updatedUser.practitionerProfile) {
-              throw new Error(`Missing practitioner profile for role ${role}`);
-            }
-            break;
-          case "clinic_admin" /* CLINIC_ADMIN */:
-            if (!updatedUser.adminProfile) {
-              throw new Error(`Missing admin profile for role ${role}`);
-            }
-            break;
-        }
-      });
       userSchema.parse(updatedUser);
       await updateDoc9(userRef, {
         ...updates,
@@ -9129,8 +9389,11 @@ export {
   PatientService,
   PracticeType,
   PractitionerService,
+  PractitionerStatus,
+  PractitionerTokenStatus,
   PricingMeasure,
   ProcedureFamily,
+  REGISTER_TOKENS_COLLECTION,
   SYNCED_CALENDARS_COLLECTION,
   SubscriptionModel,
   SyncedCalendarProvider,
@@ -9175,11 +9438,13 @@ export {
   createClinicSchema,
   createDefaultClinicGroupSchema,
   createDocumentTemplateSchema,
+  createDraftPractitionerSchema,
   createPatientLocationInfoSchema,
   createPatientMedicalInfoSchema,
   createPatientProfileSchema,
   createPatientSensitiveInfoSchema,
   createPractitionerSchema,
+  createPractitionerTokenSchema,
   createUserOptionsSchema,
   doctorInfoSchema,
   documentElementSchema,
@@ -9212,6 +9477,7 @@ export {
   practitionerProfileInfoSchema,
   practitionerReviewSchema,
   practitionerSchema,
+  practitionerTokenSchema,
   practitionerWorkingHoursSchema,
   preRequirementNotificationSchema,
   procedureCategorizationSchema,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@blackcode_sa/metaestetics-api",
   "private": false,
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "Firebase authentication service with anonymous upgrade support",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/index.ts

@@ -123,8 +123,16 @@ export type {
   PractitionerReview,
   PractitionerWorkingHours,
   PractitionerClinicWorkingHours,
+  CreateDraftPractitionerData,
+  PractitionerToken,
+  CreatePractitionerTokenData,
+} from "./types/practitioner";
+export {
+  PRACTITIONERS_COLLECTION,
+  REGISTER_TOKENS_COLLECTION,
+  PractitionerStatus,
+  PractitionerTokenStatus,
 } from "./types/practitioner";
-export { PRACTITIONERS_COLLECTION } from "./types/practitioner";
 
 // Clinic types
 export type {