@leandrosk/dashboard 3.5.5

package/src/app/routes/_authenticated/_orders/utils/order-utils.ts

@@ -0,0 +1,219 @@
+import { DEFAULT_CHANNEL_CODE } from '@/vdb/constants.js';
+import { VariablesOf } from 'gql.tada';
+
+import { modifyOrderDocument } from '../orders.graphql.js';
+
+import { Fulfillment, Order, Payment } from './order-types.js';
+import { ProductVariantInfo } from './use-modify-order.js';
+
+type ModifyOrderInput = VariablesOf<typeof modifyOrderDocument>['input'];
+type WithCustomFields<T> = T & { customFields?: Record<string, any> };
+
+/**
+ * Calculates the outstanding payment amount for an order
+ */
+export function calculateOutstandingPaymentAmount(order: Order): number {
+    if (!order) return 0;
+
+    const paymentIsValid = (p: Payment): boolean =>
+        p.state !== 'Cancelled' && p.state !== 'Declined' && p.state !== 'Error';
+
+    let amountCovered = 0;
+    for (const payment of order.payments?.filter(paymentIsValid) ?? []) {
+        const refunds = payment.refunds.filter(r => r.state !== 'Failed') ?? [];
+        const refundsTotal = refunds.reduce((sum, refund) => sum + (refund.total || 0), 0);
+        amountCovered += payment.amount - refundsTotal;
+    }
+    return order.totalWithTax - amountCovered;
+}
+
+/**
+ * Checks if an order has unsettled modifications
+ */
+export function hasUnsettledModifications(order: Order): boolean {
+    if (!order) return false;
+    return order.modifications.some(m => !m.isSettled);
+}
+
+/**
+ * Determines if the add manual payment button should be displayed
+ */
+export function shouldShowAddManualPaymentButton(order: Order): boolean {
+    if (!order) return false;
+
+    return (
+        order.type !== 'Aggregate' &&
+        (order.state === 'ArrangingPayment' || order.state === 'ArrangingAdditionalPayment') &&
+        (hasUnsettledModifications(order) || calculateOutstandingPaymentAmount(order) > 0)
+    );
+}
+
+/**
+ * Determines if we can add a fulfillment to an order
+ */
+export function canAddFulfillment(order: Order): boolean {
+    if (!order) return false;
+
+    // Get all fulfillment lines from non-cancelled fulfillments
+    const allFulfillmentLines: Fulfillment['lines'] = (order.fulfillments ?? [])
+        .filter(fulfillment => fulfillment.state !== 'Cancelled')
+        .reduce((all, fulfillment) => [...all, ...fulfillment.lines], [] as Fulfillment['lines']);
+
+    // Check if all items are already fulfilled
+    let allItemsFulfilled = true;
+    for (const line of order.lines) {
+        const totalFulfilledCount = allFulfillmentLines
+            .filter(row => row.orderLineId === line.id)
+            .reduce((sum, row) => sum + row.quantity, 0);
+        if (totalFulfilledCount < line.quantity) {
+            allItemsFulfilled = false;
+            break;
+        }
+    }
+
+    // Check if order is in a fulfillable state
+    const isFulfillableState =
+        (order.nextStates.includes('Shipped') ||
+            order.nextStates.includes('PartiallyShipped') ||
+            order.nextStates.includes('Delivered')) &&
+        order.state !== 'ArrangingAdditionalPayment';
+
+    return (
+        !allItemsFulfilled &&
+        !hasUnsettledModifications(order) &&
+        calculateOutstandingPaymentAmount(order) === 0 &&
+        isFulfillableState
+    );
+}
+
+export function getSeller<T>(order: { channels: Array<{ code: string; seller: T }> }) {
+    // Find the seller channel (non-default channel)
+    const sellerChannel = order.channels.find(channel => channel.code !== DEFAULT_CHANNEL_CODE);
+    return sellerChannel?.seller;
+}
+
+/**
+ * Computes a pending order based on the current order and modification input
+ */
+export function computePendingOrder(
+    order: Order,
+    input: ModifyOrderInput,
+    addedVariants: Map<string, ProductVariantInfo>,
+    eligibleShippingMethods?: Array<{ id: string; name: string; priceWithTax: number }>,
+    orderLineCustomFieldNames?: string[],
+): Order {
+    // Adjust lines
+    const lines = order.lines.map(line => {
+        const adjust = input.adjustOrderLines?.find(l => l.orderLineId === line.id);
+        const adjustCf = (adjust as WithCustomFields<typeof adjust>)?.customFields;
+        const lineCf = (line as WithCustomFields<typeof line>).customFields;
+        return adjust ? { ...line, quantity: adjust.quantity, customFields: adjustCf ?? lineCf } : line;
+    });
+
+    const customFieldsTemplate =
+        orderLineCustomFieldNames && orderLineCustomFieldNames.length > 0
+            ? Object.fromEntries(orderLineCustomFieldNames.map(k => [k, null]))
+            : undefined;
+
+    // Add new items (as AddedLine)
+    const addedLines = input.addItems
+        ?.map(item => {
+            const variantInfo = addedVariants.get(item.productVariantId);
+            return variantInfo
+                ? ({
+                      id: `added-${item.productVariantId}`,
+                      featuredAsset: variantInfo.productAsset ?? null,
+                      productVariant: {
+                          id: variantInfo.productVariantId,
+                          name: variantInfo.productVariantName,
+                          sku: variantInfo.sku,
+                      },
+                      unitPrice: variantInfo.price ?? 0,
+                      unitPriceWithTax: variantInfo.priceWithTax ?? 0,
+                      quantity: item.quantity,
+                      linePrice: (variantInfo.price ?? 0) * item.quantity,
+                      linePriceWithTax: (variantInfo.priceWithTax ?? 0) * item.quantity,
+                      customFields:
+                          (item as WithCustomFields<typeof item>).customFields ?? customFieldsTemplate,
+                  } as unknown as Order['lines'][number])
+                : null;
+        })
+        .filter(x => x != null);
+
+    return {
+        ...order,
+        lines: [...lines, ...(addedLines ?? [])],
+        couponCodes: input.couponCodes ?? [],
+        shippingLines: input.shippingMethodIds
+            ? input.shippingMethodIds
+                  .map(shippingMethodId => {
+                      const shippingMethod = eligibleShippingMethods?.find(
+                          method => method.id === shippingMethodId,
+                      );
+                      if (!shippingMethod) {
+                          return;
+                      }
+                      return {
+                          shippingMethod: {
+                              ...shippingMethod,
+                              fulfillmentHandlerCode: 'manual',
+                          },
+                          discountedPriceWithTax: shippingMethod?.priceWithTax ?? 0,
+                          id: shippingMethodId,
+                      } as any;
+                  })
+                  .filter(x => x !== undefined)
+            : order.shippingLines,
+    };
+}
+
+/**
+ * Gets the total quantity already refunded for an order line across all payments.
+ */
+export function getRefundedQuantity(order: Order, lineId: string): number {
+    return (
+        order.payments
+            ?.reduce((all, payment) => [...all, ...payment.refunds], [] as Payment['refunds'])
+            .filter(refund => refund.state !== 'Failed')
+            .reduce(
+                (all, refund) => [...all, ...refund.lines],
+                [] as Array<{ orderLineId: string; quantity: number }>,
+            )
+            .filter(refundLine => refundLine.orderLineId === lineId)
+            .reduce((sum, refundLine) => sum + refundLine.quantity, 0) ?? 0
+    );
+}
+
+/**
+ * Checks if an order line can still be refunded (has unrefunded quantity).
+ */
+export function lineCanBeRefunded(order: Order, line: Order['lines'][number]): boolean {
+    const refundedCount = getRefundedQuantity(order, line.id);
+    return refundedCount < line.orderPlacedQuantity;
+}
+
+/**
+ * Gets the maximum refundable quantity for an order line.
+ */
+export function getMaxRefundableQuantity(order: Order, line: Order['lines'][number]): number {
+    const refundedCount = getRefundedQuantity(order, line.id);
+    return Math.max(0, line.orderPlacedQuantity - refundedCount);
+}
+
+/**
+ * Checks if an order has any settled payments that can be refunded.
+ */
+export function orderHasSettledPayments(order: Order): boolean {
+    return !!order.payments?.some(p => p.state === 'Settled');
+}
+
+/**
+ * Determines if the refund button should be shown for an order.
+ * Shows refund for orders with settled payments that are not in initial states.
+ */
+export function canRefundOrder(order: Order): boolean {
+    if (!order || order.type === 'Aggregate') return false;
+    const hasSettled = orderHasSettledPayments(order);
+    const notInInitialState = order.state !== 'PaymentAuthorized' && order.active !== true;
+    return hasSettled && notInInitialState;
+}

