1#@!#!123s

ALWAYS HENGHENG888 1#@!#!123s
: / var / www / chinawholesale-frontend-next / src / helpers /
Filename : cart-helpers.js
back
import Swal from 'sweetalert2'
import { calculateTotalWeight1688 } from '@/helpers/product'

export const sumCartItemTotal = (variations) => {
    return variations?.length > 0 ?
        variations?.reduce((sum, { price, qty }) => Number(sum) + Number(price) * Number(qty), 0)
        : 0
}

export const sumCartItemTotalQuantity = (variations) => {
    return variations?.length > 0 ?
        variations?.reduce((sum, { price, qty }) => sum + Number(qty), 0)
        : 0
}


const isObject = (data) => {
    return typeof data === 'object' && data !== null && data.constructor === Object
}

const isEmpty = (data) => {
    return isObject(data) ? !Object.keys(data).length : true
}

const isArray = (data) => {
    return Array.isArray(data)
}

function differenceWith(array, values, comparator) {
    return array.filter(item => !values.some(value => comparator(item, value)))
}

export const getProductKeyItem = (product, keyName, returnDefault = null) => {
    if (!isEmpty(product) && isObject(product)) {
        return product[keyName]
    }
    return returnDefault
}

export const collectSelectedAttributes = (cartAttribute) => {
    const collectAttributes = []
    for (const groupKey in cartAttribute) {
        const attrItem = cartAttribute?.[groupKey]
        if (attrItem) {
            collectAttributes.push(attrItem)
        }
    }
    return collectAttributes
}

// const stringifyAttributes = (Attributes) => {
//   let collect = [];
//   Attributes?.map((item) => {
//     collect.push(item.Pid + "_" + item.Vid);
//     return false;
//   });
//   return collect;
// };

export const getActiveConfiguredItems = (ConfiguredItems, cartAttribute) => {
    const CartAttributes = collectSelectedAttributes(cartAttribute)
    // const compare1 = stringifyAttributes(CartAttributes);
    let configItems = []
    for (let i = 0; i < ConfiguredItems.length; i++) {
        const ConfiguredItem = ConfiguredItems[i]
        const Configurators = ConfiguredItem?.Configurators || []
        const newConfig =
            Configurators?.filter((filter) =>
                CartAttributes?.find(
                    (findAttr) =>
                        findAttr.Pid === filter.Pid && findAttr.Vid === filter.Vid,
                ),
            ) || []
        if (newConfig.length === Configurators.length) {
            configItems.push(ConfiguredItem)
            break
        }
    }
    if (configItems.length === 0) {
        configItems =
            ConfiguredItems?.filter((ConfiguredItem) =>
                ConfiguredItem?.Configurators?.find((find) =>
                    CartAttributes?.find(
                        (findAttr) => findAttr.Pid === find.Pid && findAttr.Vid === find.Vid,
                    ),
                ),
            ) || []
    }
    return configItems
}

export const firstAttributeConfiguredItems = (
    ConfiguredItems,
    firstAttribute,
) => {
    return ConfiguredItems?.filter((findConfig) =>
        findConfig?.Configurators?.find(
            (find) =>
                find.Pid === firstAttribute.Pid && firstAttribute.Vid === find.Vid,
        ),
    )
}

export const getObjectPropertyValue = ($object, $property, $default = null) => {
    return $object?.[$property] ? $object?.[$property] : $default
}

export const calculatePrice = (price, rate) => {
    let cost = Number(price) * Number(rate)
    return Math.round(cost)
}

export const getProductCurrentPrice = (product, activeConfiguredItem, rate) => {
    let activeConfigItemPrice = activeConfiguredItem?.Price?.OriginalPrice || 0
    let activeConfigId = activeConfiguredItem?.Id || 0
    let OriginalPrice = activeConfigItemPrice ? activeConfigItemPrice : product?.Price?.OriginalPrice
    let Promotions = product?.Promotions
    if (Promotions?.length > 0) {
        OriginalPrice = Promotions[0]?.Price?.OriginalPrice
        let PromoConfiguredItemPrice = Promotions[0]?.ConfiguredItems?.find(find => find.Id === activeConfigId)?.Price?.OriginalPrice || 0
        OriginalPrice = PromoConfiguredItemPrice ? PromoConfiguredItemPrice : OriginalPrice
    }

    return calculatePrice(OriginalPrice, rate)
}

