765 lines
22 KiB
TypeScript
765 lines
22 KiB
TypeScript
import type { Product } from '@/models/products'
|
|
import { usePriceWithoutType } from '@/utils/usePrice'
|
|
import type { UserWalletLine } from '@/models/wallet'
|
|
import type { ProductFile } from '@/utils/file'
|
|
import type { WalletInventoryCard, WalletMetalTotal } from '@/models/walletAssets'
|
|
import { getFileUrl } from '@/utils/file'
|
|
import { isCountBasedProduct, getProductQuantityUnit, type ProductUnitSource } from '@/utils/productDealMethod'
|
|
import { isMeltedTradeGroup, normalizeProductGroupType, LEGACY_GROUP_KATOD } from '@/utils/productCategories'
|
|
import defaultImg from '@/assets/img/defaultAbshodeh.svg'
|
|
import goyImg from '@/assets/img/goyImg.svg'
|
|
import mokaabImg from '@/assets/img/mokaabImg.svg'
|
|
import sekkeImg from '@/assets/img/sekkeImg.svg'
|
|
import mesImg from '@/assets/img/mesImg.jpg'
|
|
import noghrehImg from '@/assets/img/noghrehImg.webp'
|
|
import parsianImg from '@/assets/img/parsianImg.svg'
|
|
|
|
export const METAL_GOLD = 1
|
|
export const METAL_SILVER = 2
|
|
export const METAL_COPPER = 3
|
|
|
|
const GROUP_DEFAULT_IMAGES: Record<string, string> = {
|
|
گوی: goyImg,
|
|
مکعب: mokaabImg,
|
|
سکه: sekkeImg,
|
|
مس: mesImg,
|
|
[LEGACY_GROUP_KATOD]: mesImg,
|
|
نقره: noghrehImg,
|
|
'سکه پارسیان': parsianImg,
|
|
طلا: defaultImg,
|
|
آبشده: defaultImg,
|
|
}
|
|
|
|
export function getMetalLabel(metalId: number): string {
|
|
switch (metalId) {
|
|
case METAL_GOLD:
|
|
return 'طلا'
|
|
case METAL_SILVER:
|
|
return 'نقره'
|
|
case METAL_COPPER:
|
|
return 'مس'
|
|
default:
|
|
return 'فلز'
|
|
}
|
|
}
|
|
|
|
export function getTotalMetalLabel(metalId: number): string {
|
|
return `کل دارایی ${getMetalLabel(metalId)}`
|
|
}
|
|
|
|
/** boursecu home — ترتیب نمایش: مس، طلا، سایر فلزها */
|
|
export function resolveBoursecuAssetMetalTotals(
|
|
metalTotals: WalletMetalTotal[]
|
|
): WalletMetalTotal[] {
|
|
if (!metalTotals.length) {
|
|
return []
|
|
}
|
|
|
|
const ordered: WalletMetalTotal[] = []
|
|
const copper = metalTotals.find((metal) => metal.metal_id === METAL_COPPER)
|
|
const gold = metalTotals.find((metal) => metal.metal_id === METAL_GOLD)
|
|
|
|
if (copper) {
|
|
ordered.push(copper)
|
|
}
|
|
if (gold) {
|
|
ordered.push(gold)
|
|
}
|
|
|
|
for (const metal of metalTotals) {
|
|
if (!ordered.some((item) => item.metal_id === metal.metal_id)) {
|
|
ordered.push(metal)
|
|
}
|
|
}
|
|
|
|
return ordered
|
|
}
|
|
|
|
export function resolveMetalAssetsDisplayLabel(
|
|
metal: WalletMetalTotal,
|
|
isBoursecuLayout: boolean
|
|
): string {
|
|
if (!isBoursecuLayout) {
|
|
return metal.label
|
|
}
|
|
|
|
switch (metal.metal_id) {
|
|
case METAL_COPPER:
|
|
return 'دارایی مس'
|
|
case METAL_GOLD:
|
|
return 'دارایی شمش مس'
|
|
case METAL_SILVER:
|
|
return 'دارایی نقره'
|
|
default:
|
|
return metal.label
|
|
}
|
|
}
|
|
|
|
export type HomeAssetRowInfo = 'metal' | 'rial' | 'none'
|
|
|
|
export interface HomeAssetRow {
|
|
id: string
|
|
label: string
|
|
value: string
|
|
metal?: WalletMetalTotal
|
|
info: HomeAssetRowInfo
|
|
/** boursecu — متن مودال توضیحات (info) */
|
|
modalText?: string
|
|
/** boursecu — عنوان مودال (مثلاً کل دارایی مس) */
|
|
modalTitle?: string
|
|
/** boursecu — محتوای چندخطی مودال */
|
|
modalContent?: string
|
|
}
|
|
|
|
function formatInventoryCardProductLabel(card: WalletInventoryCard): string {
|
|
return `دارایی ${card.title}`
|
|
}
|
|
|
|
/** boursecu — متن مودال برای ردیف‌های metal_totals */
|
|
export function formatBoursecuMetalModalText(metal: WalletMetalTotal): string {
|
|
switch (metal.metal_id) {
|
|
case METAL_COPPER:
|
|
return getTotalMetalLabel(METAL_COPPER)
|
|
case METAL_GOLD:
|
|
return 'دارایی شمش مس = موجودی شمش مس'
|
|
case METAL_SILVER:
|
|
return 'دارایی نقره = موجودی نقره'
|
|
default:
|
|
return `${resolveMetalAssetsDisplayLabel(metal, true)} = موجودی ${metal.label}`
|
|
}
|
|
}
|
|
|
|
/** boursecu — جمع موجودی کاتد، مفتول و شمش از کارت‌های دارایی صفحه اصلی */
|
|
function sumBoursecuHomeProductInventories(
|
|
inventoryCards: WalletInventoryCard[],
|
|
countProducts: WalletInventoryCard[]
|
|
): number {
|
|
let sum = 0
|
|
|
|
for (const card of inventoryCards) {
|
|
if (card.display_type === 'count') {
|
|
continue
|
|
}
|
|
sum += Number(card.quantity ?? 0)
|
|
}
|
|
|
|
for (const card of countProducts) {
|
|
const quantity = Number(card.quantity ?? 0)
|
|
const unitWeight = Number(card.unit_weight ?? 0)
|
|
if (unitWeight > 0) {
|
|
sum += quantity * unitWeight
|
|
continue
|
|
}
|
|
|
|
if (card.unit?.includes('کیلو')) {
|
|
sum += quantity
|
|
}
|
|
}
|
|
|
|
return sum
|
|
}
|
|
|
|
type BoursecuModalProduct = {
|
|
title: string
|
|
quantity: number
|
|
unit: string
|
|
}
|
|
|
|
function toBoursecuModalProduct(card: WalletInventoryCard): BoursecuModalProduct {
|
|
return {
|
|
title: card.title,
|
|
quantity: Number(card.quantity ?? 0),
|
|
unit: card.unit ?? (card.display_type === 'count' ? 'عدد' : 'کیلوگرم'),
|
|
}
|
|
}
|
|
|
|
function resolveBoursecuMetalModalProduct(
|
|
metal: WalletMetalTotal,
|
|
countProducts: WalletInventoryCard[]
|
|
): BoursecuModalProduct {
|
|
const countCard =
|
|
countProducts.find((card) => Number(card.metal_id) === metal.metal_id) ??
|
|
countProducts.find((card) => card.title?.includes('شمش'))
|
|
|
|
if (countCard) {
|
|
return toBoursecuModalProduct(countCard)
|
|
}
|
|
|
|
if (metal.metal_id === METAL_GOLD) {
|
|
return {
|
|
title: 'شمش مس',
|
|
quantity: Number(metal.total_weight ?? 0),
|
|
unit: 'عدد',
|
|
}
|
|
}
|
|
|
|
return {
|
|
title: metal.label,
|
|
quantity: Number(metal.total_weight ?? 0),
|
|
unit: metal.unit ?? 'کیلوگرم',
|
|
}
|
|
}
|
|
|
|
/** boursecu — جزئیات کل دارایی مس در مودال info */
|
|
export function formatBoursecuCopperAssetsModalContent(
|
|
metal: WalletMetalTotal,
|
|
inventoryCards: WalletInventoryCard[],
|
|
countProducts: WalletInventoryCard[],
|
|
product: BoursecuModalProduct
|
|
): string {
|
|
const weightUnit = metal.unit || 'کیلوگرم'
|
|
const productWeight = usePriceWithoutType(
|
|
sumBoursecuHomeProductInventories(inventoryCards, countProducts),
|
|
false
|
|
)
|
|
const clickedQuantity = usePriceWithoutType(product.quantity, false)
|
|
|
|
return [
|
|
`مجموع کیف محصولات: ${productWeight} ${weightUnit}`,
|
|
`موجودی ${product.title}: ${clickedQuantity} ${product.unit}`,
|
|
].join('\n')
|
|
}
|
|
|
|
function withBoursecuCopperModal(
|
|
row: Omit<HomeAssetRow, 'modalTitle' | 'modalContent'>,
|
|
copperTotal: WalletMetalTotal | undefined,
|
|
inventoryCards: WalletInventoryCard[],
|
|
countProducts: WalletInventoryCard[],
|
|
product: BoursecuModalProduct
|
|
): HomeAssetRow {
|
|
if (!copperTotal) {
|
|
return row
|
|
}
|
|
|
|
return {
|
|
...row,
|
|
metal: copperTotal,
|
|
modalTitle: getTotalMetalLabel(METAL_COPPER),
|
|
modalContent: formatBoursecuCopperAssetsModalContent(
|
|
copperTotal,
|
|
inventoryCards,
|
|
countProducts,
|
|
product
|
|
),
|
|
}
|
|
}
|
|
|
|
function findMetalTotalById(metalTotals: WalletMetalTotal[], metalId: number) {
|
|
return metalTotals.find((metal) => metal.metal_id === metalId)
|
|
}
|
|
|
|
function formatBoursecuMetalRowValue(metal: WalletMetalTotal): string {
|
|
const amount = usePriceWithoutType(Number(metal.total_weight ?? 0), false)
|
|
if (metal.metal_id === METAL_GOLD) {
|
|
return `${amount} عدد`
|
|
}
|
|
return `${amount}${metal.unit ?? ''}`
|
|
}
|
|
|
|
/** boursecu home — هر محصول / فلز / ریال از customer/wallet/assets جدا نمایش داده می‌شود */
|
|
export function buildBoursecuHomeAssetRows(
|
|
summary: {
|
|
inventory_cards?: WalletInventoryCard[]
|
|
count_products?: WalletInventoryCard[]
|
|
metal_totals?: WalletMetalTotal[]
|
|
total_rial_value?: number
|
|
} | null | undefined
|
|
): HomeAssetRow[] {
|
|
if (!summary) {
|
|
return []
|
|
}
|
|
|
|
const rows: HomeAssetRow[] = []
|
|
const metalTotals = summary.metal_totals ?? []
|
|
const inventoryCards = summary.inventory_cards ?? []
|
|
const countProducts = summary.count_products ?? []
|
|
const copperTotal = findMetalTotalById(metalTotals, METAL_COPPER)
|
|
|
|
for (const card of inventoryCards) {
|
|
if (card.display_type === 'count') {
|
|
continue
|
|
}
|
|
|
|
rows.push(
|
|
withBoursecuCopperModal(
|
|
{
|
|
id: `inventory-${card.product_id}`,
|
|
label: formatInventoryCardProductLabel(card),
|
|
value: formatInventoryCardValue(card),
|
|
metal: findMetalTotalById(metalTotals, card.metal_id),
|
|
info: 'metal',
|
|
},
|
|
copperTotal,
|
|
inventoryCards,
|
|
countProducts,
|
|
toBoursecuModalProduct(card)
|
|
)
|
|
)
|
|
}
|
|
|
|
for (const metal of metalTotals) {
|
|
if (metal.metal_id === METAL_COPPER) {
|
|
continue
|
|
}
|
|
|
|
rows.push(
|
|
withBoursecuCopperModal(
|
|
{
|
|
id: `metal-${metal.metal_id}`,
|
|
label: resolveMetalAssetsDisplayLabel(metal, true),
|
|
value: formatBoursecuMetalRowValue(metal),
|
|
metal,
|
|
info: 'metal',
|
|
},
|
|
copperTotal,
|
|
inventoryCards,
|
|
countProducts,
|
|
resolveBoursecuMetalModalProduct(metal, countProducts)
|
|
)
|
|
)
|
|
}
|
|
|
|
for (const card of countProducts) {
|
|
rows.push(
|
|
withBoursecuCopperModal(
|
|
{
|
|
id: `count-${card.product_id}`,
|
|
label: formatInventoryCardProductLabel(card),
|
|
value: formatInventoryCardValue(card),
|
|
metal: findMetalTotalById(metalTotals, card.metal_id),
|
|
info: 'metal',
|
|
},
|
|
copperTotal,
|
|
inventoryCards,
|
|
countProducts,
|
|
toBoursecuModalProduct(card)
|
|
)
|
|
)
|
|
}
|
|
|
|
rows.push({
|
|
id: 'rial-total',
|
|
label: 'دارایی ریالی',
|
|
value: `${formatRialNumber(summary.cash_wallet ?? 0)} ریال`,
|
|
info: 'rial',
|
|
})
|
|
|
|
return rows
|
|
}
|
|
|
|
export function sumInventoryCardsWeight(
|
|
cards: Array<{ metal_id?: number; quantity?: number }>,
|
|
metalId: number
|
|
): number {
|
|
return cards
|
|
.filter((card) => Number(card.metal_id) === metalId)
|
|
.reduce((sum, card) => sum + Number(card.quantity ?? 0), 0)
|
|
}
|
|
|
|
/** ردیف‌های جزئی action sheet — فقط محصولاتی که show_in_assets روشن است. */
|
|
export function assetSheetInventoryCards<T extends { metal_id?: number; show_in_assets?: boolean }>(
|
|
cards: T[],
|
|
metalId?: number
|
|
): T[] {
|
|
return cards.filter((card) => {
|
|
if (!card.show_in_assets) {
|
|
return false
|
|
}
|
|
if (metalId == null) {
|
|
return true
|
|
}
|
|
return Number(card.metal_id) === metalId
|
|
})
|
|
}
|
|
|
|
/** همه کارت‌های صفحه دارایی‌ها — بدون فیلتر show_in_assets. */
|
|
export function fundPageInventoryCards<T>(cards: T[]): T[] {
|
|
return cards.filter((card) => Number((card as { quantity?: number }).quantity ?? 0) > 0)
|
|
}
|
|
|
|
export function resolveSummaryMetalWeight(
|
|
metal: { total_weight: number },
|
|
_cards?: Array<{ metal_id?: number; quantity?: number }>
|
|
): number {
|
|
return Number(metal.total_weight ?? 0)
|
|
}
|
|
|
|
/** متن توضیح مودال دارایی فلزی — بر اساس metal_totals سرور، بدون هاردکد طلا */
|
|
export function formatMetalAssetsInfoText(metal: WalletMetalTotal): string {
|
|
const unit = metal.unit || 'گرم'
|
|
return `${metal.label}: مجموع کیف محصولات (${metal.product_weight} ${unit}) + موجودی کیف اصلی (${metal.melted_weight} ${unit})`
|
|
}
|
|
|
|
function formatRialNumber(value: number): string {
|
|
return usePriceWithoutType(value)
|
|
}
|
|
|
|
/** متن توضیح مودال دارایی ریالی */
|
|
export function formatRialAssetsInfoText(cashWallet: number, metalRialValue: number): string {
|
|
const total = cashWallet + metalRialValue
|
|
return [
|
|
`کیف پول ریالی: ${formatRialNumber(cashWallet)} ریال`,
|
|
`ارزش ریالی طلا (وزن × قیمت زنده): ${formatRialNumber(metalRialValue)} ریال`,
|
|
`مجموع: ${formatRialNumber(total)} ریال`,
|
|
].join('\n')
|
|
}
|
|
|
|
/** ارزش ریالی فلزات از وزن × قیمت زنده — fallback کلاینت قبل از deploy بک‌اند */
|
|
export function computeMetalRialValue(
|
|
metalTotals: Array<{ metal_id?: number; total_weight?: number }>,
|
|
liveGoldPrice: number,
|
|
livePricesByMetal?: Partial<Record<number, number>>
|
|
): number {
|
|
return metalTotals.reduce((sum, metal) => {
|
|
const weight = Number(metal.total_weight ?? 0)
|
|
if (weight <= 0) {
|
|
return sum
|
|
}
|
|
|
|
const metalId = Number(metal.metal_id ?? 0)
|
|
const unitPrice =
|
|
livePricesByMetal?.[metalId] ??
|
|
(metalId === METAL_GOLD ? liveGoldPrice : 0)
|
|
|
|
return sum + weight * unitPrice
|
|
}, 0)
|
|
}
|
|
|
|
export function resolveAssetsRialValue(
|
|
summary: { assets_rial_value?: number; metal_totals?: Array<{ metal_id?: number; total_weight?: number }> } | null | undefined,
|
|
liveGoldPrice: number
|
|
): number {
|
|
const fromServer = Number(summary?.assets_rial_value ?? 0)
|
|
if (fromServer > 0) {
|
|
return fromServer
|
|
}
|
|
|
|
return computeMetalRialValue(summary?.metal_totals ?? [], liveGoldPrice)
|
|
}
|
|
|
|
export function formatInventoryCardValue(card: {
|
|
quantity?: number
|
|
unit?: string
|
|
display_type?: string
|
|
}): string {
|
|
const quantity = Number(card.quantity ?? 0)
|
|
const unit = card.unit ?? (card.display_type === 'count' ? 'عدد' : 'گرم')
|
|
return `${usePriceWithoutType(quantity, false)} ${unit}`
|
|
}
|
|
|
|
export function findProductInventoryCard(
|
|
cards: WalletInventoryCard[],
|
|
productId?: number | null
|
|
): WalletInventoryCard | undefined {
|
|
if (!productId) {
|
|
return undefined
|
|
}
|
|
|
|
return cards.find((item) => Number(item.product_id) === Number(productId))
|
|
}
|
|
|
|
/**
|
|
* موجودی کیف یک محصول از inventory_cards.
|
|
* fallback: پروژه‌های ساختار قدیم (مثل گلد علی) کیف محصول ندارند و موجودی روی gold کیف اصلی است.
|
|
*/
|
|
export function getProductInventoryQuantity(
|
|
cards: WalletInventoryCard[],
|
|
productId?: number | null,
|
|
mainWalletGold?: number | null
|
|
): number {
|
|
const card = findProductInventoryCard(cards, productId)
|
|
if (card) {
|
|
return Number(card.quantity ?? 0)
|
|
}
|
|
|
|
return Number(mainWalletGold ?? 0)
|
|
}
|
|
|
|
/** برچسب موجودی کیف محصول — برای فرم خرید/فروش */
|
|
export function formatProductWalletBalanceText(
|
|
product: { id?: number; title?: string | null; unit?: string | null; group_type?: string | null } | null | undefined,
|
|
cards: WalletInventoryCard[] = [],
|
|
mainWalletGold?: number | null
|
|
): string {
|
|
const card = findProductInventoryCard(cards, product?.id)
|
|
const quantity = card ? Number(card.quantity ?? 0) : Number(mainWalletGold ?? 0)
|
|
const unit = card?.unit ?? getProductQuantityUnit(product)
|
|
const title = product?.title?.trim() || 'محصول'
|
|
|
|
return `موجودی کیف ${title}: ${quantity} ${unit}`
|
|
}
|
|
|
|
export function isSingleMetalCatalog(metalIds: number[]): boolean {
|
|
return metalIds.length === 1
|
|
}
|
|
|
|
export function getCatalogMetalIds(products?: Product[] | null): number[] {
|
|
const ids = new Set<number>()
|
|
for (const product of products ?? []) {
|
|
const metalId = Number(product.metal_id)
|
|
if (metalId > 0) {
|
|
ids.add(metalId)
|
|
}
|
|
}
|
|
return Array.from(ids).sort((a, b) => a - b)
|
|
}
|
|
|
|
export function catalogHasCountBasedProducts(products?: Product[] | null): boolean {
|
|
return (products ?? []).some((product) => isCountBasedProduct(product))
|
|
}
|
|
|
|
export function catalogHasMeltedProducts(products?: Product[] | null): boolean {
|
|
return (products ?? []).some((product) => isMeltedTradeGroup(product.group_type))
|
|
}
|
|
|
|
export function enrichInventoryCardsWithCatalog<T extends { product_id?: number; file?: ProductFile | null }>(
|
|
cards: T[],
|
|
catalog: Product[]
|
|
): T[] {
|
|
return cards.map((card) => {
|
|
const fromCatalog = catalog.find((product) => product.id === card.product_id)
|
|
if (!fromCatalog) {
|
|
return card
|
|
}
|
|
|
|
return {
|
|
...card,
|
|
file: card.file ?? fromCatalog.file ?? null,
|
|
}
|
|
})
|
|
}
|
|
|
|
export function enrichInventoryWithCatalog<T extends { id?: number }>(
|
|
items: T[],
|
|
catalog: Product[]
|
|
): T[] {
|
|
return items.map((item) => {
|
|
const fromCatalog = catalog.find((product) => product.id === item.id)
|
|
if (!fromCatalog) {
|
|
return item
|
|
}
|
|
|
|
const current = item as T & Product
|
|
return {
|
|
...fromCatalog,
|
|
...current,
|
|
wallet: current.wallet ?? fromCatalog.wallet,
|
|
file: current.file ?? fromCatalog.file,
|
|
metal_id: current.metal_id ?? fromCatalog.metal_id,
|
|
group_type: current.group_type ?? fromCatalog.group_type,
|
|
}
|
|
})
|
|
}
|
|
|
|
export function getProductDisplayImage(product?: {
|
|
group_type?: string | null
|
|
title?: string | null
|
|
file?: ProductFile | null
|
|
img?: string | null
|
|
} | null): string {
|
|
const fileUrl = getFileUrl(product?.file)
|
|
if (fileUrl) {
|
|
return fileUrl
|
|
}
|
|
|
|
if (product?.img && /^https?:\/\//i.test(product.img)) {
|
|
return product.img
|
|
}
|
|
|
|
const group = normalizeProductGroupType(product?.group_type)
|
|
if (group && GROUP_DEFAULT_IMAGES[group]) {
|
|
return GROUP_DEFAULT_IMAGES[group]
|
|
}
|
|
|
|
return defaultImg
|
|
}
|
|
|
|
type InventoryProduct = ProductUnitSource & {
|
|
metal_id?: number | null
|
|
title?: string | null
|
|
wallet?: { gold?: number | null } | null
|
|
}
|
|
|
|
export function sumCountBasedInventory(products?: InventoryProduct[] | null): number {
|
|
return (products ?? [])
|
|
.filter((product) => product.title !== 'آبشده نقدی' && isCountBasedProduct(product))
|
|
.reduce((sum, product) => sum + Number(product.wallet?.gold ?? 0), 0)
|
|
}
|
|
|
|
export function sumProductWalletByMetal(
|
|
products: InventoryProduct[] | null | undefined,
|
|
metalId: number
|
|
): number {
|
|
return (products ?? [])
|
|
.filter((product) => Number(product.metal_id) === metalId)
|
|
.reduce((sum, product) => sum + Number(product.wallet?.gold ?? 0), 0)
|
|
}
|
|
|
|
export function getMainWalletLine(wallets?: UserWalletLine[] | null): UserWalletLine | undefined {
|
|
return wallets?.find((line) => line.product_id == null)
|
|
}
|
|
|
|
export function getMainWalletGold(wallets?: UserWalletLine[] | null): number {
|
|
return Number(getMainWalletLine(wallets)?.gold ?? 0)
|
|
}
|
|
|
|
export function getMainWalletCash(wallets?: UserWalletLine[] | null): number {
|
|
return Number(getMainWalletLine(wallets)?.cash ?? 0)
|
|
}
|
|
|
|
export function sumWalletsGold(
|
|
wallets?: UserWalletLine[] | null,
|
|
metalId?: number | null
|
|
): number {
|
|
if (!wallets?.length) {
|
|
return 0
|
|
}
|
|
|
|
return wallets.reduce((sum, line) => {
|
|
const weight = Number(line.gold ?? 0)
|
|
if (metalId == null) {
|
|
return sum + weight
|
|
}
|
|
|
|
if (line.product_id == null) {
|
|
return metalId === METAL_GOLD ? sum + weight : sum
|
|
}
|
|
|
|
return Number(line.product?.metal_id) === metalId ? sum + weight : sum
|
|
}, 0)
|
|
}
|
|
|
|
export function sumProductWalletsGold(
|
|
wallets?: UserWalletLine[] | null,
|
|
metalId?: number | null
|
|
): number {
|
|
return (wallets ?? [])
|
|
.filter((line) => line.product_id != null)
|
|
.reduce((sum, line) => {
|
|
const weight = Number(line.gold ?? 0)
|
|
if (metalId == null) {
|
|
return sum + weight
|
|
}
|
|
|
|
return Number(line.product?.metal_id) === metalId ? sum + weight : sum
|
|
}, 0)
|
|
}
|
|
|
|
export function sumInventoryMetalWeight(products?: InventoryProduct[] | null): number {
|
|
return (products ?? [])
|
|
.filter((product) => product.title !== 'آبشده نقدی')
|
|
.reduce((sum, product) => sum + Number(product.wallet?.gold ?? 0), 0)
|
|
}
|
|
|
|
export function getTotalMetalWeight(
|
|
walletInfo?: Record<string, unknown> | null,
|
|
wallets?: UserWalletLine[] | null,
|
|
inventoryProducts?: InventoryProduct[] | null
|
|
): number {
|
|
const fromInventory = sumInventoryMetalWeight(inventoryProducts)
|
|
if (fromInventory > 0) {
|
|
return fromInventory
|
|
}
|
|
|
|
const fromProductWallets = sumProductWalletsGold(wallets)
|
|
if (fromProductWallets > 0) {
|
|
return fromProductWallets
|
|
}
|
|
|
|
if (wallets?.length) {
|
|
return getMainWalletGold(wallets)
|
|
}
|
|
|
|
return Number(walletInfo?.treasure ?? walletInfo?.gold_sum ?? walletInfo?.count_gold ?? 0)
|
|
}
|
|
|
|
/** موجودی ریالی کیف اصلی — با main_wallet_products فیلد cash ممکن است کیف محصول باشد */
|
|
export function getRialCashAmount(
|
|
walletInfo?: Record<string, unknown> | null,
|
|
wallets?: UserWalletLine[] | null
|
|
): number {
|
|
const aggregated = walletInfo?.count_cash_wallet ?? walletInfo?.count_cash
|
|
if (aggregated != null && aggregated !== '') {
|
|
const parsed = Number(aggregated)
|
|
if (!Number.isNaN(parsed)) {
|
|
return parsed
|
|
}
|
|
}
|
|
|
|
const mainCash = getMainWalletCash(wallets)
|
|
if (mainCash > 0) {
|
|
return mainCash
|
|
}
|
|
|
|
return Number(walletInfo?.cash ?? 0)
|
|
}
|
|
|
|
export function getCashWalletBalance(
|
|
walletInfo?: Record<string, unknown> | null,
|
|
wallets?: UserWalletLine[] | null
|
|
): number {
|
|
return getRialCashAmount(walletInfo, wallets)
|
|
}
|
|
|
|
export function getTotalRialEquivalent(walletInfo?: Record<string, unknown> | null): number {
|
|
return Number(walletInfo?.count_cash_total ?? 0)
|
|
}
|
|
|
|
export function getMetalAssetAmount(
|
|
walletInfo: Record<string, unknown> | null | undefined,
|
|
metalId: number,
|
|
inventoryProducts?: InventoryProduct[] | null
|
|
): number {
|
|
if (inventoryProducts?.length) {
|
|
const fromProducts = sumProductWalletByMetal(inventoryProducts, metalId)
|
|
if (fromProducts > 0 || inventoryProducts.some((product) => Number(product.metal_id) === metalId)) {
|
|
return fromProducts
|
|
}
|
|
}
|
|
|
|
if (!walletInfo) {
|
|
return 0
|
|
}
|
|
|
|
switch (metalId) {
|
|
case METAL_GOLD:
|
|
return Number(walletInfo.count_gold_wallets ?? walletInfo.count_gold ?? 0)
|
|
case METAL_SILVER:
|
|
return Number(walletInfo.count_silver ?? 0)
|
|
case METAL_COPPER:
|
|
return Number(walletInfo.count_copper ?? 0)
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
export function getMetalAssetAmountForDisplay(
|
|
walletInfo: Record<string, unknown> | null | undefined,
|
|
metalId: number,
|
|
catalogMetalIds: number[],
|
|
inventoryProducts?: InventoryProduct[] | null,
|
|
wallets?: UserWalletLine[] | null
|
|
): number {
|
|
if (isSingleMetalCatalog(catalogMetalIds)) {
|
|
return getTotalMetalWeight(walletInfo, wallets, inventoryProducts)
|
|
}
|
|
|
|
const productWeight = sumProductWalletByMetal(inventoryProducts, metalId)
|
|
const mainWalletWeight = wallets?.length
|
|
? getMainWalletGold(wallets)
|
|
: Number(walletInfo?.count_gold_wallet ?? 0)
|
|
|
|
if (catalogHasMeltedProducts(inventoryProducts as Product[] | null | undefined) && metalId === catalogMetalIds[0]) {
|
|
return productWeight + mainWalletWeight
|
|
}
|
|
|
|
if (wallets?.length) {
|
|
const walletWeight = sumWalletsGold(wallets, metalId)
|
|
if (walletWeight > 0) {
|
|
return walletWeight
|
|
}
|
|
}
|
|
|
|
return productWeight || getMetalAssetAmount(walletInfo, metalId, inventoryProducts)
|
|
}
|