@blackcode_sa/metaestetics-api 1.5.3 → 1.5.6

package/src/services/auth.service.ts

@@ -471,6 +471,100 @@ export class AuthService extends BaseService {
     return this.userService.getOrCreateUser(firebaseUser);
   }
 
+  /**
+   * Prijavljuje korisnika sa email-om i lozinkom samo za clinic_admin role
+   * @param email - Email korisnika
+   * @param password - Lozinka korisnika
+   * @returns Objekat koji sadrži korisnika, admin profil i grupu klinika
+   * @throws {AUTH_ERRORS.INVALID_ROLE} Ako korisnik nema clinic_admin rolu
+   * @throws {AUTH_ERRORS.NOT_FOUND} Ako admin profil nije pronađen
+   */
+  async signInClinicAdmin(
+    email: string,
+    password: string
+  ): Promise<{
+    user: User;
+    clinicAdmin: ClinicAdmin;
+    clinicGroup: ClinicGroup;
+  }> {
+    try {
+      // Initialize required services
+      const clinicAdminService = new ClinicAdminService(
+        this.db,
+        this.auth,
+        this.app
+      );
+      const clinicGroupService = new ClinicGroupService(
+        this.db,
+        this.auth,
+        this.app,
+        clinicAdminService
+      );
+      const clinicService = new ClinicService(
+        this.db,
+        this.auth,
+        this.app,
+        clinicGroupService,
+        clinicAdminService
+      );
+
+      // Set services to resolve circular dependencies
+      clinicAdminService.setServices(clinicGroupService, clinicService);
+
+      // Sign in with email/password
+      const { user: firebaseUser } = await signInWithEmailAndPassword(
+        this.auth,
+        email,
+        password
+      );
+
+      // Get or create user
+      const user = await this.userService.getOrCreateUser(firebaseUser);
+
+      // Check if user has clinic_admin role
+      if (!user.roles?.includes(UserRole.CLINIC_ADMIN)) {
+        console.error("[AUTH] User is not a clinic admin:", user.uid);
+        throw AUTH_ERRORS.INVALID_ROLE;
+      }
+
+      // Check and get admin profile
+      if (!user.adminProfile) {
+        console.error("[AUTH] User has no admin profile:", user.uid);
+        throw AUTH_ERRORS.NOT_FOUND;
+      }
+
+      // Get clinic admin profile
+      const adminProfile = await clinicAdminService.getClinicAdmin(
+        user.adminProfile
+      );
+      if (!adminProfile) {
+        console.error("[AUTH] Admin profile not found:", user.adminProfile);
+        throw AUTH_ERRORS.NOT_FOUND;
+      }
+
+      // Get clinic group
+      const clinicGroup = await clinicGroupService.getClinicGroup(
+        adminProfile.clinicGroupId
+      );
+      if (!clinicGroup) {
+        console.error(
+          "[AUTH] Clinic group not found:",
+          adminProfile.clinicGroupId
+        );
+        throw AUTH_ERRORS.NOT_FOUND;
+      }
+
+      return {
+        user,
+        clinicAdmin: adminProfile,
+        clinicGroup,
+      };
+    } catch (error) {
+      console.error("[AUTH] Error in signInClinicAdmin:", error);
+      throw error;
+    }
+  }
+
   /**
    * Prijavljuje korisnika sa Facebook-om
    */

package/src/services/clinic/clinic.service.ts

@@ -258,6 +258,12 @@ export class ClinicService extends BaseService {
     }
     console.log("[CLINIC_SERVICE] Clinic group verified");
 