export const getProductWeight = (product) => {
    let Weight = product?.PhysicalParameters?.Weight || 0
    if (!Weight) {
        Weight = product?.PhysicalParameters?.ApproxWeight || 0
    }
    if (!Weight) {
        Weight = product?.ActualWeightInfo?.Weight || 0
    }
    return Weight ? Number(Weight).toFixed(3) : '0.000'
}

export const getProductDeliveryCosts = (product, rate) => {
    let DeliveryCosts = product?.DeliveryCosts
    let charge = 5
    if (DeliveryCosts?.length > 0) {
        charge = DeliveryCosts[0]?.Price?.OriginalPrice
    }
    return calculatePrice(charge, rate)
}

export const getProductModifiedConfiguredItem = (
    $product,
    qty,
    activeConfiguredItem,
    rate,
) => {
    let configItem = {}
    let configId = activeConfiguredItem?.Id
    configItem.Id = configId
    configItem.qty = qty
    configItem.maxQuantity = activeConfiguredItem?.Quantity

    let configItemPrice = activeConfiguredItem?.Price?.OriginalPrice

    let ConfigPrice = 0
    let ProductPrice = $product?.Price?.OriginalPrice
    let ProductPromotions = $product?.Promotions
    if (ProductPromotions?.length > 0) {
        ProductPromotions = ProductPromotions[0]
        ConfigPrice = ProductPromotions?.Price?.OriginalPrice
        let promoConfiguredItems = ProductPromotions?.ConfiguredItems
        let findConfig = promoConfiguredItems?.find((find) => find.Id === configId)
        if (findConfig) {
            ConfigPrice = findConfig?.Price?.OriginalPrice
        }
    } else {
        ConfigPrice = configItemPrice ? configItemPrice : ProductPrice
    }

    configItem.price = calculatePrice(ConfigPrice, rate)

    let Attributes = $product?.Attributes
    let Configurators = activeConfiguredItem?.Configurators
    let selectAttributes = []
    Configurators?.map((config) => {
        const findAttr = Attributes.find(
            (find) => find.Pid === config.Pid && find.Vid === config.Vid,
        )
        if (findAttr) {
            selectAttributes.push(findAttr)
        }
        return ''
    })
    configItem.Attributes = selectAttributes

    return configItem
}

export const getProductModifiedWithOutConfiguredItem = ($product, rate) => {
    let configItem = {}
    let configId = $product?.Id
    configItem.Id = configId
    configItem.qty = 1
    configItem.maxQuantity = $product?.MasterQuantity

    let ConfigPrice = 0
    let ProductPrice = $product?.Price?.OriginalPrice
    let ProductPromotions = $product?.Promotions
    if (ProductPromotions?.length > 0) {
        ProductPromotions = ProductPromotions[0]
        ConfigPrice = ProductPromotions?.Price.OriginalPrice
        let promoConfiguredItems = ProductPromotions?.ConfiguredItems
        let findConfig = promoConfiguredItems?.find((find) => find.Id === configId)
        if (findConfig) {
            ConfigPrice = findConfig?.Price.OriginalPrice
        }
    } else {
        ConfigPrice = ProductPrice
    }
    configItem.price = calculatePrice(ConfigPrice, rate)
    configItem.Attributes = []

    return configItem
}

// ========== bolow is the unknown ===========

export const numberWithCommas = (numericDtaa) => {
    if (numericDtaa) {
        let floatNum = Number(numericDtaa).toFixed(2)
        return floatNum.toString().split('.')[0].length > 3
            ? floatNum
                .toString()
                .substring(0, floatNum.toString().split('.')[0].length - 3)
                .replace(/\B(?=(\d{2})+(?!\d))/g, ',') +
            ',' +
            floatNum
                .toString()
                .substring(floatNum.toString().split('.')[0].length - 3)
            : floatNum.toString()
    }
    return '0.00'
}

