@blackcode_sa/metaestetics-api 1.5.0 → 1.5.1

package/src/services/practitioner/practitioner.service.ts

@@ -17,11 +17,20 @@ import {
   CreatePractitionerData,
   UpdatePractitionerData,
   PRACTITIONERS_COLLECTION,
+  REGISTER_TOKENS_COLLECTION,
+  PractitionerStatus,
+  CreateDraftPractitionerData,
+  PractitionerToken,
+  CreatePractitionerTokenData,
+  PractitionerTokenStatus,
 } from "../../types/practitioner";
 import { ClinicService } from "../clinic/clinic.service";
 import {
   practitionerSchema,
   createPractitionerSchema,
+  createDraftPractitionerSchema,
+  practitionerTokenSchema,
+  createPractitionerTokenSchema,
 } from "../../validations/practitioner.schema";
 import { z } from "zod";
 import { Auth } from "firebase/auth";
@@ -95,6 +104,7 @@ export class PractitionerService extends BaseService {
         clinicWorkingHours: validatedData.clinicWorkingHours || [],
         isActive: validatedData.isActive,
         isVerified: validatedData.isVerified,
+        status: validatedData.status || PractitionerStatus.ACTIVE,
         createdAt: serverTimestamp(),
         updatedAt: serverTimestamp(),
       };
@@ -126,6 +136,278 @@ export class PractitionerService extends BaseService {
     }
   }
 
