@blackcode_sa/metaestetics-api 1.12.72 → 1.13.1

package/src/services/analytics/utils/appointment-filtering.utils.ts

@@ -0,0 +1,138 @@
+import { Appointment, AppointmentStatus } from '../../../types/appointment';
+import { AnalyticsDateRange, AnalyticsFilters } from '../../../types/analytics';
+
+/**
+ * Filters appointments by date range
+ *
+ * @param appointments - Array of appointments
+ * @param dateRange - Date range filter
+ * @returns Filtered appointments
+ */
+export function filterByDateRange(
+  appointments: Appointment[],
+  dateRange?: AnalyticsDateRange,
+): Appointment[] {
+  if (!dateRange) {
+    return appointments;
+  }
+
+  const startTime = dateRange.start.getTime();
+  const endTime = dateRange.end.getTime();
+
+  return appointments.filter(appointment => {
+    const appointmentTime = appointment.appointmentStartTime.toMillis();
+    return appointmentTime >= startTime && appointmentTime <= endTime;
+  });
+}
+
+/**
+ * Filters appointments by various criteria
+ *
+ * @param appointments - Array of appointments
+ * @param filters - Filter criteria
+ * @returns Filtered appointments
+ */
+export function filterAppointments(
+  appointments: Appointment[],
+  filters?: AnalyticsFilters,
+): Appointment[] {
+  if (!filters) {
+    return appointments;
+  }
+
+  return appointments.filter(appointment => {
+    if (filters.clinicBranchId && appointment.clinicBranchId !== filters.clinicBranchId) {
+      return false;
+    }
+    if (filters.practitionerId && appointment.practitionerId !== filters.practitionerId) {
+      return false;
+    }
+    if (filters.procedureId && appointment.procedureId !== filters.procedureId) {
+      return false;
+    }
+    if (filters.patientId && appointment.patientId !== filters.patientId) {
+      return false;
+    }
+    return true;
+  });
+}
+
+/**
+ * Filters appointments by status
+ *
+ * @param appointments - Array of appointments
+ * @param statuses - Array of statuses to include
+ * @returns Filtered appointments
+ */
+export function filterByStatus(
+  appointments: Appointment[],
+  statuses: AppointmentStatus[],
+): Appointment[] {
+  return appointments.filter(appointment => statuses.includes(appointment.status));
+}
+
+/**
+ * Gets completed appointments (status = COMPLETED)
+ *
+ * @param appointments - Array of appointments
+ * @returns Completed appointments
+ */
+export function getCompletedAppointments(appointments: Appointment[]): Appointment[] {
+  return filterByStatus(appointments, [AppointmentStatus.COMPLETED]);
+}
+
+/**
+ * Gets canceled appointments (all cancellation statuses)
+ *
+ * @param appointments - Array of appointments
+ * @returns Canceled appointments
+ */
+export function getCanceledAppointments(appointments: Appointment[]): Appointment[] {
+  return filterByStatus(appointments, [
+    AppointmentStatus.CANCELED_PATIENT,
+    AppointmentStatus.CANCELED_CLINIC,
+    AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
+  ]);
+}
+
+/**
+ * Gets no-show appointments
+ *
+ * @param appointments - Array of appointments
+ * @returns No-show appointments
+ */
+export function getNoShowAppointments(appointments: Appointment[]): Appointment[] {
+  return filterByStatus(appointments, [AppointmentStatus.NO_SHOW]);
+}
+
+/**
+ * Gets active appointments (not canceled or no-show)
+ *
+ * @param appointments - Array of appointments
+ * @returns Active appointments
+ */
+export function getActiveAppointments(appointments: Appointment[]): Appointment[] {
+  const inactiveStatuses = [
+    AppointmentStatus.CANCELED_PATIENT,
+    AppointmentStatus.CANCELED_CLINIC,
+    AppointmentStatus.CANCELED_PATIENT_RESCHEDULED,
+    AppointmentStatus.NO_SHOW,
+  ];
+
+  return appointments.filter(appointment => !inactiveStatuses.includes(appointment.status));
+}
+
+/**
+ * Calculates percentage
+ *
+ * @param part - Part value
+ * @param total - Total value
+ * @returns Percentage (0-100)
+ */
+export function calculatePercentage(part: number, total: number): number {
+  if (total === 0) {
+    return 0;
+  }
+  return Math.round((part / total) * 100 * 100) / 100;
+}
+

package/src/services/analytics/utils/cost-calculation.utils.ts