export const findOldConfiguredExpectCurrent = (findItem, selectedConfig) => {
    if (isObject(selectedConfig) && isObject(findItem)) {
        if (!isEmpty(selectedConfig) && !isEmpty(findItem)) {
            return findItem.ConfiguredItems.filter(
                (filter) => filter.Id !== selectedConfig.Id,
            )
        }
    }
    return []
}

export const findOldCartItemExpectCurrent = (oldConfigured, productId) => {
    if (!isArray(oldConfigured) && !isEmpty(oldConfigured)) {
        return oldConfigured.filter((filter) => filter.Id !== productId)
    }
    return []
}

export const getProductAttributes = (product) => {
    return product?.Attributes || []
}

export const getProductGroupedAttributes = (Attributes) => {

    const result = Attributes.reduce(function(r, a) {
        r[a.PropertyName] = r[a.PropertyName] || []
        r[a.PropertyName].push(a)
        return r
    }, Object.create(null))


    const returnGroup = []
    for (const attr in result) {
        let item = result[attr]?.find(find => find.MiniImageUrl !== undefined)
        if (item) {
            returnGroup.unshift({
                key: attr,
                values: result[attr],
            })
        } else {
            returnGroup.push({
                key: attr,
                values: result[attr],
            })
        }
    }

    return returnGroup

}

export const GetOriginalPriceFromPrice = (Price, rate) => {
    let sellPrice = 0
    if (!isEmpty(Price)) {
        if (isObject(Price)) {
            sellPrice = Number(Price.OriginalPrice) * Number(rate)
        }
        if (isArray(Price)) {
            sellPrice = Number(Price[0].OriginalPrice) * Number(rate)
        }
    }
    return Math.round(sellPrice)
}

/**
 *
 * @param product
 * @param rate
 * @param ConfiguredItem
 * @returns {number|*}
 */
export const getProductPrice = (product, rate = 15, ConfiguredItem = {}) => {
    let sellPrice = 0
    if (!isEmpty(product)) {
        let Price = product.Price
        let configuredId = null
        if (!isEmpty(ConfiguredItem)) {
            Price = ConfiguredItem.Price
            configuredId = ConfiguredItem.Id
        }
        const Promotions = product.Promotions
        if (!isEmpty(Promotions) && isArray(Promotions)) {
            Price = Promotions.map((promotion) => {
                const promoConfig = promotion.ConfiguredItems
                const promoPrice = promotion.Price
                if (isArray(promoConfig)) {
                    const findPromoConfig = promotion.ConfiguredItems.find(
                        (configFilter) => configFilter.Id === configuredId,
                    )
                    return !isEmpty(findPromoConfig)
                        ? findPromoConfig.Price
                        : promoPrice
                }
                return promoPrice
            })
        }

        if (!isEmpty(Price)) {
            return GetOriginalPriceFromPrice(Price, rate)
        }
    }
    return sellPrice
}

export const getDBProductPrice = (product, rate = 15, selectedConfig = {}) => {
    let sellPrice = product?.sale_price || 0
    if (product?.Price) {
        let Price = JSON.parse(product.Price)
        if (Price?.OriginalPrice) {
            sellPrice = Number(Price.OriginalPrice) * Number(rate)
        }
        if (Price?.length > 0) {
            sellPrice = Price[0]?.OriginalPrice
                ? Number(Price[0]?.OriginalPrice) * Number(rate)
                : sellPrice
        }
        return Math.round(sellPrice)
    }
    return sellPrice
}

export const getDBAliProductPrice = (product, rate = 100) => {
    let Price = product?.Price ? JSON.parse(product?.Price) : {}
    let sellPrice = 0
    if (Price?.min_promo_price > 0) {
        sellPrice = Number(Price.min_promo_price) * Number(rate)
    } else if (Price?.min_price > 0) {
        sellPrice = Number(Price.min_price) * Number(rate)
    } else if (product?.sale_price > 0) {
        sellPrice = Number(product.sale_price)
    } else if (product?.regular_price > 0) {
        sellPrice = Number(product.regular_price)
    }
    return Math.round(sellPrice)
}