+  /**
+   * 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: CreateDraftPractitionerData,
+    createdBy: string,
+    clinicId: string
+  ): Promise<{ practitioner: Practitioner; token: PractitionerToken }> {
+    try {
+      // Validacija ulaznih podataka
+      const validatedData = createDraftPractitionerSchema.parse(data);
+
+      // Provera da li klinika postoji
+      const clinic = await this.getClinicService().getClinic(clinicId);
+      if (!clinic) {
+        throw new Error(`Clinic ${clinicId} not found`);
+      }
+
+      // Priprema podataka za kreiranje profila
+      const clinics = data.clinics || [clinicId];
+
+      // Provera da li sve dodatno navedene klinike postoje
+      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: Omit<Practitioner, "createdAt" | "updatedAt"> & {
+        createdAt: ReturnType<typeof serverTimestamp>;
+        updatedAt: ReturnType<typeof serverTimestamp>;
+      } = {
+        id: practitionerId,
+        userRef: "", // Prazno - biće popunjeno kada korisnik kreira nalog
+        basicInfo: validatedData.basicInfo,
+        certification: validatedData.certification,
+        clinics: clinics,
+        clinicWorkingHours: validatedData.clinicWorkingHours || [],
+        isActive:
+          validatedData.isActive !== undefined ? validatedData.isActive : false,
+        isVerified:
+          validatedData.isVerified !== undefined
+            ? validatedData.isVerified
+            : false,
+        status: PractitionerStatus.DRAFT,
+        createdAt: serverTimestamp(),
+        updatedAt: serverTimestamp(),
+      };
+
+      // Validacija kompletnog objekta
+      // Koristimo privremeni userRef za validaciju, biće prazan u bazi
+      practitionerSchema.parse({
+        ...practitionerData,
+        userRef: "temp-for-validation",
+        createdAt: Timestamp.now(),
+        updatedAt: Timestamp.now(),
+      });
+
+      // Čuvamo u Firestore
+      await setDoc(
+        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");
+      }
+
+      // Automatski kreiramo token za registraciju
+      const tokenString = this.generateId().slice(0, 6).toUpperCase();
+
+      // Default expiration is 7 days from now
+      const expiration = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
+
+      const token: PractitionerToken = {
+        id: this.generateId(),
+        token: tokenString,
+        practitionerId: practitionerId,
+        email: practitionerData.basicInfo.email,
+        clinicId: clinicId,
+        status: PractitionerTokenStatus.ACTIVE,
+        createdBy: createdBy,
+        createdAt: Timestamp.now(),
+        expiresAt: Timestamp.fromDate(expiration),
+      };
+
+      // Validate token object
+      practitionerTokenSchema.parse(token);
+
+      // Store the token in the practitioner document's register_tokens subcollection
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await setDoc(doc(this.db, tokenPath), token);
+
+      // Ovde bi bilo slanje emaila sa tokenom, ali to ćemo implementirati kasnije
+      // TODO: Implement email sending with Cloud Functions
+
+      return { practitioner: savedPractitioner, token };
+    } catch (error) {
+      if (error instanceof 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: CreatePractitionerTokenData,
+    createdBy: string
+  ): Promise<PractitionerToken> {
+    try {
+      // Validate data
+      const validatedData = createPractitionerTokenSchema.parse(data);
+
+      // Check if practitioner exists and is in DRAFT status
+      const practitioner = await this.getPractitioner(
+        validatedData.practitionerId
+      );
+      if (!practitioner) {
+        throw new Error("Practitioner not found");
+      }
+
+      if (practitioner.status !== PractitionerStatus.DRAFT) {
+        throw new Error(
+          "Can only create tokens for practitioners in DRAFT status"
+        );
+      }
+
+      // Check if clinic exists and practitioner belongs to it
+      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");
+      }
+
+      // Default expiration is 7 days from now if not specified
+      const expiration =
+        validatedData.expiresAt ||
+        new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
+
+      // Generate a token (6 characters) using generateId from BaseService
+      const tokenString = this.generateId().slice(0, 6).toUpperCase();
+
+      const token: PractitionerToken = {
+        id: this.generateId(),
+        token: tokenString,
+        practitionerId: validatedData.practitionerId,
+        email: validatedData.email,
+        clinicId: validatedData.clinicId,
+        status: PractitionerTokenStatus.ACTIVE,
+        createdBy: createdBy,
+        createdAt: Timestamp.now(),
+        expiresAt: Timestamp.fromDate(expiration),
+      };
+
+      // Validate token object
+      practitionerTokenSchema.parse(token);
+
+      // Store the token in the practitioner document's register_tokens subcollection
+      const tokenPath = `${PRACTITIONERS_COLLECTION}/${validatedData.practitionerId}/${REGISTER_TOKENS_COLLECTION}/${token.id}`;
+      await setDoc(doc(this.db, tokenPath), token);
+
+      return token;
+    } catch (error) {
+      if (error instanceof 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: string
+  ): Promise<PractitionerToken[]> {
+    const tokensRef = collection(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+    );
+
+    const q = query(
+      tokensRef,
+      where("status", "==", PractitionerTokenStatus.ACTIVE),
+      where("expiresAt", ">", Timestamp.now())
+    );
+
+    const querySnapshot = await getDocs(q);
+    return querySnapshot.docs.map((doc) => doc.data() as PractitionerToken);
+  }
+
+  /**
+   * 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: string): Promise<PractitionerToken | null> {
+    // We need to search through all practitioners' register_tokens subcollections
+    const practitionersRef = collection(this.db, PRACTITIONERS_COLLECTION);
+    const practitionersSnapshot = await getDocs(practitionersRef);
+
+    for (const practitionerDoc of practitionersSnapshot.docs) {
+      const practitionerId = practitionerDoc.id;
+      const tokensRef = collection(
+        this.db,
+        `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}`
+      );
+
+      const q = query(
+        tokensRef,
+        where("token", "==", tokenString),
+        where("status", "==", PractitionerTokenStatus.ACTIVE),
+        where("expiresAt", ">", Timestamp.now())
+      );
+
+      const tokenSnapshot = await getDocs(q);
+      if (!tokenSnapshot.empty) {
+        return tokenSnapshot.docs[0].data() as PractitionerToken;
+      }
+    }
+
+    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: string,
+    practitionerId: string,
+    userId: string
+  ): Promise<void> {
+    const tokenRef = doc(
+      this.db,
+      `${PRACTITIONERS_COLLECTION}/${practitionerId}/${REGISTER_TOKENS_COLLECTION}/${tokenId}`
+    );
+
+    await updateDoc(tokenRef, {
+      status: PractitionerTokenStatus.USED,
+      usedBy: userId,
+      usedAt: Timestamp.now(),
+    });
+  }
+
   /**
    * Dohvata zdravstvenog radnika po ID-u
    */