package/src/app/routes/_authenticated/_orders/utils/refund-utils.ts

@@ -0,0 +1,100 @@
+import { Order, Payment } from './order-types.js';
+
+// === Types ===
+
+export type RefundablePayment = Payment & {
+    refundableAmount: number;
+    amountToRefund: number;
+    selected: boolean;
+};
+
+export type LineSelection = { quantity: number; cancel: boolean };
+
+// === Refundable Payment Functions ===
+
+/**
+ * Filters payments to only those that are settled and calculates the refundable amount
+ * (payment amount minus sum of non-failed refunds).
+ */
+export function getRefundablePayments(payments: Payment[] | undefined | null): RefundablePayment[] {
+    const settledPayments = (payments ?? []).filter(p => p.state === 'Settled');
+    return settledPayments.map((payment, index) => {
+        const successfulRefunds = payment.refunds.filter(r => r.state !== 'Failed');
+        const refundedTotal = successfulRefunds.reduce((sum, refund) => sum + (refund.total || 0), 0);
+        const refundableAmount = Math.max(0, payment.amount - refundedTotal);
+        return {
+            ...payment,
+            refundableAmount,
+            amountToRefund: 0,
+            selected: index === 0,
+        };
+    });
+}
+
+/**
+ * Calculates the total refundable amount across all payments.
+ */
+export function getTotalRefundableAmount(refundablePayments: RefundablePayment[]): number {
+    return refundablePayments.reduce((sum, p) => sum + p.refundableAmount, 0);
+}
+
+/**
+ * Calculates the total amount currently allocated to refund across all payments.
+ */
+export function getTotalAmountToRefund(refundablePayments: RefundablePayment[]): number {
+    return refundablePayments.reduce((sum, p) => sum + p.amountToRefund, 0);
+}
+
+// === Refund Calculation Functions ===
+
+/**
+ * Calculate total refund amount from line selections and shipping
+ */
+export function calculateRefundTotal(
+    lines: Order['lines'],
+    lineSelections: Record<string, LineSelection>,
+    shippingLines: Order['shippingLines'],
+    refundShippingLineIds: string[],
+): number {
+    const itemTotal = lines.reduce((total, line) => {
+        const selection = lineSelections[line.id];
+        const refundCount = selection?.quantity || 0;
+        return total + line.proratedUnitPriceWithTax * refundCount;
+    }, 0);
+
+    const shippingTotal = shippingLines.reduce((total, line) => {
+        if (refundShippingLineIds.includes(line.id)) {
+            return total + line.discountedPriceWithTax;
+        }
+        return total;
+    }, 0);
+
+    return itemTotal + shippingTotal;
+}
+
+/**
+ * Allocate refund total across selected payments (immutable)
+ */
+export function allocateRefundsToPayments(payments: RefundablePayment[], total: number): RefundablePayment[] {
+    let refundsAllocated = 0;
+    return payments.map(payment => {
+        if (!payment.selected) {
+            return { ...payment, amountToRefund: 0 };
+        }
+        const amountToRefund = Math.min(payment.refundableAmount, total - refundsAllocated);
+        refundsAllocated += amountToRefund;
+        return { ...payment, amountToRefund };
+    });
+}
+
+/**
+ * Convert line selections to GraphQL input format
+ */
+export function getOrderLineInputFromSelections(
+    lineSelections: Record<string, LineSelection>,
+    filterFn: (line: LineSelection) => boolean = () => true,
+): Array<{ orderLineId: string; quantity: number }> {
+    return Object.entries(lineSelections)
+        .filter(([, line]) => line.quantity > 0 && filterFn(line))
+        .map(([orderLineId, line]) => ({ orderLineId, quantity: line.quantity }));
+}