/**
 *
 * @returns {*[]|*}
 * @param Attributes
 */
export const ConfiguratorAttributes = (Attributes) => {
    const filter = Attributes?.filter((filter) => filter.IsConfigurator === true)
    return filter ? filter : []
}

/**
 *
 * @param product
 * @param common
 * @returns {number|*}
 */
export const getProductApproxWeight = (product, common = 0) => {
    if (isObject(product)) {
        const PhysicalParameters = product.PhysicalParameters
        if (!isEmpty(PhysicalParameters) && isObject(PhysicalParameters)) {
            const ManualWeight = PhysicalParameters.ManualWeight
            if (ManualWeight) {
                return ManualWeight ? ManualWeight : common
            }
            const weight = PhysicalParameters.ApproxWeight
            return weight ? weight : common
        }
    }
    return common
}

export const getProductDeliveryCost = (product, rate = 15) => {
    let shipping = 0
    if (!isEmpty(product) && isObject(product)) {
        // const HasInternalDelivery = product.HasInternalDelivery;
        const DeliveryCosts = product.DeliveryCosts
        if (isArray(DeliveryCosts)) {
            const DeliveryCost = DeliveryCosts.length > 0 ? DeliveryCosts[0] : {}
            if (!isEmpty(DeliveryCost)) {
                const Price = DeliveryCost.Price
                const OriginalPrice = !isEmpty(Price) ? Price.OriginalPrice : 0
                shipping = (Number(OriginalPrice) * Number(rate)).toFixed(2)
            }
        }
    }
    return shipping
}

export const getProductFeaturedValues = (product, keyName, common = 0) => {
    if (!isEmpty(product) && isObject(product)) {
        const FeaturedValues = product.FeaturedValues
        if (!isEmpty(FeaturedValues) && isArray(FeaturedValues)) {
            const FeatureItem = FeaturedValues.find((find) => find.Name === keyName)
            return !isEmpty(FeatureItem) && isObject(FeatureItem)
                ? FeatureItem.Value
                : common
        }
    }
    return common
}

export const matchAttributesConfigurator = (
    selectAttributes = [],
    ConfiguredItems = [],
) => {
    const remakeAttributes = selectAttributes.map((item) => {
        return { Pid: item.Pid, Vid: item.Vid }
    })
    return ConfiguredItems.filter((filter) => {
        const difference = differenceWith(
            remakeAttributes,
            filter.Configurators,
            (obj1, obj2) => {
                return obj1.Pid === obj2.Pid && obj1.Vid === obj2.Vid // Compare based on some property (e.g., id)
            },
        )
        return isEmpty(difference)
    })
}

export const getCartConfiguredItems = (cartConfigured, productId) => {
    if (!isEmpty(cartConfigured) && isArray(cartConfigured)) {
        const findItem = cartConfigured.find((find) => find.Id === productId)
        if (!isEmpty(findItem) && isObject(findItem)) {
            const ConfiguredItems = findItem.ConfiguredItems
            return !isEmpty(ConfiguredItems) && isArray(ConfiguredItems)
                ? ConfiguredItems
                : []
        }
    }
    return []
}

export const getCartSelectedConfig = (ConfiguredItems) => {
    if (!isEmpty(ConfiguredItems) && isArray(ConfiguredItems)) {
        const returnKey = ConfiguredItems.length === 1 ? ConfiguredItems[0] : {}
        return !isEmpty(returnKey) && isObject(returnKey) ? returnKey : {}
    }
    return {}
}

export const activeProductAllConfigurators = (activeCartProduct) => {
    if (isObject(activeCartProduct)) {
        return !isEmpty(activeCartProduct) ? activeCartProduct.ConfiguredItems : []
    }
    return []
}

