1#@!#!123s

ALWAYS HENGHENG888 1#@!#!123s
: / var / www / chinawholesale-frontend-next / src / helpers /
Filename : product.ts
back
import { rn } from '@/helpers/general'
import { KeyValuePairs } from '@/types/global'


export const formatQuantityRanges = (product, curr_rate) => {
    let QuantityRanges = product?.QuantityRanges || []
    if (QuantityRanges?.length > 0) {
        let ranges = []
        QuantityRanges?.forEach((item) => {
            let OriginalPrice = item?.Price?.OriginalPrice || 0
            let MarginPrice = item?.Price?.MarginPrice || 0
            let is_discount = (MarginPrice > OriginalPrice)
            let Price = {
                OriginalPrice: rn(OriginalPrice * curr_rate),
                MarginPrice: rn(MarginPrice * curr_rate),
            }
            ranges.push({ ...item, is_discount, Price })
        })
        return ranges
    }
    return []
}


export const currentActiveRange = (ranges, quantity = 1) => {
    let filtered_qty = 0
    if (ranges?.length > 0) {
        for (let i = 0; i < ranges.length; i++) {
            let QtyRange = ranges[i]
            let MinQuantity = QtyRange.MinQuantity
            if (quantity < MinQuantity) {
                filtered_qty = QtyRange.Price.OriginalPrice
                break
            } else {
                let nextQtyRange = ranges[i + 1]
                if (nextQtyRange) {
                    nextQtyRange = nextQtyRange.MinQuantity
                    if (MinQuantity <= quantity && quantity < nextQtyRange) {
                        filtered_qty = QtyRange.Price.OriginalPrice
                        break
                    }
                } else {
                    filtered_qty = QtyRange.Price.OriginalPrice
                }
            }
        }
    }
    return filtered_qty
}


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


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 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?.image || 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 plainAttributesArray = (Attributes) => {
    if (!Object?.keys(Attributes)?.length) {
        return []
    }
    const values = Object.values(Attributes)
    let newArray = []
    values.forEach(item => {
        newArray = newArray.concat(item)
    })
    return newArray
}

export const compareArrays = (arr1, arr2, keys) => {
    const createKey = (obj, keys) => keys.map(key => obj[key]).join('|')

    const map1 = new Map(arr1.map(item => [createKey(item, keys), item]))
    const map2 = new Map(arr2.map(item => [createKey(item, keys), item]))

    const onlyInArr1 = arr1.filter(item => !map2.has(createKey(item, keys)))
    const onlyInArr2 = arr2.filter(item => !map1.has(createKey(item, keys)))

    return {
        onlyInArr1,
        onlyInArr2,
    }
}

export const getFormatConfiguredItems = (product: KeyValuePairs, operationalConfigItems: KeyValuePairs[], activeAttributes: KeyValuePairs[], rate: number) => {
    // let ConfiguredItems = product?.ConfiguredItems || [];
    // let QuantityRanges = product?.QuantityRanges || [];
    let Attributes = product?.Attributes || {}
    Attributes = plainAttributesArray(Attributes)

    let newConfigure = []
    if (operationalConfigItems?.length > 0) {
        operationalConfigItems?.forEach((item) => {
            let Configurators = item?.Configurators || []
            let singleConfig = item?.singleConfig || null
            let hasConfig = false
            if (!activeAttributes.length) {
                hasConfig = true
            } else {
                if (singleConfig && Configurators.length > 1) {
                    const otherConfig = Configurators.filter((config) => config.Pid !== singleConfig.Pid && config.Vid !== singleConfig.Vid)
                    const differences = compareArrays(otherConfig, activeAttributes, ['Pid', 'Vid'])
                    if (!differences.onlyInArr1.length && !differences.onlyInArr2.length) {
                        hasConfig = true
                    }
                } else {
                    const differences = compareArrays(Configurators, activeAttributes, ['Pid', 'Vid'])
                    if (!differences.onlyInArr1.length && !differences.onlyInArr2.length) {
                        hasConfig = true
                    }
                }
            }

            if (hasConfig) {
                let Price = {
                    MarginPrice: undefined, OriginalPrice: undefined,
                }
                let OriginalPrice = item?.Price?.OriginalPrice || 0
                let MarginPrice = item?.Price?.MarginPrice || 0
                Price.MarginPrice = rn(MarginPrice * rate)
                Price.OriginalPrice = rn(OriginalPrice * rate)
                Configurators = item?.Configurators?.map((config) => {
                    return Attributes?.find((attr) => attr?.Pid === config.Pid && attr?.Vid === config.Vid)
                })
                let QuantityRanges = []
                item?.QuantityRanges?.forEach((range) => {
                    let rangePrice = {
                        MarginPrice: undefined, OriginalPrice: undefined,
                    }
                    let rangeOriginalPrice = range?.Price?.OriginalPrice || 0
                    let rangeMarginPrice = range?.Price?.MarginPrice || 0
                    rangePrice.MarginPrice = rn(rangeMarginPrice * rate)
                    rangePrice.OriginalPrice = rn(rangeOriginalPrice * rate)
                    QuantityRanges.push({ ...range, Price: rangePrice })
                })
                newConfigure.push({ ...item, Price, Configurators, QuantityRanges })
            }
        })
        return newConfigure
    }
    return []
}