package/src/app/routes/_authenticated/_orders/utils/use-modify-order.ts

@@ -0,0 +1,350 @@
+import { VariablesOf } from 'gql.tada';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { modifyOrderDocument } from '../orders.graphql.js';
+
+import { AddressFragment, Order } from './order-types.js';
+
+type ModifyOrderInput = VariablesOf<typeof modifyOrderDocument>['input'];
+
+export type ProductVariantInfo = {
+    productVariantId: string;
+    productVariantName: string;
+    sku: string;
+    productAsset: {
+        preview: string;
+    };
+    price?: number;
+    priceWithTax?: number;
+};
+
+type SurchargeInput = NonNullable<ModifyOrderInput['surcharges']>[number];
+
+export interface UseModifyOrderReturn {
+    modifyOrderInput: ModifyOrderInput;
+    addedVariants: Map<string, ProductVariantInfo>;
+    addItem: (variant: ProductVariantInfo) => void;
+    adjustLine: (params: {
+        lineId: string;
+        quantity: number;
+        customFields: Record<string, any> | undefined;
+    }) => void;
+    removeLine: (params: { lineId: string }) => void;
+    setShippingMethod: (params: { shippingMethodId: string }) => void;
+    applyCouponCode: (params: { couponCode: string }) => void;
+    removeCouponCode: (params: { couponCode: string }) => void;
+    updateShippingAddress: (address: AddressFragment) => void;
+    updateBillingAddress: (address: AddressFragment) => void;
+    addSurcharge: (surcharge: SurchargeInput) => void;
+    setNote: (note: string) => void;
+    setRecalculateShipping: (recalculate: boolean) => void;
+    hasModifications: boolean;
+}
+
+/**
+ * Custom hook to manage order modification state and operations
+ */
+export function useModifyOrder(order: Order | null | undefined): UseModifyOrderReturn {
+    const [modifyOrderInput, setModifyOrderInput] = useState<ModifyOrderInput>({
+        orderId: '',
+        addItems: [],
+        adjustOrderLines: [],
+        surcharges: [],
+        note: '',
+        couponCodes: [],
+        options: {
+            recalculateShipping: true,
+        },
+        dryRun: true,
+    });
+
+    const [addedVariants, setAddedVariants] = useState<Map<string, ProductVariantInfo>>(new Map());
+
+    // Sync orderId and couponCodes when order changes
+    useEffect(() => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            orderId: order?.id ?? '',
+            couponCodes: order?.couponCodes ?? [],
+        }));
+    }, [order?.id]);
+
+    // Add item or increment existing line
+    const addItem = useCallback(
+        (variant: ProductVariantInfo) => {
+            setModifyOrderInput(prev => {
+                const existingLine = order?.lines.find(
+                    line => line.productVariant.id === variant.productVariantId,
+                );
+
+                if (existingLine) {
+                    const existingAdjustment = prev.adjustOrderLines?.find(
+                        adj => adj.orderLineId === existingLine.id,
+                    );
+
+                    if (existingAdjustment) {
+                        const newQuantity = existingAdjustment.quantity + 1;
+
+                        // If back to original quantity, remove from adjustments
+                        if (newQuantity === Number(existingLine.quantity)) {
+                            return {
+                                ...prev,
+                                adjustOrderLines: (prev.adjustOrderLines ?? []).filter(
+                                    adj => adj.orderLineId !== existingLine.id,
+                                ),
+                            };
+                        }
+
+                        return {
+                            ...prev,
+                            adjustOrderLines:
+                                prev.adjustOrderLines?.map(adj =>
+                                    adj.orderLineId === existingLine.id
+                                        ? { ...adj, quantity: newQuantity }
+                                        : adj,
+                                ) ?? [],
+                        };
+                    } else {
+                        return {
+                            ...prev,
+                            adjustOrderLines: [
+                                ...(prev.adjustOrderLines ?? []),
+                                { orderLineId: existingLine.id, quantity: existingLine.quantity + 1 },
+                            ],
+                        };
+                    }
+                } else {
+                    return {
+                        ...prev,
+                        addItems: [
+                            ...(prev.addItems ?? []),
+                            { productVariantId: variant.productVariantId, quantity: 1 },
+                        ],
+                    };
+                }
+            });
+
+            setAddedVariants(prev => {
+                const newMap = new Map(prev);
+                newMap.set(variant.productVariantId, variant);
+                return newMap;
+            });
+        },
+        [order],
+    );
+
+    // Adjust line quantity or custom fields
+    const adjustLine = useCallback(
+        ({
+            lineId,
+            quantity,
+            customFields,
+        }: {
+            lineId: string;
+            quantity: number;
+            customFields: Record<string, any> | undefined;
+        }) => {
+            if (lineId.startsWith('added-')) {
+                const productVariantId = lineId.replace('added-', '');
+                setModifyOrderInput(prev => ({
+                    ...prev,
+                    addItems: (prev.addItems ?? []).map(item =>
+                        item.productVariantId === productVariantId
+                            ? { ...item, quantity, customFields }
+                            : item,
+                    ),
+                }));
+            } else {
+                let normalizedCustomFields: Record<string, any> | undefined = customFields;
+                if (normalizedCustomFields) {
+                    delete normalizedCustomFields.__entityId__;
+                }
+                if (normalizedCustomFields && Object.keys(normalizedCustomFields).length === 0) {
+                    normalizedCustomFields = undefined;
+                }
+
+                setModifyOrderInput(prev => {
+                    const originalLine = order?.lines.find(l => l.id === lineId);
+                    const isBackToOriginal = originalLine && originalLine.quantity === quantity;
+
+                    const originalCustomFields = (originalLine as any)?.customFields;
+                    const customFieldsChanged =
+                        JSON.stringify(normalizedCustomFields) !== JSON.stringify(originalCustomFields);
+
+                    const existing = (prev.adjustOrderLines ?? []).find(l => l.orderLineId === lineId);
+
+                    // If back to original and custom fields unchanged, remove from adjustments
+                    if (isBackToOriginal && !customFieldsChanged) {
+                        return {
+                            ...prev,
+                            adjustOrderLines: (prev.adjustOrderLines ?? []).filter(
+                                l => l.orderLineId !== lineId,
+                            ),
+                        };
+                    }
+
+                    const adjustOrderLines = existing
+                        ? (prev.adjustOrderLines ?? []).map(l =>
+                              l.orderLineId === lineId
+                                  ? { ...l, quantity, customFields: normalizedCustomFields }
+                                  : l,
+                          )
+                        : [
+                              ...(prev.adjustOrderLines ?? []),
+                              { orderLineId: lineId, quantity, customFields: normalizedCustomFields },
+                          ];
+                    return { ...prev, adjustOrderLines };
+                });
+            }
+        },
+        [order],
+    );
+
+    // Remove line
+    const removeLine = useCallback(({ lineId }: { lineId: string }) => {
+        if (lineId.startsWith('added-')) {
+            const productVariantId = lineId.replace('added-', '');
+            setModifyOrderInput(prev => ({
+                ...prev,
+                addItems: (prev.addItems ?? []).filter(item => item.productVariantId !== productVariantId),
+            }));
+            setAddedVariants(prev => {
+                const newMap = new Map(prev);
+                newMap.delete(productVariantId);
+                return newMap;
+            });
+        } else {
+            setModifyOrderInput(prev => {
+                const existingAdjustment = (prev.adjustOrderLines ?? []).find(l => l.orderLineId === lineId);
+                const adjustOrderLines = existingAdjustment
+                    ? (prev.adjustOrderLines ?? []).map(l =>
+                          l.orderLineId === lineId ? { ...l, quantity: 0 } : l,
+                      )
+                    : [...(prev.adjustOrderLines ?? []), { orderLineId: lineId, quantity: 0 }];
+                return {
+                    ...prev,
+                    adjustOrderLines,
+                };
+            });
+        }
+    }, []);
+
+    // Set shipping method
+    const setShippingMethod = useCallback(({ shippingMethodId }: { shippingMethodId: string }) => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            shippingMethodIds: [shippingMethodId],
+        }));
+    }, []);
+
+    // Apply coupon code
+    const applyCouponCode = useCallback(({ couponCode }: { couponCode: string }) => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            couponCodes: prev.couponCodes?.includes(couponCode)
+                ? prev.couponCodes
+                : [...(prev.couponCodes ?? []), couponCode],
+        }));
+    }, []);
+
+    // Remove coupon code
+    const removeCouponCode = useCallback(({ couponCode }: { couponCode: string }) => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            couponCodes: (prev.couponCodes ?? []).filter(code => code !== couponCode),
+        }));
+    }, []);
+
+    // Update shipping address
+    const updateShippingAddress = useCallback((address: AddressFragment) => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            updateShippingAddress: {
+                streetLine1: address.streetLine1,
+                streetLine2: address.streetLine2,
+                city: address.city,
+                countryCode: address.country.code,
+                fullName: address.fullName,
+                postalCode: address.postalCode,
+                province: address.province,
+                company: address.company,
+                phoneNumber: address.phoneNumber,
+            },
+        }));
+    }, []);
+
+    // Update billing address
+    const updateBillingAddress = useCallback((address: AddressFragment) => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            updateBillingAddress: {
+                streetLine1: address.streetLine1,
+                streetLine2: address.streetLine2,
+                city: address.city,
+                countryCode: address.country.code,
+                fullName: address.fullName,
+                postalCode: address.postalCode,
+                province: address.province,
+                company: address.company,
+                phoneNumber: address.phoneNumber,
+            },
+        }));
+    }, []);
+
+    // Add surcharge
+    const addSurcharge = useCallback((surcharge: SurchargeInput) => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            surcharges: [...(prev.surcharges ?? []), surcharge],
+        }));
+    }, []);
+
+    // Set note
+    const setNote = useCallback((note: string) => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            note: note || '',
+        }));
+    }, []);
+
+    // Set recalculate shipping
+    const setRecalculateShipping = useCallback((recalculate: boolean) => {
+        setModifyOrderInput(prev => ({
+            ...prev,
+            options: {
+                ...prev.options,
+                recalculateShipping: recalculate,
+            },
+        }));
+    }, []);
+
+    // Check if there are modifications
+    const hasModifications = useMemo(() => {
+        return (
+            (modifyOrderInput.addItems?.length ?? 0) > 0 ||
+            (modifyOrderInput.adjustOrderLines?.length ?? 0) > 0 ||
+            (modifyOrderInput.couponCodes?.length ?? 0) > 0 ||
+            (modifyOrderInput.shippingMethodIds?.length ?? 0) > 0 ||
+            (modifyOrderInput.surcharges?.length ?? 0) > 0 ||
+            !!modifyOrderInput.updateShippingAddress ||
+            !!modifyOrderInput.updateBillingAddress
+        );
+    }, [modifyOrderInput]);
+
+    return {
+        modifyOrderInput,
+        addedVariants,
+        addItem,
+        adjustLine,
+        removeLine,
+        setShippingMethod,
+        applyCouponCode,
+        removeCouponCode,
+        updateShippingAddress,
+        updateBillingAddress,
+        addSurcharge,
+        setNote,
+        setRecalculateShipping,
+        hasModifications,
+    };
+}