export const checkExistConfiguredItem = (
    activeCartProduct,
    product_id,
    selectConfigId,
) => {
    const activeConfiguredItems =
        activeProductAllConfigurators(activeCartProduct)
    const activeFind = activeConfiguredItems.find(
        (find) => find.Id === selectConfigId,
    )
    return !isEmpty(activeFind) ? activeFind : {}
}

export const calculateAirShippingCharge = (subTotal, shipping_charges) => {
    let charges = shipping_charges ? JSON.parse(shipping_charges) : []
    let chargeAmount = 0
    for (let i = 0; i < charges.length; i++) {
        const dCharge = charges[i]
        if (subTotal === 0) {
            chargeAmount = dCharge.rate
            break
        } else if (dCharge.minimum <= subTotal && dCharge.maximum >= subTotal) {
            chargeAmount = dCharge.rate
            break
        }
    }
    return parseInt(chargeAmount)
}

// Customer cart calculation functions

export const cartProductTotal = (Product, ShippingCharges) => {
    let ConfiguredItems = Product.ConfiguredItems
    let ApproxWeight = Product.ApproxWeight
    let totalPrice = 0
    let totalQty = 0
    if (!isEmpty(ConfiguredItems)) {
        ConfiguredItems.map((summary) => {
            let Qty = Number(summary.Quantity)
            let Price = Number(summary.Price)
            totalQty += Qty
            totalPrice += Price * Qty
            return ''
        })
    }

    let ShippingRate = calculateAirShippingCharge(totalPrice, ShippingCharges)

    return {
        totalPrice: totalPrice,
        totalQty: totalQty,
        ShippingRate: ShippingRate,
        ApproxWeight: ApproxWeight,
        totalWeight: (Number(ApproxWeight) * Number(totalQty)).toFixed(3),
    }
}

export const cartColorAttributes = (attributes, product) => {
    if (isArray(attributes)) {
        return attributes.filter((filter) => filter.MiniImageUrl !== undefined)
    }
    return product.MainPictureUrl
}

export const CartSizeAttributes = (attributes) => {
    if (isArray(attributes)) {
        return attributes.filter((filter) => filter.MiniImageUrl === undefined)
    }
    return []
}

export const CartChinaShippingCost = (Product, ShippingCharges) => {
    let productTotal = cartProductTotal(Product)
    let DeliveryCost = Product.DeliveryCost ? Product.DeliveryCost : 0
    let totalWeight = productTotal.totalWeight
    let calculateCharge = calculateAirShippingCharge(
        productTotal.totalPrice,
        ShippingCharges,
    )
    let totalCost =
        Number(DeliveryCost) + Number(totalWeight) * Number(calculateCharge)
    return Number(totalCost).toFixed(2)
}

export const CartProductSubTotal = (Product, ShippingCharges) => {
    let productTotal = cartProductTotal(Product)
    let Subtotal = 0
    if (!isEmpty(productTotal)) {
        let otherCost = CartChinaShippingCost(Product, ShippingCharges)
        Subtotal = Number(productTotal.totalPrice) + Number(otherCost)
    }
    return numberWithCommas(Subtotal)
}

export const calculate_advanced_rate = (
    cart_total,
    rates,
    current_rate = 0,
) => {
    const settingRates = rates ? JSON.parse(rates) : []
    if (settingRates?.length > 0) {
        let adv = null
        for (let i = 0; i < settingRates?.length; i++) {
            const rate_row = settingRates[i]
            const minimum = rate_row?.minimum || 0
            const maximum = rate_row?.maximum || 0
            const rate = rate_row?.rate || 0
            if (cart_total >= minimum && cart_total <= maximum) {
                adv = Number(rate)
                break
            }
        }
        if (adv) {
            return adv
        }
    }
    return current_rate
}