export const quantityRangePriceSlubFilter = (ranges: any, quantity: any) => {
    let OriginalPrice = 0
    if (ranges?.length > 0) {
        for (let i = 0; i < ranges.length; i++) {
            let QtyRange = ranges[i]
            let MinQuantity = QtyRange.MinQuantity
            if (quantity < MinQuantity) {
                OriginalPrice = QtyRange.Price.OriginalPrice
                break
            } else {
                let nextQtyRange = ranges[i + 1]
                if (nextQtyRange?.MinQuantity) {
                    nextQtyRange = nextQtyRange.MinQuantity

                    if (MinQuantity <= quantity && quantity < nextQtyRange) {
                        OriginalPrice = QtyRange.Price.OriginalPrice
                        break
                    }
                } else {
                    OriginalPrice = QtyRange.Price.OriginalPrice
                    // console.log({ EWEWEW: nextQtyRange, OriginalPrice })
                }
            }
        }
    }
    return OriginalPrice
}

export const configurePriceFilter = (config: KeyValuePairs, quantity = 1) => {
    const OriginalPrice = config?.Price?.OriginalPrice
    const ranges = config?.QuantityRanges || []
    const range_price = quantityRangePriceSlubFilter(ranges, quantity)
    return range_price ? range_price : OriginalPrice
}

export const findActiveAttribute = (Attributes, config) => {
    if (!Object?.keys(Attributes)?.length && config) {
        return null
    }

    let single = null
    let collections = null
    for (const attribute in Attributes) {
        const items = Attributes[attribute]
        // console.log({items})
        if (!items.length) {
            continue
        }
        const findItem = items.find((attr) => attr?.Pid === config?.Pid && attr?.Vid === config?.Vid)

        collections = items.filter((attr) => attr?.Pid === config?.Pid)
        if (findItem) {
            single = findItem
            break
        }
    }

    return { single, collections }
}

export const getUniqueBy = (array, key) => {
    const seen = new Map()
    return array.reduce((result, item) => {
        const keyValue = item[key]

        if (!seen.has(keyValue)) {
            seen.set(keyValue, true)
            result.push(item)
        }

        return result
    }, [])
}

export const getGroupByAttributes = (array, key) => {
    return array.reduce((result, currentValue) => {
        const groupKey = currentValue[key]
        if (!result[groupKey]) {
            result[groupKey] = []
        }
        result[groupKey].push(currentValue)
        return result
    }, {})
}

export const calculateTotalWeight1688 = (cartItem: any) => {

    const cart_weight = cartItem?.weight > 0 ? parseFloat(cartItem?.weight) : 0
    const cart_quantity = cartItem?.Quantity > 0 ? parseInt(cartItem?.Quantity) : 0
    return Number(cart_weight * cart_quantity).toFixed(2)

}


export const getProductWeight = (product: any) => {
    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 sumCartItemTotal = (variations: any) => {
    return variations?.length > 0 ?
        variations?.reduce((sum: any, { price, qty }) => sum + Number(price) * Number(qty), 0)
        : 0
}


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

export const taobaoSellerPositiveScore = (VendorScore: any) => {
    const percent = (VendorScore / 20) * 100
    return Math.round(percent)
}


export const cartItemCheckedVariousTotal = (variations: any) => {
    const checkedVariations =
        variations?.filter((item: any) => parseInt(item.is_checked) === 1) || []
    return sumCartItemTotal(checkedVariations)
}


export const singleProductTotal = (product: any) => {
    let DeliveryCost = product?.DeliveryCost || 0
    let variations =
        product?.variations?.filter((variation: any) => 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 getProductGroupedAttributes = (Attributes: any) => {

    if (!Object.keys(Attributes)?.length) {
        return []
    }

    let dataSource = [];
    Object.keys(Attributes).forEach((keyName) => {
        dataSource.push({
            name: keyName,
            values: Attributes[keyName],
        })
    });
    return dataSource;

}