@blackcode_sa/metaestetics-api 1.10.0 → 1.11.1

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

@@ -0,0 +1,268 @@
+import {
+  arrayRemove,
+  arrayUnion,
+  collection,
+  doc,
+  getDoc,
+  setDoc,
+  updateDoc,
+} from "firebase/firestore";
+import { BaseService } from "../../services/base.service";
+import {
+  ContraindicationDynamic,
+  ContraindicationsDocument,
+  TreatmentBenefitDynamic,
+  TreatmentBenefitsDocument,
+} from "../types/admin-constants.types";
+
+const ADMIN_CONSTANTS_COLLECTION = "admin-constants";
+const TREATMENT_BENEFITS_DOC = "treatment-benefits";
+const CONTRAINDICATIONS_DOC = "contraindications";
+
+/**
+ * @class ConstantsService
+ * @description Service for managing administrative constants, such as treatment benefits and contraindications.
+ * These constants are stored in a single Firestore collection 'admin-constants',
+ * with each type of constant in its own document ('treatment-benefits', 'contraindications').
+ * The constants themselves are stored in an array within these documents.
+ * @extends {BaseService}
+ */
+export class ConstantsService extends BaseService {
+  /**
+   * @description Gets the reference to the document holding treatment benefits.
+   * @private
+   * @type {DocumentReference}
+   */
+  private get treatmentBenefitsDocRef() {
+    return doc(this.db, ADMIN_CONSTANTS_COLLECTION, TREATMENT_BENEFITS_DOC);
+  }
+
+  /**
+   * @description Gets the reference to the document holding contraindications.
+   * @private
+   * @type {DocumentReference}
+   */
+  private get contraindicationsDocRef() {
+    return doc(this.db, ADMIN_CONSTANTS_COLLECTION, CONTRAINDICATIONS_DOC);
+  }
+
+  // =================================================================
+  // Treatment Benefits
+  // =================================================================
+
+  /**
+   * @description Retrieves all treatment benefits.
+   * @returns {Promise<TreatmentBenefitDynamic[]>} An array of all treatment benefits.
+   */
+  async getAllBenefits(): Promise<TreatmentBenefitDynamic[]> {
+    const docSnap = await getDoc(this.treatmentBenefitsDocRef);
+    if (!docSnap.exists()) {
+      return [];
+    }
+    return (docSnap.data() as TreatmentBenefitsDocument).benefits;
+  }
+
+  /**
+   * @description Adds a new treatment benefit.
+   * @param {Omit<TreatmentBenefitDynamic, "id">} benefit - The treatment benefit to add, without an ID.
+   * @returns {Promise<TreatmentBenefitDynamic>} The newly created treatment benefit with its generated ID.
+   */
+  async addTreatmentBenefit(
+    benefit: Omit<TreatmentBenefitDynamic, "id">
+  ): Promise<TreatmentBenefitDynamic> {
+    const newBenefit: TreatmentBenefitDynamic = {
+      id: this.generateId(),
+      ...benefit,
+    };
+
+    const docSnap = await getDoc(this.treatmentBenefitsDocRef);
+    if (!docSnap.exists()) {
+      await setDoc(this.treatmentBenefitsDocRef, { benefits: [newBenefit] });
+    } else {
+      await updateDoc(this.treatmentBenefitsDocRef, {
+        benefits: arrayUnion(newBenefit),
+      });
+    }
+
+    return newBenefit;
+  }
+
+  /**
+   * @description Retrieves a single treatment benefit by its ID.
+   * @param {string} benefitId - The ID of the treatment benefit to retrieve.
+   * @returns {Promise<TreatmentBenefitDynamic | undefined>} The found treatment benefit or undefined.
+   */
+  async getBenefitById(
+    benefitId: string
+  ): Promise<TreatmentBenefitDynamic | undefined> {
+    const benefits = await this.getAllBenefits();
+    return benefits.find((b) => b.id === benefitId);
+  }
+
+  /**
+   * @description Searches for treatment benefits by name (case-insensitive).
+   * @param {string} searchTerm - The term to search for in the benefit names.
+   * @returns {Promise<TreatmentBenefitDynamic[]>} An array of matching treatment benefits.
+   */
+  async searchBenefitsByName(
+    searchTerm: string
+  ): Promise<TreatmentBenefitDynamic[]> {
+    const benefits = await this.getAllBenefits();
+    const normalizedSearchTerm = searchTerm.toLowerCase();
+    return benefits.filter((b) =>
+      b.name.toLowerCase().includes(normalizedSearchTerm)
+    );
+  }
+
+  /**
+   * @description Updates an existing treatment benefit.
+   * @param {TreatmentBenefitDynamic} benefit - The treatment benefit with updated data. Its ID must match an existing benefit.
+   * @returns {Promise<TreatmentBenefitDynamic>} The updated treatment benefit.
+   * @throws {Error} If the treatment benefit is not found.
+   */
+  async updateTreatmentBenefit(
+    benefit: TreatmentBenefitDynamic
+  ): Promise<TreatmentBenefitDynamic> {
+    const benefits = await this.getAllBenefits();
+    const benefitIndex = benefits.findIndex((b) => b.id === benefit.id);
+
+    if (benefitIndex === -1) {
+      throw new Error("Treatment benefit not found.");
+    }
+
+    benefits[benefitIndex] = benefit;
+
+    await updateDoc(this.treatmentBenefitsDocRef, { benefits });
+    return benefit;
+  }
+
+  /**
+   * @description Deletes a treatment benefit by its ID.
+   * @param {string} benefitId - The ID of the treatment benefit to delete.
+   * @returns {Promise<void>}
+   */
+  async deleteTreatmentBenefit(benefitId: string): Promise<void> {
+    const benefits = await this.getAllBenefits();
+    const benefitToRemove = benefits.find((b) => b.id === benefitId);
+
+    if (!benefitToRemove) {
+      return;
+    }
+
+    await updateDoc(this.treatmentBenefitsDocRef, {
+      benefits: arrayRemove(benefitToRemove),
+    });
+  }
+
+  // =================================================================
+  // Contraindications
+  // =================================================================
+
+  /**
+   * @description Retrieves all contraindications.
+   * @returns {Promise<ContraindicationDynamic[]>} An array of all contraindications.
+   */
+  async getAllContraindications(): Promise<ContraindicationDynamic[]> {
+    const docSnap = await getDoc(this.contraindicationsDocRef);
+    if (!docSnap.exists()) {
+      return [];
+    }
+    return (docSnap.data() as ContraindicationsDocument).contraindications;
+  }
+
+  /**
+   * @description Adds a new contraindication.
+   * @param {Omit<ContraindicationDynamic, "id">} contraindication - The contraindication to add, without an ID.
+   * @returns {Promise<ContraindicationDynamic>} The newly created contraindication with its generated ID.
+   */
+  async addContraindication(
+    contraindication: Omit<ContraindicationDynamic, "id">
+  ): Promise<ContraindicationDynamic> {
+    const newContraindication: ContraindicationDynamic = {
+      id: this.generateId(),
+      ...contraindication,
+    };
+
+    const docSnap = await getDoc(this.contraindicationsDocRef);
+    if (!docSnap.exists()) {
+      await setDoc(this.contraindicationsDocRef, {
+        contraindications: [newContraindication],
+      });
+    } else {
+      await updateDoc(this.contraindicationsDocRef, {
+        contraindications: arrayUnion(newContraindication),
+      });
+    }
+
+    return newContraindication;
+  }
+
+  /**
+   * @description Retrieves a single contraindication by its ID.
+   * @param {string} contraindicationId - The ID of the contraindication to retrieve.
+   * @returns {Promise<ContraindicationDynamic | undefined>} The found contraindication or undefined.
+   */
+  async getContraindicationById(
+    contraindicationId: string
+  ): Promise<ContraindicationDynamic | undefined> {
+    const contraindications = await this.getAllContraindications();
+    return contraindications.find((c) => c.id === contraindicationId);
+  }
+
+  /**
+   * @description Searches for contraindications by name (case-insensitive).
+   * @param {string} searchTerm - The term to search for in the contraindication names.
+   * @returns {Promise<ContraindicationDynamic[]>} An array of matching contraindications.
+   */
+  async searchContraindicationsByName(
+    searchTerm: string
+  ): Promise<ContraindicationDynamic[]> {
+    const contraindications = await this.getAllContraindications();
+    const normalizedSearchTerm = searchTerm.toLowerCase();
+    return contraindications.filter((c) =>
+      c.name.toLowerCase().includes(normalizedSearchTerm)
+    );
+  }
+
+  /**
+   * @description Updates an existing contraindication.
+   * @param {ContraindicationDynamic} contraindication - The contraindication with updated data. Its ID must match an existing one.
+   * @returns {Promise<ContraindicationDynamic>} The updated contraindication.
+   * @throws {Error} If the contraindication is not found.
+   */
+  async updateContraindication(
+    contraindication: ContraindicationDynamic
+  ): Promise<ContraindicationDynamic> {
+    const contraindications = await this.getAllContraindications();
+    const index = contraindications.findIndex(
+      (c) => c.id === contraindication.id
+    );
+
+    if (index === -1) {
+      throw new Error("Contraindication not found.");
+    }
+
+    contraindications[index] = contraindication;
+
+    await updateDoc(this.contraindicationsDocRef, { contraindications });
+    return contraindication;
+  }
+
+  /**
+   * @description Deletes a contraindication by its ID.
+   * @param {string} contraindicationId - The ID of the contraindication to delete.
+   * @returns {Promise<void>}
+   */
+  async deleteContraindication(contraindicationId: string): Promise<void> {
+    const contraindications = await this.getAllContraindications();
+    const toRemove = contraindications.find((c) => c.id === contraindicationId);
+
+    if (!toRemove) {
+      return;
+    }
+
+    await updateDoc(this.contraindicationsDocRef, {
+      contraindications: arrayRemove(toRemove),
+    });
+  }
+}

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