export const CartProductSummary = (cart, advanced_rates, current_rate) => {
    let totalPrice = 0
    let shipping = 0
    let totalQty = 0
    let advanced = 0
    let dueAmount = 0
    cart?.cart_items?.forEach((product) => {
        const DeliveryCost = product?.DeliveryCost || 0
        const checkedVariations = product?.variations?.filter(filter => parseInt(filter.is_checked) === 1) || []
        const variationPrice = sumCartItemTotal(checkedVariations)
        const variationQty = sumCartItemTotalQuantity(checkedVariations)
        if (variationPrice > 0) {
            totalQty += variationQty
            totalPrice += variationPrice
            shipping += Number(DeliveryCost)
        }
    })
    if (totalPrice > 0) {
        totalPrice = Math.round(totalPrice + shipping)
        let actual_adv_rate = calculate_advanced_rate(
            totalPrice,
            advanced_rates,
            current_rate,
        )

        advanced = Math.round((totalPrice * actual_adv_rate) / 100)
        dueAmount = Math.round(totalPrice - advanced)
    }
    return { totalPrice, advanced, dueAmount, totalQty }
}

export const singleProductTotal = (product) => {
    let DeliveryCost = product?.DeliveryCost || 0
    let variations =
        product?.variations?.filter(
            (variation) => parseInt(variation.is_checked) === 1,
        ) || []
    let variationPrice = sumCartItemTotal(variations)
    if (variationPrice > 0) {
        return Math.round(
            variationPrice + (parseInt(DeliveryCost) > 0 ? parseInt(DeliveryCost) : 0),
        )
    }
    return 0
}

export const orderSummaryCalculation = (items, balanceAmount = 0) => {
    let totalValue = 0
    let productValue = 0
    let firstPayment = 0
    let dueAmount = 0
    let coupon_contribution = 0
    let DeliveryCost = 0
    items?.forEach((item) => {
        let total_value = parseInt(item.product_value) || 0
        let del_Cost = parseInt(item.DeliveryCost) || 0
        let contribution = parseInt(item.coupon_contribution) || 0
        let price = Number(item.product_value) + Number(item.DeliveryCost) - contribution
        let firstPrice = parseInt(item.first_payment)
        totalValue += total_value
        productValue += price
        coupon_contribution += contribution
        DeliveryCost += del_Cost
        firstPayment += firstPrice
        dueAmount += (price - firstPrice)
    })

    if (Number(balanceAmount) >= Number(firstPayment)) {
        balanceAmount = firstPayment
    }

    return {
        totalValue,
        productValue,
        coupon_contribution,
        DeliveryCost,
        balanceAmount: balanceAmount,
        firstPayment: Number(firstPayment) - Number(balanceAmount),
        dueAmount,
    }
}

export const taobaoProductPrepareForLove = (product, rate) => {
    const FeaturedValues = product?.FeaturedValues
    const ProviderType = product?.ProviderType
    const TotalSales = FeaturedValues?.find(
        (find) => find.Name === 'TotalSales',
    )?.Value
    const averageStar = FeaturedValues?.find(
        (find) => find.Name === 'favCount',
    )?.Value
    const promoPrice = product?.Promotions?.[0].Price || {}
    const regularPrice = product?.Price
    const sale_price = parseInt(promoPrice?.OriginalPrice) || 0
    const regular_price = parseInt(regularPrice?.OriginalPrice) || 0
    return {
        name: product?.Title,
        ItemId: product?.Id || product?.ItemId,
        provider_type: ProviderType,
        img: product?.MainPictureUrl,
        rating: averageStar,
        sale_price: sale_price
            ? sale_price * parseInt(rate)
            : regular_price * parseInt(rate),
        regular_price: regular_price * parseInt(rate),
        stock: product?.MasterQuantity,
        total_sold: TotalSales,
    }
}

export const taobaoCardProductPrepareForLove = (product) => {
    const price = product?.price || 0
    const regular_price = product?.regular_price || 0

    return {
        name: product?.name,
        ItemId: product?.item_id,
        provider_type: product?.provider_type,
        img: product?.image_url,
        rating: null,
        sale_price: price ? price : regular_price,
        regular_price: regular_price,
        stock: product?.master_quantity,
        total_sold: product?.total_sold,
    }
}


