@blackcode_sa/metaestetics-api 1.5.2 → 1.5.4

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/index.ts

@@ -14,9 +14,9 @@ export interface User {
   email: string | null;
   roles: UserRole[];
   isAnonymous: boolean;
-  createdAt: Timestamp;
-  updatedAt: Timestamp;
-  lastLoginAt: Timestamp;
+  createdAt: Timestamp | FieldValue;
+  updatedAt: Timestamp | FieldValue;
+  lastLoginAt: Timestamp | FieldValue;
   patientProfile?: string;
   practitionerProfile?: string;
   adminProfile?: string;

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(),
+});

package/src/validations/schemas.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { UserRole } from "../types";
-import { Timestamp } from "firebase/firestore";
+import { Timestamp, FieldValue } from "firebase/firestore";
 
 export const emailSchema = z
   .string()
@@ -24,7 +24,13 @@ export const userRolesSchema = z
   .min(1, "User must have at least one role")
   .max(3, "User cannot have more than 3 roles");
 
-export const timestampSchema = z.custom<Timestamp>((data) => {
+export const timestampSchema = z.custom<Timestamp | FieldValue>((data) => {
+  // If it's a serverTimestamp (FieldValue), it's valid
+  if (data && typeof data === "object" && "isEqual" in data) {
+    return true;
+  }
+
+  // If it's a Timestamp object, validate its structure
   return (
     data &&
     typeof data === "object" &&
@@ -32,7 +38,7 @@ export const timestampSchema = z.custom<Timestamp>((data) => {
     "seconds" in data &&
     "nanoseconds" in data
   );
-}, "Must be a Timestamp object");
+}, "Must be a Timestamp object or serverTimestamp");
 
 /**
  * Validaciona šema za clinic admin opcije pri kreiranju