@blackcode_sa/metaestetics-api 1.12.32 → 1.12.34

package/src/types/appointment/index.ts

@@ -76,8 +76,12 @@ export interface ProcedureExtendedInfo {
   procedureTechnologyName: string;
   procedureProductBrandId: string;
   procedureProductBrandName: string;
-  procedureProductId: string; // We need to have more than one product allowed in this data, this is coming from aggregation, so please update aggregation and this data type
-  procedureProductName: string; // We need to have more than one product allowed in this data, this is coming from aggregation, so please update aggregation and this data type
+  procedureProducts: Array<{
+    productId: string;
+    productName: string;
+    brandId: string;
+    brandName: string;
+  }>;
 }
 
 /**
@@ -132,26 +136,39 @@ export interface ZonePhotoUploadData {
 }
 
 /**
- * Interface for billing information per zone
+ * Interface for zone item data (products or notes per zone)
  */
-export interface BillingPerZone { // We should rename this to ZoneItemData and we should expend it as per our documentations (will be used for both zone items in step 3 and summary and pricing in the step 4)
-  /** Product name/description */
+export interface ZoneItemData {
+  productId?: string;
+  productName?: string;
+  productBrandId?: string;
+  productBrandName?: string;
+  belongingProcedureId: string;
+  type: 'item' | 'note';
+  price?: number;
+  currency?: Currency;
+  unitOfMeasurement?: PricingMeasure;
+  priceOverrideAmount?: number; // If set, takes precedence over price
+  quantity?: number;
+  parentZone: string; // Zone key in format "category.zone" (e.g., "face.forehead")
+  subzones: string[];
+  notes?: string;
+  subtotal?: number;
+  ionNumber?: string;
+}
+
+/**
+ * @deprecated Use ZoneItemData instead
+ */
+export interface BillingPerZone {
   Product: string;
-  /** Product ID */
   ProductId: string | null;
-  /** Quantity used (can be decimal) */
   Quantity: number;
-  /** Unit of measurement */
   UnitOfMeasurement: PricingMeasure;
-  /** Unit price for the product */
   UnitPrice: number;
-  /** Currency for the unit price */
   UnitCurency: Currency;
-  /** Calculated subtotal */
   Subtotal: number;
-  /** Optional billing note */
   Note: string | null;
-  /** Ion/Batch number for traceability */
   IonNumber: string | null;
 }
 
@@ -167,29 +184,61 @@ export interface FinalBilling {
   taxPrice: number;
   /** Final price including tax */
   finalPrice: number;
-  /** Total final quantity across all zones */
-  finalQuantity: number; // Not sure we should keep this as well, we keep track of this per item
   /** Currency for the final billing */
   currency: Currency;
-  /** Unit of measurement for the final billing */
-  unitOfMeasurement: PricingMeasure; // NO need to keep this, we keep track of this per item
+}
+
+/**
+ * Interface for product metadata in appointment
+ */
+export interface AppointmentProductMetadata {
+  productId: string;
+  productName: string;
+  brandId: string;
+  brandName: string;
+  procedureId: string;
+  price: number;
+  currency: Currency;
+  unitOfMeasurement: PricingMeasure;
+}
+
+/**
+ * Interface for extended procedures in appointment
+ */
+export interface ExtendedProcedureInfo {
+  procedureId: string;
+  procedureName: string;
+  procedureFamily?: ProcedureFamily;
+  procedureCategoryId: string;
+  procedureCategoryName: string;
+  procedureSubCategoryId: string;
+  procedureSubCategoryName: string;
+  procedureTechnologyId: string;
+  procedureTechnologyName: string;
+  procedureProducts: Array<{
+    productId: string;
+    productName: string;
+    brandId: string;
+    brandName: string;
+  }>;
 }
 
 /**
  * Interface for appointment metadata containing zone-specific information
  */
 export interface AppointmentMetadata {
-  /** Array of selected zones for the appointment */
-  selectedZones: string[] | null; // We are not going to accept any structure (category.zone.subzone), here we will only accept zone (category.zone), nothing more, nothing less
-  /** Map of zone photos with before/after images and notes */
-  zonePhotos: Record<string, BeforeAfterPerZone> | null; // head.forhead: {object}, head: {object}, but it can't have head.forhead.forhedLeft: {object}
-  /** Map of billing information per zone */
-  zoneBilling: Record<string, BillingPerZone> | null; // This is going to change, name it zonesData, and expand this to accept more than one item per key (which is basically zone like category.zone)
-  /** Final billing calculations for the appointment */
+  selectedZones: string[] | null;
+  zonePhotos: Record<string, BeforeAfterPerZone> | null;
+  zonesData?: Record<string, ZoneItemData[]> | null;
+  appointmentProducts?: AppointmentProductMetadata[];
+  extendedProcedures?: ExtendedProcedureInfo[];
   finalbilling: FinalBilling | null;
-  /** Final note for the appointment */
   finalizationNotes: string | null;
-  // TO-DO: We need to add extended procedures info (when we add multiple procedures, different than default one defined above)
+  
+  /**
+   * @deprecated Use zonesData instead
+   */
+  zoneBilling?: Record<string, BillingPerZone> | null;
 }
 
 /**

package/src/validations/appointment.schema.ts

@@ -53,8 +53,14 @@ export const procedureExtendedInfoSchema = z.object({
   procedureTechnologyName: z.string(),
   procedureProductBrandId: z.string(),
   procedureProductBrandName: z.string(),
-  procedureProductId: z.string(),
-  procedureProductName: z.string(),
+  procedureProducts: z.array(
+    z.object({
+      productId: z.string().min(MIN_STRING_LENGTH, 'Product ID is required'),
+      productName: z.string().min(MIN_STRING_LENGTH, 'Product name is required'),
+      brandId: z.string().min(MIN_STRING_LENGTH, 'Brand ID is required'),
+      brandName: z.string().min(MIN_STRING_LENGTH, 'Brand name is required'),
+    })
+  ),
 });
 
 export const linkedFormInfoSchema = z.object({
@@ -164,18 +170,108 @@ export const finalBillingSchema = z.object({
   taxRate: z.number().min(0).max(1, 'Tax rate must be between 0 and 1'),
   taxPrice: z.number().min(0, 'Tax price must be non-negative'),
   finalPrice: z.number().min(0, 'Final price must be non-negative'),
-  finalQuantity: z.number().min(0, 'Final quantity must be non-negative'),
+  currency: z.nativeEnum(Currency),
+});
+
+/**
+ * Schema for zone item data (product or note per zone)
+ */
+export const zoneItemDataSchema = z.object({
+  productId: z.string().optional(),
+  productName: z.string().optional(),
+  productBrandId: z.string().optional(),
+  productBrandName: z.string().optional(),
+  belongingProcedureId: z.string().min(MIN_STRING_LENGTH, 'Belonging procedure ID is required'),
+  type: z.enum(['item', 'note'], {
+    required_error: 'Type must be either "item" or "note"',
+  }),
+  price: z.number().min(0, 'Price must be non-negative').optional(),
+  currency: z.nativeEnum(Currency).optional(),
+  unitOfMeasurement: z.nativeEnum(PricingMeasure).optional(),
+  priceOverrideAmount: z.number().min(0, 'Price override amount must be non-negative').optional(),
+  quantity: z.number().min(0, 'Quantity must be non-negative').optional(),
+  parentZone: z.string().min(MIN_STRING_LENGTH, 'Parent zone is required').refine(
+    val => {
+      const parts = val.split('.');
+      return parts.length === 2;
+    },
+    {
+      message: 'Parent zone must be in "category.zone" format (e.g., "face.forehead")',
+    }
+  ),
+  subzones: z.array(z.string()).refine(
+    val => {
+      return val.every(subzone => {
+        const parts = subzone.split('.');
+        return parts.length === 3;
+      });
+    },
+    {
+      message: 'Subzones must be in "category.zone.subzone" format (e.g., "face.forehead.left")',
+    }
+  ),
+  notes: z.string().max(MAX_STRING_LENGTH_LONG, 'Notes too long').optional(),
+  subtotal: z.number().min(0, 'Subtotal must be non-negative').optional(),
+  ionNumber: z.string().optional(),
+}).refine(
+  data => {
+    if (data.type === 'item') {
+      return !!(data.productId && data.productName && (data.price || data.priceOverrideAmount));
+    }
+    return true;
+  },
+  {
+    message: 'Item type requires productId, productName, and either price or priceOverrideAmount',
+  }
+);
+
+/**
+ * Schema for appointment product metadata
+ */
+export const appointmentProductMetadataSchema = z.object({
+  productId: z.string().min(MIN_STRING_LENGTH, 'Product ID is required'),
+  productName: z.string().min(MIN_STRING_LENGTH, 'Product name is required'),
+  brandId: z.string().min(MIN_STRING_LENGTH, 'Brand ID is required'),
+  brandName: z.string().min(MIN_STRING_LENGTH, 'Brand name is required'),
+  procedureId: z.string().min(MIN_STRING_LENGTH, 'Procedure ID is required'),
+  price: z.number().min(0, 'Price must be non-negative'),
   currency: z.nativeEnum(Currency),
   unitOfMeasurement: z.nativeEnum(PricingMeasure),
 });
 
+/**
+ * Schema for extended procedure info
+ */
+export const extendedProcedureInfoSchema = z.object({
+  procedureId: z.string().min(MIN_STRING_LENGTH, 'Procedure ID is required'),
+  procedureName: z.string().min(MIN_STRING_LENGTH, 'Procedure name is required'),
+  procedureFamily: z.any(),
+  procedureCategoryId: z.string().min(MIN_STRING_LENGTH, 'Category ID is required'),
+  procedureCategoryName: z.string().min(MIN_STRING_LENGTH, 'Category name is required'),
+  procedureSubCategoryId: z.string().min(MIN_STRING_LENGTH, 'Subcategory ID is required'),
+  procedureSubCategoryName: z.string().min(MIN_STRING_LENGTH, 'Subcategory name is required'),
+  procedureTechnologyId: z.string().min(MIN_STRING_LENGTH, 'Technology ID is required'),
+  procedureTechnologyName: z.string().min(MIN_STRING_LENGTH, 'Technology name is required'),
+  procedureProducts: z.array(
+    z.object({
+      productId: z.string().min(MIN_STRING_LENGTH, 'Product ID is required'),
+      productName: z.string().min(MIN_STRING_LENGTH, 'Product name is required'),
+      brandId: z.string().min(MIN_STRING_LENGTH, 'Brand ID is required'),
+      brandName: z.string().min(MIN_STRING_LENGTH, 'Brand name is required'),
+    })
+  ),
+});
+
 /**
  * Schema for appointment metadata containing zone-specific information
  */
 export const appointmentMetadataSchema = z.object({
   selectedZones: z.array(z.string()).nullable(),
   zonePhotos: z.record(z.string(), beforeAfterPerZoneSchema).nullable(),
-  zoneBilling: z.record(z.string(), billingPerZoneSchema).nullable(),
+  zonesData: z.record(z.string(), z.array(zoneItemDataSchema)).nullable(),
+  appointmentProducts: z.array(appointmentProductMetadataSchema),
+  extendedProcedures: z.array(extendedProcedureInfoSchema),
+  zoneBilling: z.record(z.string(), billingPerZoneSchema).nullable().optional(),
   finalbilling: finalBillingSchema.nullable(),
   finalizationNotes: z.string().nullable(),
 });