// filtered tracking data
export const modifiedAdjustedTracking = (data = []) => {
    let isAdjusted = null
    let list_data = data || []
    data?.forEach((item) => {
        let findAdjust = item?.exceptions?.find(find => find.status === 'adjusted-by-invoice')
        if (!isAdjusted && findAdjust) {
            isAdjusted = findAdjust
        }
    })
    if (isAdjusted) {
        list_data = data?.filter(filter => filter.status !== 'delivered')
    }
    return list_data
}


export const queryPagination = (query) => {
    if (Object.keys(query).length > 0) {
        let pagination = {}
        for (const key in query) {
            let value = query[key]
            if (value > 0) {
                pagination[key] = parseInt(value)
            } else {
                pagination[key] = value
            }
        }
        return pagination
    }
    return { current: 1, pageSize: 10, total: 1 }
}
export const itemIsCheckWillProcess = (cartItem, settings) => {
    const min_order_amount = settings?.min_order_amount || 0
    const ali_min_order_value = settings?.ali_min_order_value || 0
    const express_shipping_min_value = settings?.express_shipping_min_value || 0
    let process = true
    let minOrder = min_order_amount
    if (cartItem?.ProviderType === 'aliexpress') {
        minOrder = ali_min_order_value
        if (cartItem?.shipping_type === 'express') {
            minOrder = express_shipping_min_value
        }
    }
    const checkedVariations = cartItem?.variations?.filter(
        (variation) => parseInt(variation.is_checked) === 1,
    ) || []
    const itemTotal = sumCartItemTotal(checkedVariations)
    if (Number(itemTotal) > 0) {
        if (Number(itemTotal) < Number(minOrder)) {
            process = false
        }
        return { process, minOrder }
    }
    return { process: true }
}


export const itemValidateWillPayment = (cartItems, settings) => {
    const currency = settings?.currency_icon
    let process = true
    for (let i = 0; i < cartItems.length; i++) {
        const product = cartItems[i]
        const { process: willProcess, minOrder } = itemIsCheckWillProcess(
            product,
            settings,
        )
        const Title = product?.Title
        if (!willProcess) {
            Swal.fire({
                icon: 'info',
                html:
                    `<b>Product value must be greater than ${currency} ${minOrder}</b> </br>` +
                    `<p class="text-danger mb-0">${Title}</p>`,
                confirmButtonText: 'Ok, Understood',
            })
            process = false
            break
        }
    }

    return process
}


export const wholesaleItemValidateWillPayment = (cartItems, settings, warning) => {

    let min_amt = parseInt(settings?.alibaba1688_min_amt) || 1500
    let min_qty = parseInt(settings?.alibaba1688_min_qty) || 2
    let process = true
    for (let i = 0; i < cartItems.length; i++) {
        const item = cartItems[i]
        const itemTitle = item?.Title || ''
        const total_weight = calculateTotalWeight1688(item)

        if (item?.shipped_by === 'by_sea') {
            if (total_weight < 200) {
                warning(`${itemTitle} <br/> Ship by sea minimum weight 200kg.`)
                process = false
                break
            }
        }

        let min_lot_qty = item?.FirstLotQuantity || 0
        min_lot_qty = Math.max(min_lot_qty, min_qty)

        const variations = item.variations.filter(variation => parseInt(variation.is_checked) === 1)
        if (variations?.length > 0) {
            const total_qty = variations.reduce((total, curr) => total + curr.qty, 0)
            const total_price = variations.reduce((total, curr) => total + (curr.price * curr.qty), 0)
            if (min_lot_qty > total_qty && total_qty > 0) {

                Swal.fire({
                    icon: 'warning',
                    html: `<p>${itemTitle}</p>`,
                    confirmButtonText: 'Ok, Understood',
                })

                // min_quantity_validation({ ...item, total_qty, min_lot_qty })
                process = false
                break
            } else if (min_amt > total_price && total_qty > 0) {
                // min_amount_validation({ ...item, total_price, min_amt })
                Swal.fire({
                    icon: 'warning',
                    html: `<p>${itemTitle}</p>`,
                    confirmButtonText: 'Ok, Understood',
                })
                process = false
                break
            }
        }
    }

    return process
}