@@ -0,0 +1,182 @@
+import { Appointment, AppointmentMetadata, FinalBilling, ZoneItemData } from '../../../types/appointment';
+
+/**
+ * Calculates the total cost from an appointment's metadata
+ * Priority: finalbilling.finalPrice > zonesData subtotals > appointment.cost
+ *
+ * @param appointment - The appointment to calculate cost for
+ * @returns Object with cost, currency, and calculation source
+ */
+export function calculateAppointmentCost(appointment: Appointment): {
+  cost: number;
+  currency: string;
+  source: 'finalbilling' | 'zonesData' | 'baseCost';
+  subtotal?: number;
+  tax?: number;
+} {
+  const metadata = appointment.metadata;
+  const currency = appointment.currency || 'CHF';
+
+  // Priority 1: Use finalbilling if available
+  if (metadata?.finalbilling) {
+    const finalbilling = metadata.finalbilling as FinalBilling;
+    return {
+      cost: finalbilling.finalPrice,
+      currency: finalbilling.currency || currency,
+      source: 'finalbilling',
+      subtotal: finalbilling.subtotalAll,
+      tax: finalbilling.taxPrice,
+    };
+  }
+
+  // Priority 2: Calculate from zonesData
+  if (metadata?.zonesData) {
+    const zonesData = metadata.zonesData as Record<string, ZoneItemData[]>;
+    let subtotal = 0;
+    let foundCurrency = currency;
+
+    Object.values(zonesData).forEach(items => {
+      items.forEach(item => {
+        if (item.type === 'item' && item.subtotal) {
+          subtotal += item.subtotal;
+          if (item.currency && !foundCurrency) {
+            foundCurrency = item.currency;
+          }
+        }
+      });
+    });
+
+    if (subtotal > 0) {
+      return {
+        cost: subtotal, // Note: This doesn't include tax, but zonesData might not have tax info
+        currency: foundCurrency,
+        source: 'zonesData',
+        subtotal,
+      };
+    }
+  }
+
+  // Priority 3: Fallback to base appointment cost
+  return {
+    cost: appointment.cost || 0,
+    currency,
+    source: 'baseCost',
+  };
+}
+
+/**
+ * Calculates total revenue from an array of appointments
+ *
+ * IMPORTANT: This function should only be called with COMPLETED appointments.
+ * Only completed procedures generate revenue. Confirmed, pending, canceled, and no-show
+ * appointments should be filtered out before calling this function.
+ *
+ * @param appointments - Array of appointments (should be filtered to COMPLETED only)
+ * @returns Total revenue and currency
+ */
+export function calculateTotalRevenue(appointments: Appointment[]): {
+  totalRevenue: number;
+  currency: string;
+} {
+  if (appointments.length === 0) {
+    return { totalRevenue: 0, currency: 'CHF' };
+  }
+
+  let totalRevenue = 0;
+  const currencies = new Set<string>();
+
+  appointments.forEach(appointment => {
+    const costData = calculateAppointmentCost(appointment);
+    totalRevenue += costData.cost;
+    currencies.add(costData.currency);
+  });
+
+  // Use the most common currency, or first one found
+  const currency = currencies.size > 0 ? Array.from(currencies)[0] : 'CHF';
+
+  return { totalRevenue, currency };
+}
+
+/**
+ * Extracts product usage from appointment metadata
+ *
+ * IMPORTANT: This function should only be called with COMPLETED appointments.
+ * Products are only considered "used" when the procedure has been completed.
+ * Only completed procedures generate product usage and revenue.
+ *
+ * NOTE ON PRICING:
+ * - Price overrides (priceOverrideAmount) are always applied if available
+ * - Subtotal is recalculated to ensure price overrides are reflected
+ * - Product revenue shows SUBTOTAL (before tax) - tax is applied at appointment level
+ * - Tax is included in appointment revenue (finalbilling.finalPrice) but not in product revenue
+ * - Product subtotals should sum to finalbilling.subtotalAll (before tax)
+ *
+ * @param appointment - The appointment to extract products from (should be COMPLETED)
+ * @returns Array of product usage data with subtotal (before tax)
+ */
+export function extractProductUsage(appointment: Appointment): Array<{
+  productId: string;
+  productName: string;
+  brandId: string;
+  brandName: string;
+  quantity: number;
+  price: number;
+  subtotal: number;
+  currency: string;
+}> {
+  const products: Array<{
+    productId: string;
+    productName: string;
+    brandId: string;
+    brandName: string;
+    quantity: number;
+    price: number;
+    subtotal: number;
+    currency: string;
+  }> = [];
+
+  const metadata = appointment.metadata;
+  if (!metadata?.zonesData) {
+    return products;
+  }
+
+  const zonesData = metadata.zonesData as Record<string, ZoneItemData[]>;
+  const currency = appointment.currency || 'CHF';
+
+  Object.values(zonesData).forEach(items => {
+    items.forEach(item => {
+      if (item.type === 'item' && item.productId) {
+        // Always use priceOverrideAmount if available, otherwise use price
+        // This ensures price overrides are properly applied to product calculations
+        const price = item.priceOverrideAmount || item.price || 0;
+        const quantity = item.quantity || 1;
+        
+        // Always recalculate subtotal based on the actual price (with override)
+        // This ensures price overrides are reflected in product revenue
+        // Use stored subtotal only if it matches the calculated value (to handle rounding)
+        const calculatedSubtotal = price * quantity;
+        const storedSubtotal = item.subtotal || 0;
+        
+        // Use stored subtotal if it's close to calculated (within 0.01 for rounding differences)
+        // Otherwise recalculate to ensure price override is applied correctly
+        const subtotal = Math.abs(storedSubtotal - calculatedSubtotal) < 0.01 
+          ? storedSubtotal 
+          : calculatedSubtotal;
+
+        products.push({
+          productId: item.productId,
+          productName: item.productName || 'Unknown Product',
+          brandId: item.productBrandId || '',
+          brandName: item.productBrandName || '',
+          quantity,
+          price,
+          subtotal,
+          currency: item.currency || currency,
+        });
+      }
+    });
+  });
+
+  return products;
+}
+