@blackcode_sa/metaestetics-api 1.11.3 → 1.12.1

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/brand.types.ts

@@ -14,6 +14,7 @@
 export interface Brand {
   id?: string;
   name: string;
+  name_lowercase: string;
   manufacturer: string;
   createdAt: Date;
   updatedAt: Date;

package/src/backoffice/types/index.ts

@@ -1,3 +1,4 @@
+export * from "./admin-constants.types";
 export * from "./brand.types";
 export * from "./category.types";
 export * from "./documentation-templates.types";
@@ -6,3 +7,4 @@ export * from "./requirement.types";
 export * from "./subcategory.types";
 export * from "./technology.types";
 export * from "./static";
+export * from "./procedure-product.types";

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

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Defines the ProcedureProduct type, which represents a product associated with a procedure,
+ * including its pricing information. This is used to allow procedures to have multiple products with different prices.
+ * @packageDocumentation
+ */
+import { Product } from "./product.types";
+import { Currency, PricingMeasure } from "./static/pricing.types";
+
+/**
+ * Represents a product associated with a procedure, including its specific pricing information.
+ */
+export interface ProcedureProduct {
+  /**
+   * The product used in the procedure.
+   * @see {@link Product}
+   */
+  product: Product;
+
+  /**
+   * The price of the procedure when using this specific product.
+   */
+  price: number;
+
+  /**
+   * The currency for the price of this product.
+   * @see {@link Currency}
+   */
+  currency: Currency;
+
+  /**
+   * How the price is measured (e.g., per ml, per zone).
+   * @see {@link PricingMeasure}
+   */
+  pricingMeasure: PricingMeasure;
+
+  // Default product
+  isDefault?: boolean;
+}

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
@@ -24,6 +26,8 @@ export interface Product {
   brandName: string;
   technologyId: string;
   technologyName: string;
+  categoryId: string;
+  subcategoryId: string;
   createdAt: Date;
   updatedAt: Date;
   isActive: boolean;
@@ -33,7 +37,7 @@ export interface Product {
   dosage?: string;
   composition?: string;
   indications?: string[];
-  contraindications?: string[];
+  contraindications?: ContraindicationDynamic[];
 }
 
 /**
@@ -61,10 +65,33 @@ export interface IProductService {
   ): Promise<Product>;
 
   /**
-   * Gets all products for a technology
-   * @param technologyId - ID of the technology
+   * Gets a paginated list of all products, with optional filters.
+   */
+  getAll(options: {
+    rowsPerPage: number;
+    lastVisible?: any;
+    categoryId?: string;
+    subcategoryId?: string;
+    technologyId?: string;
+  }): Promise<{ products: Product[]; lastVisible: any }>;
+
+  /**
+   * Gets the total count of active products, with optional filters.
+   */
+  getProductsCount(options: {
+    categoryId?: string;
+    subcategoryId?: string;
+    technologyId?: string;
+  }): Promise<number>;
+
+  /**
+   * Gets counts of active products grouped by category, subcategory, and technology.
    */
-  getAllByTechnology(technologyId: string): Promise<Product[]>;
+  getProductCounts(): Promise<{
+    byCategory: Record<string, number>;
+    bySubcategory: Record<string, number>;
+    byTechnology: Record<string, number>;
+  }>;
 
   /**
    * Gets all products for a brand

package/src/backoffice/types/static/contraindication.types.ts

@@ -1,4 +1,5 @@
 /**
+ * @deprecated
  * Kontraindikacije koje mogu uticati na proceduru
  * Ovi uslovi predstavljaju relativne kontraindikacije koje zahtevaju posebnu pažnju
  */

package/src/backoffice/types/static/treatment-benefit.types.ts

@@ -1,4 +1,5 @@
 /**
+ * @deprecated
  * Benefiti koji se mogu očekivati od procedure
  * Lista mogućih pozitivnih efekata i rezultata tretmana
  */

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;
@@ -78,3 +78,112 @@ export interface Technology {
  * Collection in Firestore database where technologies are stored
  */
 export const TECHNOLOGIES_COLLECTION = "technologies";
+
+/**
+ * Interface for the TechnologyService class
+ */
+export interface ITechnologyService {
+  create(
+    technology: Omit<Technology, "id" | "createdAt" | "updatedAt">
+  ): Promise<Technology>;
+  getTechnologyCounts(active?: boolean): Promise<Record<string, number>>;
+  getTechnologyCountsByCategory(
+    active?: boolean
+  ): Promise<Record<string, number>>;
+  getAll(options?: {
+    active?: boolean;
+    limit?: number;
+    lastVisible?: any;
+  }): Promise<{ technologies: Technology[]; lastVisible: any }>;
+  getAllByCategoryId(
+    categoryId: string,
+    options?: { active?: boolean; limit?: number; lastVisible?: any }
+  ): Promise<{ technologies: Technology[]; lastVisible: any }>;
+  getAllBySubcategoryId(
+    subcategoryId: string,
+    options?: { active?: boolean; limit?: number; lastVisible?: any }
+  ): Promise<{ technologies: Technology[]; lastVisible: any }>;
+  update(
+    id: string,
+    technology: Partial<Omit<Technology, "id" | "createdAt">>
+  ): Promise<Technology | null>;
+  delete(id: string): Promise<void>;
+  reactivate(id: string): Promise<void>;
+  getById(id: string): Promise<Technology | null>;
+  addRequirement(
+    technologyId: string,
+    requirement: Requirement
+  ): Promise<Technology | null>;
+  removeRequirement(
+    technologyId: string,
+    requirement: Requirement
+  ): Promise<Technology | null>;
+  getRequirements(
+    technologyId: string,
+    type?: "pre" | "post"
+  ): Promise<Requirement[]>;
+  updateRequirement(
+    technologyId: string,
+    oldRequirement: Requirement,
+    newRequirement: Requirement
+  ): Promise<Technology | null>;
+  addBlockingCondition(
+    technologyId: string,
+    condition: BlockingCondition
+  ): Promise<Technology | null>;
+  removeBlockingCondition(
+    technologyId: string,
+    condition: BlockingCondition
+  ): Promise<Technology | null>;
+  addContraindication(
+    technologyId: string,
+    contraindication: ContraindicationDynamic
+  ): Promise<Technology | null>;
+  removeContraindication(
+    technologyId: string,
+    contraindication: ContraindicationDynamic
+  ): Promise<Technology | null>;
+  updateContraindication(
+    technologyId: string,
+    contraindication: ContraindicationDynamic
+  ): Promise<Technology | null>;
+  addBenefit(
+    technologyId: string,
+    benefit: TreatmentBenefitDynamic
+  ): Promise<Technology | null>;
+  removeBenefit(
+    technologyId: string,
+    benefit: TreatmentBenefitDynamic
+  ): Promise<Technology | null>;
+  updateBenefit(
+    technologyId: string,
+    benefit: TreatmentBenefitDynamic
+  ): Promise<Technology | null>;
+  getBlockingConditions(technologyId: string): Promise<BlockingCondition[]>;
+  getContraindications(
+    technologyId: string
+  ): Promise<ContraindicationDynamic[]>;
+  getBenefits(technologyId: string): Promise<TreatmentBenefitDynamic[]>;
+  updateCertificationRequirement(
+    technologyId: string,
+    certificationRequirement: CertificationRequirement
+  ): Promise<Technology | null>;
+  getCertificationRequirement(
+    technologyId: string
+  ): Promise<CertificationRequirement | null>;
+  validateCertification(
+    requiredCertification: CertificationRequirement,
+    practitionerCertification: any
+  ): boolean;
+  getAllowedTechnologies(practitioner: any): Promise<{
+    technologies: Technology[];
+    families: ProcedureFamily[];
+    categories: string[];
+    subcategories: string[];
+  }>;
+  getAllForFilterBySubcategoryId(
+    categoryId: string,
+    subcategoryId: string
+  ): Promise<Technology[]>;
+  getAllForFilter(): Promise<Technology[]>;
+}

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,