@blackcode_sa/metaestetics-api 1.5.3 → 1.5.4

package/src/backoffice/services/requirement.service.ts

@@ -8,14 +8,13 @@ import {
   updateDoc,
   where,
 } from "firebase/firestore";
-import { Requirement, RequirementType } from "../types/requirement.types";
+import {
+  Requirement,
+  RequirementType,
+  REQUIREMENTS_COLLECTION,
+} from "../types/requirement.types";
 import { BaseService } from "../../services/base.service";
 
-/**
- * Kolekcija u Firestore bazi gde se čuvaju globalni zahtevi
- */
-const COLLECTION = "backoffice_requirements";
-
 /**
  * Servis za upravljanje globalnim zahtevima.
  * Zahtevi se mogu kreirati globalno i zatim povezati sa različitim tehnologijama.
@@ -42,7 +41,7 @@ export class RequirementService extends BaseService {
    * Referenca na Firestore kolekciju zahteva
    */
   private get requirementsRef() {
-    return collection(this.db, COLLECTION);
+    return collection(this.db, REQUIREMENTS_COLLECTION);
   }
 
   /**

package/src/backoffice/services/subcategory.service.ts

@@ -8,14 +8,12 @@ import {
   updateDoc,
   where,
 } from "firebase/firestore";
-import { Subcategory } from "../types/subcategory.types";
+import {
+  Subcategory,
+  SUBCATEGORIES_COLLECTION,
+} from "../types/subcategory.types";
 import { BaseService } from "../../services/base.service";
-
-/**
- * Kolekcije u Firestore bazi
- */
-const COLLECTION = "backoffice_categories";
-const SUB_COLLECTION = "subcategories";
+import { CATEGORIES_COLLECTION } from "../types/category.types";
 
 /**
  * Servis za upravljanje podkategorijama procedura.
@@ -36,7 +34,12 @@ export class SubcategoryService extends BaseService {
    * @param categoryId - ID roditeljske kategorije
    */
   private getSubcategoriesRef(categoryId: string) {
-    return collection(this.db, COLLECTION, categoryId, SUB_COLLECTION);
+    return collection(
+      this.db,
+      CATEGORIES_COLLECTION,
+      categoryId,
+      SUBCATEGORIES_COLLECTION
+    );
   }
 
   /**

package/src/backoffice/services/technology.service.ts

@@ -11,7 +11,7 @@ import {
   arrayRemove,
   Firestore,
 } from "firebase/firestore";
-import { Technology } from "../types/technology.types";
+import { Technology, TECHNOLOGIES_COLLECTION } from "../types/technology.types";
 import { Requirement, RequirementType } from "../types/requirement.types";
 import { BlockingCondition } from "../types/static/blocking-condition.types";
 import { Contraindication } from "../types/static/contraindication.types";
@@ -22,13 +22,8 @@ import {
   CertificationRequirement,
 } from "../types/static/certification.types";
 import { BaseService } from "../../services/base.service";
-
-/**
- * Kolekcije u Firestore bazi
- */
-const COLLECTION = "backoffice_categories";
-const SUB_COLLECTION_SUBCATEGORIES = "subcategories";
-const SUB_COLLECTION_TECHNOLOGIES = "technologies";
+import { SUBCATEGORIES_COLLECTION } from "../types/subcategory.types";
+import { CATEGORIES_COLLECTION } from "../types/category.types";
 
 /**
  * Default vrednosti za sertifikaciju
@@ -68,11 +63,11 @@ export class TechnologyService extends BaseService {
   private getTechnologiesRef(categoryId: string, subcategoryId: string) {
     return collection(
       this.db,
-      COLLECTION,
+      CATEGORIES_COLLECTION,
       categoryId,
-      SUB_COLLECTION_SUBCATEGORIES,
+      SUBCATEGORIES_COLLECTION,
       subcategoryId,
-      SUB_COLLECTION_TECHNOLOGIES
+      TECHNOLOGIES_COLLECTION
     );
   }
 

package/src/backoffice/types/brand.types.ts

@@ -21,3 +21,8 @@ export interface Brand {
   website?: string;
   description?: string;
 }
+
+/**
+ * Kolekcija u Firestore bazi gde se čuvaju brendovi
+ */
+export const BRANDS_COLLECTION = "brands";

package/src/backoffice/types/category.types.ts

@@ -29,3 +29,8 @@ export interface Category {
   /** Flag koji označava da li je kategorija aktivna */
   isActive: boolean;
 }