@@ -14,8 +14,8 @@ import {
 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";
-import { TreatmentBenefit } from "../types/static/treatment-benefit.types";
+import { ContraindicationDynamic } from "../types/admin-constants.types";
+import { TreatmentBenefitDynamic } from "../types/admin-constants.types";
 import {
   CertificationLevel,
   CertificationSpecialty,
@@ -346,12 +346,21 @@ export class TechnologyService extends BaseService {
    */
   async addContraindication(
     technologyId: string,
-    contraindication: Contraindication
+    contraindication: ContraindicationDynamic
   ) {
     const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const existingContraindications = technology.contraindications || [];
+    if (existingContraindications.some((c) => c.id === contraindication.id)) {
+      return technology; // Already exists, do nothing
+    }
 
     await updateDoc(docRef, {
-      contraindications: arrayUnion(contraindication),
+      contraindications: [...existingContraindications, contraindication],
       updatedAt: new Date(),
     });
 
@@ -366,12 +375,62 @@ export class TechnologyService extends BaseService {
    */
   async removeContraindication(
     technologyId: string,
-    contraindication: Contraindication
+    contraindication: ContraindicationDynamic
   ) {
     const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const updatedContraindications = (
+      technology.contraindications || []
+    ).filter((c) => c.id !== contraindication.id);
+
+    await updateDoc(docRef, {
+      contraindications: updatedContraindications,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Updates an existing contraindication in a technology's list.
+   * If the contraindication does not exist, it will not be added.
+   * @param technologyId - ID of the technology
+   * @param contraindication - The updated contraindication object
+   * @returns The updated technology
+   */
+  async updateContraindication(
+    technologyId: string,
+    contraindication: ContraindicationDynamic
+  ) {
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const contraindications = technology.contraindications || [];
+    const index = contraindications.findIndex(
+      (c) => c.id === contraindication.id
+    );
+
+    if (index === -1) {
+      // If contraindication doesn't exist, do not update
+      // Consider throwing an error if this is an unexpected state
+      console.warn(
+        `Contraindication with id ${contraindication.id} not found for technology ${technologyId}. No update performed.`
+      );
+      return technology;
+    }
+
+    const updatedContraindications = [...contraindications];
+    updatedContraindications[index] = contraindication;
 
     await updateDoc(docRef, {
-      contraindications: arrayRemove(contraindication),
+      contraindications: updatedContraindications,
       updatedAt: new Date(),
     });
 
@@ -384,11 +443,20 @@ export class TechnologyService extends BaseService {
    * @param benefit - Benefit koji se dodaje
    * @returns Ažurirana tehnologija
    */
-  async addBenefit(technologyId: string, benefit: TreatmentBenefit) {
+  async addBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
     const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const existingBenefits = technology.benefits || [];
+    if (existingBenefits.some((b) => b.id === benefit.id)) {
+      return technology; // Already exists, do nothing
+    }
 
     await updateDoc(docRef, {
-      benefits: arrayUnion(benefit),
+      benefits: [...existingBenefits, benefit],
       updatedAt: new Date(),
     });
 
@@ -401,11 +469,55 @@ export class TechnologyService extends BaseService {
    * @param benefit - Benefit koji se uklanja
    * @returns Ažurirana tehnologija
    */
-  async removeBenefit(technologyId: string, benefit: TreatmentBenefit) {
+  async removeBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
     const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const updatedBenefits = (technology.benefits || []).filter(
+      (b) => b.id !== benefit.id
+    );
+
+    await updateDoc(docRef, {
+      benefits: updatedBenefits,
+      updatedAt: new Date(),
+    });
+
+    return this.getById(technologyId);
+  }
+
+  /**
+   * Updates an existing benefit in a technology's list.
+   * If the benefit does not exist, it will not be added.
+   * @param technologyId - ID of the technology
+   * @param benefit - The updated benefit object
+   * @returns The updated technology
+   */
+  async updateBenefit(technologyId: string, benefit: TreatmentBenefitDynamic) {
+    const docRef = doc(this.getTechnologiesRef(), technologyId);
+    const technology = await this.getById(technologyId);
+    if (!technology) {
+      throw new Error(`Technology with id ${technologyId} not found`);
+    }
+
+    const benefits = technology.benefits || [];
+    const index = benefits.findIndex((b) => b.id === benefit.id);
+
+    if (index === -1) {
+      // If benefit doesn't exist, do not update
+      console.warn(
+        `Benefit with id ${benefit.id} not found for technology ${technologyId}. No update performed.`
+      );
+      return technology;
+    }
+
+    const updatedBenefits = [...benefits];
+    updatedBenefits[index] = benefit;
 
     await updateDoc(docRef, {
-      benefits: arrayRemove(benefit),
+      benefits: updatedBenefits,
       updatedAt: new Date(),
     });
 

package/src/backoffice/types/admin-constants.types.ts

@@ -0,0 +1,69 @@
+/**
+ * @file Defines types for dynamically managed administrative constants,
+ * such as treatment benefits and contraindications. These are stored in
+ * the 'admin-constants' collection in Firestore.
+ */
+
+/**
+ * Represents a single dynamic treatment benefit.
+ * These are positive effects or results a patient can expect from a treatment.
+ */
+export interface TreatmentBenefitDynamic {
+  /**
+   * A unique identifier for the benefit, typically in snake_case.
+   * @example "wrinkle_reduction"
+   */
+  id: string;
+
+  /**
+   * A human-readable name for the treatment benefit.
+   * @example "Wrinkle Reduction"
+   */
+  name: string;
+
+  /**
+   * A detailed description of the benefit.
+   */
+  description?: string;
+}
+
+/**
+ * Defines the structure of the document storing all treatment benefits
+ * in the 'admin-constants' collection.
+ * The document ID for this type should be 'treatment-benefits'.
+ */
+export interface TreatmentBenefitsDocument {
+  benefits: TreatmentBenefitDynamic[];
+}
+
+/**
+ * Represents a single dynamic contraindication.
+ * These are conditions or factors that can affect a procedure and require special attention.
+ */
+export interface ContraindicationDynamic {
+  /**
+   * A unique identifier for the contraindication, typically in snake_case.
+   * @example "sensitive_skin"
+   */
+  id: string;
+
+  /**
+   * A human-readable name for the contraindication.
+   * @example "Sensitive Skin"
+   */
+  name: string;
+
+  /**
+   * A detailed description of the contraindication.
+   */
+  description?: string;
+}
+
+/**
+ * Defines the structure of the document storing all contraindications
+ * in the 'admin-constants' collection.
+ * The document ID for this type should be 'contraindications'.
+ */
+export interface ContraindicationsDocument {
+  contraindications: ContraindicationDynamic[];
+}

package/src/backoffice/types/index.ts

@@ -6,3 +6,4 @@ export * from "./requirement.types";
 export * from "./subcategory.types";
 export * from "./technology.types";
 export * from "./static";
+export * from "./admin-constants.types";

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

@@ -1,3 +1,5 @@
+import type { ContraindicationDynamic } from "./admin-constants.types";
+
 /**
  * Product used in procedures
  * Can be consumables, equipment, or any other product needed for performing procedures
@@ -33,7 +35,7 @@ export interface Product {
   dosage?: string;
   composition?: string;
   indications?: string[];
-  contraindications?: string[];
+  contraindications?: ContraindicationDynamic[];
 }
 
 /**

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

@@ -1,10 +1,10 @@
 import { Requirement } from "./requirement.types";
 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";
 import { ProcedureFamily } from "./static/procedure-family.types";
+import { ContraindicationDynamic } from "./admin-constants.types";
+import { TreatmentBenefitDynamic } from "./admin-constants.types";
 
 /**
  * Reference to a documentation template with metadata
@@ -65,8 +65,8 @@ export interface Technology {
     post: Requirement[];
   };
   blockingConditions: BlockingCondition[];
-  contraindications: Contraindication[];
-  benefits: TreatmentBenefit[];
+  contraindications: ContraindicationDynamic[];
+  benefits: TreatmentBenefitDynamic[];
   certificationRequirement: CertificationRequirement;
   documentationTemplates?: TechnologyDocumentationTemplate[];
   isActive: boolean;

package/src/backoffice/validations/schemas.ts

@@ -1,27 +1,53 @@
 import { z } from "zod";
 import { ProcedureFamily } from "../types/static/procedure-family.types";
 import { BlockingCondition } from "../types/static/blocking-condition.types";
-import { Contraindication } from "../types/static/contraindication.types";
-import { TreatmentBenefit } from "../types/static/treatment-benefit.types";
 import { TimeUnit, RequirementType } from "../types/requirement.types";
 import {
   CertificationLevel,
   CertificationSpecialty,
 } from "../types/static/certification.types";
-import {
-  DocumentElementType,
-  HeadingLevel,
-  ListType,
-} from "../types/documentation-templates.types";
+
 import { documentTemplateSchema } from "../../validations/documentation-templates.schema";
 
+/**
+ * Zod validation schema for a single dynamic contraindication.
+ * @see ContraindicationDynamic in admin-constants.types.ts
+ */
+export const contraindicationDynamicSchema = z.object({
+  id: z
+    .string()
+    .min(1, "Contraindication ID is required")
+    .regex(
+      /^[a-z0-9_]+$/,
+      "ID must be in snake_case (lowercase, numbers, and underscores only)"
+    ),
+  name: z.string().min(1, "Contraindication name is required"),
+  description: z.string().optional(),
+});
+
+/**
+ * Zod validation schema for a single dynamic treatment benefit.
+ * @see TreatmentBenefitDynamic in admin-constants.types.ts
+ */
+export const treatmentBenefitDynamicSchema = z.object({
+  id: z
+    .string()
+    .min(1, "Benefit ID is required")
+    .regex(
+      /^[a-z0-9_]+$/,
+      "ID must be in snake_case (lowercase, numbers, and underscores only)"
+    ),
+  name: z.string().min(1, "Benefit name is required"),
+  description: z.string().optional(),
+});
+
 /**
  * Base validation schemas for enums
  */
 export const blockingConditionSchemaBackoffice =
   z.nativeEnum(BlockingCondition);
-export const contraindicationSchemaBackoffice = z.nativeEnum(Contraindication);
-export const treatmentBenefitSchemaBackoffice = z.nativeEnum(TreatmentBenefit);
+export const contraindicationSchemaBackoffice = contraindicationDynamicSchema;
+export const treatmentBenefitSchemaBackoffice = treatmentBenefitDynamicSchema;
 export const procedureFamilySchemaBackoffice = z.nativeEnum(ProcedureFamily);
 export const timeUnitSchemaBackoffice = z.nativeEnum(TimeUnit);
 export const requirementTypeSchema = z.nativeEnum(RequirementType);

package/src/services/appointment/appointment.service.ts

@@ -21,18 +21,15 @@ import { BaseService } from "../base.service";
 import {
   Appointment,
   AppointmentStatus,
-  CreateAppointmentData,
   UpdateAppointmentData,
   SearchAppointmentsParams,
   PaymentStatus,
   AppointmentMediaItem,
   PatientReviewInfo,
-  LinkedFormInfo,
   type CreateAppointmentHttpData,
   APPOINTMENTS_COLLECTION,
 } from "../../types/appointment";
 import {
-  createAppointmentSchema,
   updateAppointmentSchema,
   searchAppointmentsSchema,
   rescheduleAppointmentSchema,
@@ -47,8 +44,6 @@ import { FilledDocumentService } from "../documentation-templates/filled-documen
 
 // Import utility functions
 import {
-  fetchAggregatedInfoUtil,
-  createAppointmentUtil,
   updateAppointmentUtil,
   getAppointmentByIdUtil,
   searchAppointmentsUtil,