@@ -167,7 +449,24 @@ export class PractitionerService extends BaseService {
     const q = query(
       collection(this.db, PRACTITIONERS_COLLECTION),
       where("clinics", "array-contains", clinicId),
-      where("isActive", "==", true)
+      where("isActive", "==", true),
+      where("status", "==", PractitionerStatus.ACTIVE)
+    );
+
+    const querySnapshot = await getDocs(q);
+    return querySnapshot.docs.map((doc) => doc.data() as Practitioner);
+  }
+
+  /**
+   * Dohvata sve draft zdravstvene radnike za određenu kliniku
+   */
+  async getDraftPractitionersByClinic(
+    clinicId: string
+  ): Promise<Practitioner[]> {
+    const q = query(
+      collection(this.db, PRACTITIONERS_COLLECTION),
+      where("clinics", "array-contains", clinicId),
+      where("status", "==", PractitionerStatus.DRAFT)
     );
 
     const querySnapshot = await getDocs(q);
@@ -303,4 +602,49 @@ export class PractitionerService extends BaseService {
 
     await deleteDoc(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: string,
+    userId: string
+  ): Promise<Practitioner | null> {
+    // Find the token
+    const token = await this.validateToken(tokenString);
+    if (!token) {
+      return null; // Token not found or not valid
+    }
+
+    // Get the practitioner profile
+    const practitioner = await this.getPractitioner(token.practitionerId);
+    if (!practitioner) {
+      return null; // Practitioner not found
+    }
+
+    // Ensure practitioner is in DRAFT status
+    if (practitioner.status !== PractitionerStatus.DRAFT) {
+      throw new Error("This practitioner profile has already been claimed");
+    }
+
+    // Check if user already has a practitioner profile
+    const existingPractitioner = await this.getPractitionerByUserRef(userId);
+    if (existingPractitioner) {
+      throw new Error("User already has a practitioner profile");
+    }
+
+    // Claim the profile by linking it to the user
+    const updatedPractitioner = await this.updatePractitioner(practitioner.id, {
+      userRef: userId,
+      status: PractitionerStatus.ACTIVE,
+    });
+
+    // Mark the token as used
+    await this.markTokenAsUsed(token.id, token.practitionerId, userId);
+
+    return updatedPractitioner;
+  }
 }

package/src/types/practitioner/index.ts

@@ -5,6 +5,7 @@ import {
 } from "../../backoffice/types/static/certification.types";
 
 export const PRACTITIONERS_COLLECTION = "practitioners";
+export const REGISTER_TOKENS_COLLECTION = "register_tokens";
 
 /**
  * Osnovne informacije o zdravstvenom radniku
@@ -54,6 +55,24 @@ export interface PractitionerClinicWorkingHours {
   updatedAt: Timestamp;
 }
 
+/**
+ * Status of practitioner profile
+ */
+export enum PractitionerStatus {
+  DRAFT = "draft",
+  ACTIVE = "active",
+}
+
+/**
+ * Token status for practitioner invitations
+ */
+export enum PractitionerTokenStatus {
+  ACTIVE = "active",
+  USED = "used",
+  EXPIRED = "expired",
+  REVOKED = "revoked",
+}
+
 /**
  * Interfejs za zdravstvenog radnika
  */
@@ -66,6 +85,7 @@ export interface Practitioner {
   clinicWorkingHours: PractitionerClinicWorkingHours[]; // Radno vreme za svaku kliniku
   isActive: boolean;
   isVerified: boolean;
+  status: PractitionerStatus;
   createdAt: Timestamp;
   updatedAt: Timestamp;
 }
@@ -81,6 +101,19 @@ export interface CreatePractitionerData {
   clinicWorkingHours?: PractitionerClinicWorkingHours[];
   isActive: boolean;
   isVerified: boolean;
+  status?: PractitionerStatus;
+}
+
+/**
+ * Tip za kreiranje draft profila zdravstvenog radnika
+ */
+export interface CreateDraftPractitionerData {
+  basicInfo: PractitionerBasicInfo;
+  certification: PractitionerCertification;
+  clinics?: string[];
+  clinicWorkingHours?: PractitionerClinicWorkingHours[];
+  isActive?: boolean;
+  isVerified?: boolean;
 }
 
 /**
@@ -134,3 +167,30 @@ export interface PractitionerWorkingHours {
   createdAt: Timestamp;
   updatedAt: Timestamp;
 }
+
+/**
+ * Token za pozivanje zdravstvenog radnika
+ */
+export interface PractitionerToken {
+  id: string;
+  token: string;
+  practitionerId: string;
+  email: string;
+  clinicId: string;
+  status: PractitionerTokenStatus;
+  createdBy: string;
+  createdAt: Timestamp;
+  expiresAt: Timestamp;
+  usedBy?: string;
+  usedAt?: Timestamp;
+}
+
+/**
+ * Tip za kreiranje tokena za zdravstvenog radnika
+ */
+export interface CreatePractitionerTokenData {
+  practitionerId: string;
+  email: string;
+  clinicId: string;
+  expiresAt?: Date;
+}

package/src/validations/practitioner.schema.ts

@@ -4,6 +4,10 @@ import {
   CertificationLevel,
   CertificationSpecialty,
 } from "../backoffice/types/static/certification.types";
+import {
+  PractitionerStatus,
+  PractitionerTokenStatus,
+} from "../types/practitioner";
 
 /**
  * Šema za validaciju osnovnih informacija o zdravstvenom radniku
@@ -118,6 +122,7 @@ export const practitionerSchema = z.object({
   clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema),
   isActive: z.boolean(),
   isVerified: z.boolean(),
+  status: z.nativeEnum(PractitionerStatus),
   createdAt: z.instanceof(Timestamp),
   updatedAt: z.instanceof(Timestamp),
 });
@@ -133,4 +138,44 @@ export const createPractitionerSchema = z.object({
   clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema).optional(),
   isActive: z.boolean(),
   isVerified: z.boolean(),
+  status: z.nativeEnum(PractitionerStatus).optional(),
+});
+
+/**
+ * Šema za validaciju podataka pri kreiranju draft profila zdravstvenog radnika
+ */
+export const createDraftPractitionerSchema = z.object({
+  basicInfo: practitionerBasicInfoSchema,
+  certification: practitionerCertificationSchema,
+  clinics: z.array(z.string()).optional(),
+  clinicWorkingHours: z.array(practitionerClinicWorkingHoursSchema).optional(),
+  isActive: z.boolean().optional().default(false),
+  isVerified: z.boolean().optional().default(false),
+});
+
+/**
+ * Šema za validaciju tokena za zdravstvenog radnika
+ */
+export const practitionerTokenSchema = z.object({
+  id: z.string().min(1),
+  token: z.string().min(6),
+  practitionerId: z.string().min(1),
+  email: z.string().email(),
+  clinicId: z.string().min(1),
+  status: z.nativeEnum(PractitionerTokenStatus),
+  createdBy: z.string().min(1),
+  createdAt: z.instanceof(Timestamp),
+  expiresAt: z.instanceof(Timestamp),
+  usedBy: z.string().optional(),
+  usedAt: z.instanceof(Timestamp).optional(),
+});
+
+/**
+ * Šema za validaciju podataka pri kreiranju tokena za zdravstvenog radnika
+ */
+export const createPractitionerTokenSchema = z.object({
+  practitionerId: z.string().min(1),
+  email: z.string().email(),
+  clinicId: z.string().min(1),
+  expiresAt: z.date().optional(),
 });