+
+/**
+ * Kolekcija u Firestore bazi gde se čuvaju kategorije
+ */
+export const CATEGORIES_COLLECTION = "backoffice_categories";

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

@@ -7,6 +7,8 @@ import {
   HeadingLevel,
   ListType,
   DynamicVariable,
+  DOCUMENTATION_TEMPLATES_COLLECTION,
+  FILLED_DOCUMENTS_COLLECTION,
 } from "../../types/documentation-templates";
 
 /**
@@ -22,3 +24,5 @@ export {
   ListType,
   DynamicVariable,
 };
+
+export { DOCUMENTATION_TEMPLATES_COLLECTION, FILLED_DOCUMENTS_COLLECTION };

package/src/backoffice/types/product.types.ts

@@ -33,3 +33,8 @@ export interface Product {
   indications?: string[];
   contraindications?: string[];
 }
+
+/**
+ * Kolekcija u Firestore bazi gde se čuvaju proizvodi
+ */
+export const PRODUCTS_COLLECTION = "products";

package/src/backoffice/types/requirement.types.ts

@@ -56,3 +56,8 @@ export interface Requirement {
   createdAt: Date;
   updatedAt: Date;
 }
+
+/**
+ * Kolekcija u Firestore bazi gde se čuvaju globalni zahtevi
+ */
+export const REQUIREMENTS_COLLECTION = "backoffice_requirements";

package/src/backoffice/types/subcategory.types.ts

@@ -27,3 +27,8 @@ export interface Subcategory {
   /** Datum poslednjeg ažuriranja podkategorije */
   updatedAt: Date;
 }
+
+/**
+ * Kolekcija u Firestore bazi gde se čuvaju podkategorije
+ */
+export const SUBCATEGORIES_COLLECTION = "subcategories";

package/src/backoffice/types/technology.types.ts

@@ -3,6 +3,7 @@ import { BlockingCondition } from "./static/blocking-condition.types";
 import { Contraindication } from "./static/contraindication.types";
 import { TreatmentBenefit } from "./static/treatment-benefit.types";
 import { CertificationRequirement } from "./static/certification.types";
+import { DocumentTemplate } from "../../types/documentation-templates";
 
 /**
  * Zahtevi koji su povezani sa tehnologijom
@@ -29,6 +30,7 @@ export interface TechnologyRequirements {
  * @property contraindications - List of conditions requiring special attention
  * @property benefits - List of expected benefits from the procedure
  * @property certificationRequirement - Required certification level and specialties
+ * @property documentationTemplates - List of documentation templates required for this technology
  * @property isActive - Whether the technology is active in the system
  * @property createdAt - Creation date
  * @property updatedAt - Last update date
@@ -66,6 +68,9 @@ export interface Technology {
   /** Potrebna sertifikacija za korišćenje tehnologije */
   certificationRequirement: CertificationRequirement;
 
+  /** Dokumentacioni šabloni potrebni za ovu tehnologiju */
+  documentationTemplates?: DocumentTemplate[];
+
   /** Da li je tehnologija trenutno aktivna */
   isActive: boolean;
 
@@ -75,3 +80,8 @@ export interface Technology {
   /** Datum poslednjeg ažuriranja */
   updatedAt: Date;
 }
+
+/**
+ * Kolekcija u Firestore bazi gde se čuvaju tehnologije
+ */
+export const TECHNOLOGIES_COLLECTION = "technologies";

package/src/backoffice/validations/schemas.ts

@@ -13,6 +13,7 @@ import {
   HeadingLevel,
   ListType,
 } from "../types/documentation-templates.types";
+import { documentTemplateSchema } from "../../validations/documentation-templates.schema";
 
 /**
  * Base validation schemas for enums
@@ -87,6 +88,7 @@ export const technologySchema = z.object({
   }),
   blockingConditions: z.array(blockingConditionSchema),
   contraindications: z.array(contraindicationSchema),
+  documentationTemplates: z.array(documentTemplateSchema),
   benefits: z.array(treatmentBenefitSchema),
   certificationRequirement: certificationRequirementSchema,
   isActive: z.boolean().default(true),

package/src/errors/auth.errors.ts

@@ -134,6 +134,13 @@ export const AUTH_ERRORS = {
     401
   ),
 
+  // Resource not found
+  NOT_FOUND: new AuthError(
+    "The requested resource was not found",
+    "AUTH/NOT_FOUND",
+    404
+  ),
+
   // Detailed password validation errors
   PASSWORD_LENGTH_ERROR: new AuthError(
     "Password must be at least 8 characters long",

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/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
  */