@blackcode_sa/metaestetics-api 1.5.3 → 1.5.4

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