+    // TODO: Handle logo, coverPhoto, featuredPhotos, photosWithTags and upload them to storage
+    // Use storage service to upload files, and get the download URL
+    // Use path 'clinics/{clinicId}/{photoType}/{filename}' for storing the files
+    // Photo types: logo, coverPhoto, featuredPhotos, photosWithTags
+    // Storage can be accessed by using the storage service like app.getStorage()
+
     // Create the clinic data
     const createClinicData: CreateClinicData = {
       clinicGroupId,

package/src/services/documentation-templates/documentation-template.service.ts

@@ -21,9 +21,12 @@ import {
   CreateDocumentTemplateData,
   DocumentElement,
   DocumentTemplate,
-  DOCUMENTATION_TEMPLATES_COLLECTION,
   UpdateDocumentTemplateData,
 } from "../../types";
+import {
+  FILLED_DOCUMENTS_COLLECTION,
+  DOCUMENTATION_TEMPLATES_COLLECTION,
+} from "../../types";
 import {
   createDocumentTemplateSchema,
   updateDocumentTemplateSchema,

package/src/services/procedure/procedure.service.ts

@@ -0,0 +1,238 @@
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  setDoc,
+  deleteDoc,
+  Timestamp,
+  serverTimestamp,
+  DocumentData,
+} from "firebase/firestore";
+import { BaseService } from "../base.service";
+import {
+  Procedure,
+  CreateProcedureData,
+  UpdateProcedureData,
+  PROCEDURES_COLLECTION,
+} from "../../types/procedure";
+import {
+  createProcedureSchema,
+  updateProcedureSchema,
+} from "../../validations/procedure.schema";
+import { z } from "zod";
+import { Auth } from "firebase/auth";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import {
+  Category,
+  CATEGORIES_COLLECTION,
+} from "../../backoffice/types/category.types";
+import {
+  Subcategory,
+  SUBCATEGORIES_COLLECTION,
+} from "../../backoffice/types/subcategory.types";
+import {
+  Technology,
+  TECHNOLOGIES_COLLECTION,
+} from "../../backoffice/types/technology.types";
+import {
+  Product,
+  PRODUCTS_COLLECTION,
+} from "../../backoffice/types/product.types";
+
+export class ProcedureService extends BaseService {
+  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
+    super(db, auth, app);
+  }
+
+  /**
+   * Creates a new procedure
+   * @param data - The data for creating a new procedure
+   * @returns The created procedure
+   */
+  async createProcedure(data: CreateProcedureData): Promise<Procedure> {
+    // Validate input data
+    const validatedData = createProcedureSchema.parse(data);
+
+    // Get references to related entities
+    const [category, subcategory, technology, product] = await Promise.all([
+      this.getCategory(validatedData.categoryId),
+      this.getSubcategory(validatedData.subcategoryId),
+      this.getTechnology(validatedData.technologyId),
+      this.getProduct(validatedData.productId),
+    ]);
+
+    if (!category || !subcategory || !technology || !product) {
+      throw new Error("One or more required entities not found");
+    }
+
+    // Create the procedure object
+    const procedure: Omit<Procedure, "id"> = {
+      ...validatedData,
+      category,
+      subcategory,
+      technology,
+      product,
+      blockingConditions: technology.blockingConditions,
+      treatmentBenefits: technology.benefits,
+      preRequirements: technology.requirements.pre,
+      postRequirements: technology.requirements.post,
+      certificationRequirement: technology.certificationRequirement,
+      documentationTemplates: technology.documentationTemplates || [],
+      isActive: true,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    // Generate ID and create document
+    const id = this.generateId();
+    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    await setDoc(docRef, {
+      ...procedure,
+      id,
+      createdAt: serverTimestamp(),
+      updatedAt: serverTimestamp(),
+    });
+
+    return { ...procedure, id } as Procedure;
+  }
+
+  /**
+   * Gets a procedure by ID
+   * @param id - The ID of the procedure to get
+   * @returns The procedure if found, null otherwise
+   */
+  async getProcedure(id: string): Promise<Procedure | null> {
+    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    const docSnap = await getDoc(docRef);
+
+    if (!docSnap.exists()) {
+      return null;
+    }
+
+    return docSnap.data() as Procedure;
+  }
+
+  /**
+   * Gets all procedures for a clinic branch
+   * @param clinicBranchId - The ID of the clinic branch
+   * @returns List of procedures
+   */
+  async getProceduresByClinicBranch(
+    clinicBranchId: string
+  ): Promise<Procedure[]> {
+    const q = query(
+      collection(this.db, PROCEDURES_COLLECTION),
+      where("clinicBranchId", "==", clinicBranchId),
+      where("isActive", "==", true)
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map((doc) => doc.data() as Procedure);
+  }
+
+  /**
+   * Gets all procedures for a practitioner
+   * @param practitionerId - The ID of the practitioner
+   * @returns List of procedures
+   */
+  async getProceduresByPractitioner(
+    practitionerId: string
+  ): Promise<Procedure[]> {
+    const q = query(
+      collection(this.db, PROCEDURES_COLLECTION),
+      where("practitionerId", "==", practitionerId),
+      where("isActive", "==", true)
+    );
+    const snapshot = await getDocs(q);
+    return snapshot.docs.map((doc) => doc.data() as Procedure);
+  }
+
+  /**
+   * Updates a procedure
+   * @param id - The ID of the procedure to update
+   * @param data - The data to update
+   * @returns The updated procedure
+   */
+  async updateProcedure(
+    id: string,
+    data: UpdateProcedureData
+  ): Promise<Procedure> {
+    // Validate input data
+    const validatedData = updateProcedureSchema.parse(data);
+
+    // Get the existing procedure
+    const existingProcedure = await this.getProcedure(id);
+    if (!existingProcedure) {
+      throw new Error(`Procedure with ID ${id} not found`);
+    }
+
+    // Update the procedure
+    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    await updateDoc(docRef, {
+      ...validatedData,
+      updatedAt: serverTimestamp(),
+    });
+
+    return {
+      ...existingProcedure,
+      ...validatedData,
+      updatedAt: new Date(),
+    };
+  }
+
+  /**
+   * Deactivates a procedure
+   * @param id - The ID of the procedure to deactivate
+   */
+  async deactivateProcedure(id: string): Promise<void> {
+    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    await updateDoc(docRef, {
+      isActive: false,
+      updatedAt: serverTimestamp(),
+    });
+  }
+
+  /**
+   * Gets a category by ID
+   * @private
+   */
+  private async getCategory(id: string): Promise<Category | null> {
+    const docRef = doc(this.db, CATEGORIES_COLLECTION, id);
+    const docSnap = await getDoc(docRef);
+    return docSnap.exists() ? (docSnap.data() as Category) : null;
+  }
+
+  /**
+   * Gets a subcategory by ID
+   * @private
+   */
+  private async getSubcategory(id: string): Promise<Subcategory | null> {
+    const docRef = doc(this.db, SUBCATEGORIES_COLLECTION, id);
+    const docSnap = await getDoc(docRef);
+    return docSnap.exists() ? (docSnap.data() as Subcategory) : null;
+  }
+
+  /**
+   * Gets a technology by ID
+   * @private
+   */
+  private async getTechnology(id: string): Promise<Technology | null> {
+    const docRef = doc(this.db, TECHNOLOGIES_COLLECTION, id);
+    const docSnap = await getDoc(docRef);
+    return docSnap.exists() ? (docSnap.data() as Technology) : null;
+  }
+
+  /**
+   * Gets a product by ID
+   * @private
+   */
+  private async getProduct(id: string): Promise<Product | null> {
+    const docRef = doc(this.db, PRODUCTS_COLLECTION, id);
+    const docSnap = await getDoc(docRef);
+    return docSnap.exists() ? (docSnap.data() as Product) : null;
+  }
+}

package/src/types/documentation-templates/index.ts

@@ -2,6 +2,11 @@
  * Types for the Medical Documentation Templating System
  */
 
+/**
+ * Kolekcija u Firestore bazi gde se čuvaju dokumentacijske šablone
+ */
+export const DOCUMENTATION_TEMPLATES_COLLECTION = "documentation-templates";
+export const FILLED_DOCUMENTS_COLLECTION = "filled-documents";
 /**
  * Enum for element types in documentation templates
  */

package/src/types/procedure/index.ts

@@ -0,0 +1,104 @@
+import { ProcedureFamily } from "../../backoffice/types/static/procedure-family.types";
+import { Category } from "../../backoffice/types/category.types";
+import { Subcategory } from "../../backoffice/types/subcategory.types";
+import { Technology } from "../../backoffice/types/technology.types";
+import { Product } from "../../backoffice/types/product.types";
+import {
+  PricingMeasure,
+  Currency,
+} from "../../backoffice/types/static/pricing.types";
+import { Requirement } from "../../backoffice/types/requirement.types";
+import { BlockingCondition } from "../../backoffice/types/static/blocking-condition.types";
+import { TreatmentBenefit } from "../../backoffice/types/static/treatment-benefit.types";
+import { CertificationRequirement } from "../../backoffice/types/static/certification.types";
+import { DocumentTemplate } from "../documentation-templates";
+
+/**
+ * Procedure represents a specific medical procedure that can be performed by a practitioner in a clinic
+ * It inherits properties from technology and adds clinic/practitioner specific details
+ */
+export interface Procedure {
+  /** Unique identifier of the procedure */
+  id: string;
+  /** Name of the procedure */
+  name: string;
+  /** Detailed description of the procedure */
+  description: string;
+  /** Family of procedures this belongs to (aesthetics/surgery) */
+  family: ProcedureFamily;
+  /** Category this procedure belongs to */
+  category: Category;
+  /** Subcategory this procedure belongs to */
+  subcategory: Subcategory;
+  /** Technology used in this procedure */
+  technology: Technology;
+  /** Product used in this procedure */
+  product: Product;
+  /** Price of the procedure */
+  price: number;
+  /** Currency for the price */
+  currency: Currency;
+  /** How the price is measured (per ml, per zone, etc.) */
+  pricingMeasure: PricingMeasure;
+  /** Duration of the procedure in minutes */
+  duration: number;
+  /** Blocking conditions that prevent this procedure */
+  blockingConditions: BlockingCondition[];
+  /** Treatment benefits of this procedure */
+  treatmentBenefits: TreatmentBenefit[];
+  /** Pre-procedure requirements */
+  preRequirements: Requirement[];
+  /** Post-procedure requirements */
+  postRequirements: Requirement[];
+  /** Certification requirements for performing this procedure */
+  certificationRequirement: CertificationRequirement;
+  /** Documentation templates required for this procedure */
+  documentationTemplates: DocumentTemplate[];
+  /** ID of the practitioner who performs this procedure */
+  practitionerId: string;
+  /** ID of the clinic branch where this procedure is performed */
+  clinicBranchId: string;
+  /** Whether this procedure is active */
+  isActive: boolean;
+  /** When this procedure was created */
+  createdAt: Date;
+  /** When this procedure was last updated */
+  updatedAt: Date;
+}
+
+/**
+ * Data required to create a new procedure
+ */
+export interface CreateProcedureData {
+  name: string;
+  description: string;
+  family: ProcedureFamily;
+  categoryId: string;
+  subcategoryId: string;
+  technologyId: string;
+  productId: string;
+  price: number;
+  currency: Currency;
+  pricingMeasure: PricingMeasure;
+  duration: number;
+  practitionerId: string;
+  clinicBranchId: string;
+}
+
+/**
+ * Data that can be updated for an existing procedure
+ */
+export interface UpdateProcedureData {
+  name?: string;
+  description?: string;
+  price?: number;
+  currency?: Currency;
+  pricingMeasure?: PricingMeasure;
+  duration?: number;
+  isActive?: boolean;
+}
+
+/**
+ * Collection name for procedures in Firestore
+ */
+export const PROCEDURES_COLLECTION = "procedures";

package/src/validations/procedure.schema.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { ProcedureFamily } from "../backoffice/types/static/procedure-family.types";
+import {
+  Currency,
+  PricingMeasure,
+} from "../backoffice/types/static/pricing.types";
+
+/**
+ * Schema for creating a new procedure
+ */
+export const createProcedureSchema = z.object({
+  name: z.string().min(1).max(200),
+  description: z.string().min(1).max(2000),
+  family: z.nativeEnum(ProcedureFamily),
+  categoryId: z.string().min(1),
+  subcategoryId: z.string().min(1),
+  technologyId: z.string().min(1),
+  productId: z.string().min(1),
+  price: z.number().min(0),
+  currency: z.nativeEnum(Currency),
+  pricingMeasure: z.nativeEnum(PricingMeasure),
+  duration: z.number().min(1).max(480), // Max 8 hours
+  practitionerId: z.string().min(1),
+  clinicBranchId: z.string().min(1),
+});
+
+/**
+ * Schema for updating an existing procedure
+ */
+export const updateProcedureSchema = z.object({
+  name: z.string().min(1).max(200).optional(),
+  description: z.string().min(1).max(2000).optional(),
+  price: z.number().min(0).optional(),
+  currency: z.nativeEnum(Currency).optional(),
+  pricingMeasure: z.nativeEnum(PricingMeasure).optional(),
+  duration: z.number().min(1).max(480).optional(), // Max 8 hours
+  isActive: z.boolean().optional(),
+});
+
+/**
+ * Schema for validating a complete procedure object
+ */
+export const procedureSchema = createProcedureSchema.extend({
+  id: z.string().min(1),
+  category: z.any(), // We'll validate the full category object separately
+  subcategory: z.any(), // We'll validate the full subcategory object separately
+  technology: z.any(), // We'll validate the full technology object separately
+  product: z.any(), // We'll validate the full product object separately
+  blockingConditions: z.array(z.any()), // We'll validate blocking conditions separately
+  treatmentBenefits: z.array(z.any()), // We'll validate treatment benefits separately
+  preRequirements: z.array(z.any()), // We'll validate requirements separately
+  postRequirements: z.array(z.any()), // We'll validate requirements separately
+  certificationRequirement: z.any(), // We'll validate certification requirement separately
+  documentationTemplates: z.array(z.any()), // We'll validate documentation templates separately
+  isActive: z.boolean(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});