676 lines
22 KiB
PHP
676 lines
22 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Http\Controllers\Controller;
|
|
use App\Models\Price;
|
|
use App\Models\Product;
|
|
use Illuminate\Support\Collection;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Rooyesh\Wallet\models\Wallet;
|
|
|
|
/**
|
|
* محاسبهٔ موجودی کیف — منبع واحد برای ادمین و APIها.
|
|
*
|
|
* کیف اصلی: fund_id=null و product_id=null
|
|
* main_wallet_products: طلای این محصولات روی کیف اصلی است؛ کیف legacy محصول نادیده گرفته می‌شود.
|
|
*/
|
|
class WalletBalanceService
|
|
{
|
|
public function __construct(
|
|
private ConfigService $configService,
|
|
private BalanceReportService $balanceReportService
|
|
) {
|
|
}
|
|
|
|
public function mainWalletProductIds(): array
|
|
{
|
|
return $this->configService->mainWalletProductIds();
|
|
}
|
|
|
|
/** @param Collection|array<int, mixed>|null $wallets */
|
|
public function mainWalletCash(Collection|array|null $wallets, ?int $ownerType = null): float
|
|
{
|
|
$line = $this->mainWalletLine($wallets, $ownerType);
|
|
|
|
return (float) ($this->lineValue($line, 'cash') ?? 0);
|
|
}
|
|
|
|
/** @param Collection|array<int, mixed>|null $wallets */
|
|
public function mainWalletGold(Collection|array|null $wallets, ?int $ownerType = null): float
|
|
{
|
|
$line = $this->mainWalletLine($wallets, $ownerType);
|
|
|
|
return (float) ($this->lineValue($line, 'gold') ?? 0);
|
|
}
|
|
|
|
/**
|
|
* موجودی مؤثر کیف اصلی برای نمایش آبشده =
|
|
* gold کیف اصلی + gold کیف‌های legacy محصولات main_wallet_products.
|
|
*
|
|
* @param int|null $ownerType اگر داده شود فقط همان owner_type جمع می‌شود (هم‌تراز wallet/me).
|
|
*/
|
|
public function effectiveMainWalletGold(int $ownerId, ?int $ownerType = null): float
|
|
{
|
|
$mainQuery = Wallet::query()
|
|
->where('owner', $ownerId)
|
|
->whereNull('fund_id')
|
|
->whereNull('product_id');
|
|
if ($ownerType !== null) {
|
|
$mainQuery->where('owner_type', $ownerType);
|
|
}
|
|
$mainGold = (float) $mainQuery->sum('gold');
|
|
|
|
$productIds = $this->mainWalletProductIds();
|
|
if ($productIds === []) {
|
|
return round($mainGold, 3);
|
|
}
|
|
|
|
$orphanedQuery = Wallet::query()
|
|
->where('owner', $ownerId)
|
|
->whereNull('fund_id')
|
|
->whereIn('product_id', $productIds);
|
|
if ($ownerType !== null) {
|
|
$orphanedQuery->where('owner_type', $ownerType);
|
|
}
|
|
$orphanedGold = (float) $orphanedQuery->sum('gold');
|
|
|
|
return round($mainGold + $orphanedGold, 3);
|
|
}
|
|
|
|
/**
|
|
* موجودی ریالی مؤثر کیف اصلی =
|
|
* cash کیف اصلی + cash کیف‌های legacy محصولات main_wallet_products.
|
|
*/
|
|
public function effectiveMainWalletCash(int $ownerId, ?int $ownerType = null): float
|
|
{
|
|
$mainQuery = Wallet::query()
|
|
->where('owner', $ownerId)
|
|
->whereNull('fund_id')
|
|
->whereNull('product_id');
|
|
if ($ownerType !== null) {
|
|
$mainQuery->where('owner_type', $ownerType);
|
|
}
|
|
$mainCash = (float) $mainQuery->sum('cash');
|
|
|
|
$productIds = $this->mainWalletProductIds();
|
|
if ($productIds === []) {
|
|
return $mainCash;
|
|
}
|
|
|
|
$orphanedQuery = Wallet::query()
|
|
->where('owner', $ownerId)
|
|
->whereNull('fund_id')
|
|
->whereIn('product_id', $productIds);
|
|
if ($ownerType !== null) {
|
|
$orphanedQuery->where('owner_type', $ownerType);
|
|
}
|
|
$orphanedCash = (float) $orphanedQuery->sum('cash');
|
|
|
|
return $mainCash + $orphanedCash;
|
|
}
|
|
|
|
/**
|
|
* انتقال موجودی کیف legacy یک محصول متصل به کیف اصلی — مثل goldali (idempotent).
|
|
* خرید/فروش بعد از این فقط روی یک کیف (اصلی) کسر/واریز می‌شود.
|
|
*/
|
|
public function consolidateOrphanedForOwner(int $ownerId, int $ownerType, int $productId): bool
|
|
{
|
|
if (!$this->configService->isMainWalletProduct($productId)) {
|
|
return false;
|
|
}
|
|
|
|
$productWallet = Wallet::query()
|
|
->where('owner', $ownerId)
|
|
->where('owner_type', $ownerType)
|
|
->where('product_id', $productId)
|
|
->whereNull('fund_id')
|
|
->first();
|
|
|
|
if (!$productWallet) {
|
|
return false;
|
|
}
|
|
|
|
$goldToMove = (float) $productWallet->gold;
|
|
$cashToMove = (float) $productWallet->cash;
|
|
|
|
if (abs($goldToMove) < 1e-12 && abs($cashToMove) < 1e-12) {
|
|
return false;
|
|
}
|
|
|
|
DB::transaction(function () use ($ownerId, $ownerType, $productWallet, $goldToMove, $cashToMove) {
|
|
$mainWallet = Wallet::query()->firstOrCreate(
|
|
[
|
|
'owner' => $ownerId,
|
|
'owner_type' => $ownerType,
|
|
'fund_id' => null,
|
|
'product_id' => null,
|
|
],
|
|
['gold' => 0, 'cash' => 0]
|
|
);
|
|
|
|
$mainWallet->gold = (float) $mainWallet->gold + $goldToMove;
|
|
$mainWallet->cash = (float) $mainWallet->cash + $cashToMove;
|
|
$mainWallet->save();
|
|
|
|
$productWallet->gold = 0;
|
|
$productWallet->cash = 0;
|
|
$productWallet->save();
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
/** ادغام همهٔ کیف‌های legacy محصولات main_wallet_products برای یک کاربر */
|
|
public function consolidateAllMainWalletProductsForOwner(int $ownerId, int $ownerType): void
|
|
{
|
|
foreach ($this->mainWalletProductIds() as $productId) {
|
|
$this->consolidateOrphanedForOwner($ownerId, $ownerType, (int) $productId);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* طلای داخل قلک‌های یک محصول (یا همهٔ محصولات main_wallet اگر $productId=null و فقط main).
|
|
*/
|
|
public function fundGoldForProduct(int $ownerId, ?int $productId, ?int $ownerType = null): float
|
|
{
|
|
$query = Wallet::query()
|
|
->where('owner', $ownerId)
|
|
->whereNotNull('fund_id');
|
|
if ($ownerType !== null) {
|
|
$query->where('owner_type', $ownerType);
|
|
}
|
|
if ($productId === null) {
|
|
$query->whereNull('product_id');
|
|
} else {
|
|
$query->where('product_id', $productId);
|
|
}
|
|
|
|
return round((float) $query->sum('gold'), 3);
|
|
}
|
|
|
|
/**
|
|
* جمع طلای قلک‌های محصولات متصل به کیف اصلی (+ قلک‌های legacy بدون product_id).
|
|
*/
|
|
public function fundGoldForMainWalletProducts(int $ownerId, ?int $ownerType = null): float
|
|
{
|
|
$productIds = $this->mainWalletProductIds();
|
|
$query = Wallet::query()
|
|
->where('owner', $ownerId)
|
|
->whereNotNull('fund_id');
|
|
if ($ownerType !== null) {
|
|
$query->where('owner_type', $ownerType);
|
|
}
|
|
if ($productIds === []) {
|
|
$query->whereNull('product_id');
|
|
} else {
|
|
$query->where(function ($q) use ($productIds) {
|
|
$q->whereIn('product_id', $productIds)->orWhereNull('product_id');
|
|
});
|
|
}
|
|
|
|
return round((float) $query->sum('gold'), 3);
|
|
}
|
|
|
|
/**
|
|
* موجودی قابل‌مقایسه با حسابداری برای طلای کیف اصلی =
|
|
* آزاد (effectiveMain) + قلک‌های همان محصولات.
|
|
* برای معامله استفاده نشود — فقط sync/مانده.
|
|
*/
|
|
public function accountingVisibleMainWalletGold(int $ownerId, ?int $ownerType = null): float
|
|
{
|
|
return round(
|
|
$this->effectiveMainWalletGold($ownerId, $ownerType)
|
|
+ $this->fundGoldForMainWalletProducts($ownerId, $ownerType),
|
|
3
|
|
);
|
|
}
|
|
|
|
/**
|
|
* موجودی آزاد یک محصول (بدون قلک) — برای معامله و واریز به قلک.
|
|
*/
|
|
public function freeProductGold(int $ownerId, int $productId, ?int $ownerType = null): float
|
|
{
|
|
if ($this->configService->isMainWalletProduct($productId)) {
|
|
return $this->effectiveMainWalletGold($ownerId, $ownerType);
|
|
}
|
|
|
|
$query = Wallet::query()
|
|
->where('owner', $ownerId)
|
|
->whereNull('fund_id')
|
|
->where('product_id', $productId);
|
|
if ($ownerType !== null) {
|
|
$query->where('owner_type', $ownerType);
|
|
}
|
|
|
|
return round((float) $query->sum('gold'), 3);
|
|
}
|
|
|
|
/**
|
|
* جمع نمایشی دارایی یک محصول = آزاد + قلک‌های همان محصول.
|
|
*/
|
|
public function totalProductGold(int $ownerId, int $productId, ?int $ownerType = null): float
|
|
{
|
|
return round(
|
|
$this->freeProductGold($ownerId, $productId, $ownerType)
|
|
+ $this->fundGoldForProduct($ownerId, $productId, $ownerType),
|
|
3
|
|
);
|
|
}
|
|
|
|
/**
|
|
* جمع طلای قابل‌نمایش: کیف اصلی + کیف محصولات + قلک‌ها.
|
|
* کیف‌های legacy محصولات main_wallet_products شمرده نمی‌شوند.
|
|
*
|
|
* @param Collection|array<int, mixed>|null $wallets
|
|
*/
|
|
public function totalGoldWeight(
|
|
Collection|array|null $wallets,
|
|
?array $mainWalletProductIds = null
|
|
): float {
|
|
$mainWalletProductIds ??= $this->mainWalletProductIds();
|
|
$sum = 0.0;
|
|
|
|
foreach ($this->walletLines($wallets) as $line) {
|
|
$fundId = $this->lineValue($line, 'fund_id');
|
|
$productId = (int) ($this->lineValue($line, 'product_id') ?? 0);
|
|
$gold = (float) ($this->lineValue($line, 'gold') ?? 0);
|
|
|
|
if (abs($gold) < 0.0000001) {
|
|
continue;
|
|
}
|
|
|
|
if ($fundId !== null) {
|
|
$sum += $gold;
|
|
continue;
|
|
}
|
|
|
|
if ($productId === 0) {
|
|
$sum += $gold;
|
|
continue;
|
|
}
|
|
|
|
if ($mainWalletProductIds !== [] && in_array($productId, $mainWalletProductIds, true)) {
|
|
continue;
|
|
}
|
|
|
|
$sum += $gold;
|
|
}
|
|
|
|
return $sum;
|
|
}
|
|
|
|
/** @return list<int> */
|
|
public function catalogMetalIds(): array
|
|
{
|
|
$ids = $this->balanceReportService->catalogMetalIds();
|
|
|
|
return $ids !== [] ? $ids : [1];
|
|
}
|
|
|
|
public function resolveMainWalletMetalId(): int
|
|
{
|
|
$mainWalletProductIds = $this->mainWalletProductIds();
|
|
if ($mainWalletProductIds !== []) {
|
|
$product = Product::query()
|
|
->whereIn('id', $mainWalletProductIds)
|
|
->orderBy('id')
|
|
->first();
|
|
|
|
if ($product && (int) ($product->metal_id ?? 0) > 0) {
|
|
return (int) $product->metal_id;
|
|
}
|
|
}
|
|
|
|
// در بورس مس، مس فلز اصلی پلتفرم است
|
|
$hasCopperProduct = Product::query()
|
|
->where('active', 1)
|
|
->where('metal_id', 3)
|
|
->exists();
|
|
if ($hasCopperProduct) {
|
|
return 3;
|
|
}
|
|
|
|
$metalIds = $this->catalogMetalIds();
|
|
if (in_array(3, $metalIds, true)) {
|
|
return 3;
|
|
}
|
|
|
|
return count($metalIds) === 1 ? (int) $metalIds[0] : 1;
|
|
}
|
|
|
|
/**
|
|
* فلز مرتبط با یک ردیف کیف در جدول ادمین.
|
|
*
|
|
* @param Collection|array<int, mixed>|null $wallets
|
|
*/
|
|
public function resolveWalletLineMetalId(mixed $line, ?int $mainWalletMetalId = null): int
|
|
{
|
|
$fundId = $this->lineValue($line, 'fund_id');
|
|
$productId = $this->lineValue($line, 'product_id');
|
|
|
|
if ($fundId !== null) {
|
|
return 1;
|
|
}
|
|
|
|
if ($productId !== null) {
|
|
$product = $this->lineProduct($line);
|
|
$metalId = (int) ($product?->metal_id ?? 0);
|
|
|
|
return $metalId > 0 ? $metalId : 1;
|
|
}
|
|
|
|
return $mainWalletMetalId ?? $this->resolveMainWalletMetalId();
|
|
}
|
|
|
|
/**
|
|
* @param list<int> $catalogMetalIds
|
|
* @return array<string, float>
|
|
*/
|
|
public function walletLineMetalGoldMap(
|
|
mixed $line,
|
|
array $catalogMetalIds,
|
|
?int $mainWalletMetalId = null
|
|
): array {
|
|
$map = [];
|
|
foreach ($catalogMetalIds as $metalId) {
|
|
$map[(string) $metalId] = 0.0;
|
|
}
|
|
|
|
$goldGrams = $this->walletLineGoldGrams($line);
|
|
if (abs($goldGrams) < 0.0000001) {
|
|
return $map;
|
|
}
|
|
|
|
$metalId = $this->resolveWalletLineMetalId($line, $mainWalletMetalId);
|
|
$map[(string) $metalId] = round(
|
|
$this->balanceReportService->gramsToMetalDisplay($goldGrams, $metalId),
|
|
3
|
|
);
|
|
|
|
return $map;
|
|
}
|
|
|
|
/**
|
|
* @param Collection|array<int, mixed> $walletLines
|
|
* @param list<int> $catalogMetalIds
|
|
* @return array<string, float> جمع به گرم
|
|
*/
|
|
public function sumWalletMetalGrams(Collection|array $walletLines, array $catalogMetalIds): array
|
|
{
|
|
$buckets = [];
|
|
foreach ($catalogMetalIds as $metalId) {
|
|
$buckets[(string) (int) $metalId] = 0.0;
|
|
}
|
|
|
|
$mainWalletMetalId = $this->resolveMainWalletMetalId();
|
|
foreach ($this->walletLines($walletLines) as $line) {
|
|
$goldGrams = $this->walletLineGoldGrams($line);
|
|
if (abs($goldGrams) < 0.0000001) {
|
|
continue;
|
|
}
|
|
|
|
$metalId = (string) $this->resolveWalletLineMetalId($line, $mainWalletMetalId);
|
|
$buckets[$metalId] = ($buckets[$metalId] ?? 0.0) + $goldGrams;
|
|
}
|
|
|
|
return $buckets;
|
|
}
|
|
|
|
/**
|
|
* @param Collection|array<int, mixed> $walletLines
|
|
* @param list<int> $catalogMetalIds
|
|
* @return list<array{metal_id: int, label: string, gold: float, display_unit: string, goldToCash: float}>
|
|
*/
|
|
public function buildWalletMetalSums(Collection|array $walletLines, array $catalogMetalIds): array
|
|
{
|
|
$gramBuckets = $this->sumWalletMetalGrams($walletLines, $catalogMetalIds);
|
|
|
|
$items = [];
|
|
foreach ($catalogMetalIds as $metalId) {
|
|
$metalId = (int) $metalId;
|
|
$goldGrams = (float) ($gramBuckets[(string) $metalId] ?? 0.0);
|
|
$displayGold = round($this->balanceReportService->gramsToMetalDisplay($goldGrams, $metalId), 3);
|
|
$price = $this->livePricePerGram($metalId);
|
|
$items[] = [
|
|
'metal_id' => $metalId,
|
|
'label' => $this->balanceReportService->metalLabel($metalId),
|
|
'gold' => $displayGold,
|
|
'display_unit' => $this->balanceReportService->metalDisplayUnit($metalId),
|
|
'goldToCash' => round($goldGrams * $price, 2),
|
|
];
|
|
}
|
|
|
|
return $items;
|
|
}
|
|
|
|
/**
|
|
* @param Collection|array<int, mixed> $walletLines
|
|
* @param list<int> $catalogMetalIds
|
|
* @return array<string, float> مقادیر نمایشی
|
|
*/
|
|
public function buildCustomerWalletMetalDisplayMap(Collection|array $walletLines, array $catalogMetalIds): array
|
|
{
|
|
$gramBuckets = $this->sumWalletMetalGrams($walletLines, $catalogMetalIds);
|
|
$map = [];
|
|
|
|
foreach ($catalogMetalIds as $metalId) {
|
|
$metalId = (int) $metalId;
|
|
$goldGrams = (float) ($gramBuckets[(string) $metalId] ?? 0.0);
|
|
$map[(string) $metalId] = round(
|
|
$this->balanceReportService->gramsToMetalDisplay($goldGrams, $metalId),
|
|
3
|
|
);
|
|
}
|
|
|
|
return $map;
|
|
}
|
|
|
|
/**
|
|
* @param list<int> $catalogMetalIds
|
|
*/
|
|
public function enrichWalletTableRow(mixed &$row, array $catalogMetalIds, int $mainWalletMetalId): void
|
|
{
|
|
$metalMap = $this->walletLineMetalGoldMap($row, $catalogMetalIds, $mainWalletMetalId);
|
|
$meta = $this->buildWalletTableRowMeta($row, $mainWalletMetalId);
|
|
|
|
if (is_array($row)) {
|
|
$row['metal_gold'] = $metalMap;
|
|
foreach ($catalogMetalIds as $metalId) {
|
|
$row['metal_gold_' . $metalId] = $metalMap[(string) $metalId] ?? 0.0;
|
|
}
|
|
foreach ($meta as $key => $value) {
|
|
$row[$key] = $value;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (is_object($row)) {
|
|
$row->metal_gold = $metalMap;
|
|
foreach ($catalogMetalIds as $metalId) {
|
|
$row->{'metal_gold_' . $metalId} = $metalMap[(string) $metalId] ?? 0.0;
|
|
}
|
|
foreach ($meta as $key => $value) {
|
|
$row->{$key} = $value;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return array<string, mixed>
|
|
*/
|
|
private function buildWalletTableRowMeta(mixed $row, int $mainWalletMetalId): array
|
|
{
|
|
$fundId = $this->lineValue($row, 'fund_id');
|
|
$productId = $this->lineValue($row, 'product_id');
|
|
$product = $this->lineProduct($row);
|
|
$fund = $this->lineFund($row);
|
|
$cash = (float) ($this->lineValue($row, 'cash') ?? 0);
|
|
|
|
if ($fundId !== null) {
|
|
$kind = 'fund';
|
|
$kindLabel = 'قلک (صندوق)';
|
|
$fundTitle = trim((string) ($fund?->title ?? ''));
|
|
$subject = $fundTitle !== '' ? "قلک «{$fundTitle}»" : 'قلک بدون عنوان';
|
|
} elseif ($productId === null) {
|
|
$kind = 'main';
|
|
$kindLabel = 'کیف اصلی';
|
|
$subject = 'کیف اصلی — ریال و طلای آبشده';
|
|
} else {
|
|
$kind = 'product';
|
|
$kindLabel = 'کیف محصول';
|
|
$title = trim((string) ($product?->title ?? ''));
|
|
$subject = $title !== '' ? "محصول «{$title}»" : "محصول کد {$productId}";
|
|
}
|
|
|
|
$metalId = $this->resolveWalletLineMetalId($row, $mainWalletMetalId);
|
|
$goldGrams = $this->walletLineGoldGrams($row);
|
|
$goldToCash = $goldGrams > 0 ? (int) round($goldGrams * $this->livePricePerGram($metalId)) : 0;
|
|
|
|
return [
|
|
'wallet_kind' => $kind,
|
|
'wallet_kind_label' => $kindLabel,
|
|
'wallet_subject' => $subject,
|
|
'product_title' => $product?->title ?? null,
|
|
'product_group_type' => $product?->group_type ?? null,
|
|
'product_unit' => $product?->unit ?? null,
|
|
'product_amount' => $product?->amount ?? null,
|
|
'fund_title' => $fund?->title ?? null,
|
|
'wallet_metal_id' => $metalId,
|
|
'wallet_metal_label' => $this->balanceReportService->metalLabel($metalId),
|
|
'gold_to_cash' => $goldToCash,
|
|
'gold_grams' => round($goldGrams, 3),
|
|
'total_rial_value' => (int) round($cash + $goldToCash),
|
|
];
|
|
}
|
|
|
|
private function livePricePerGram(int $metalId): float
|
|
{
|
|
if ($metalId === 1) {
|
|
$live = (int) app(ProductDisplayPriceService::class)->resolveAppBasePrice();
|
|
if ($live > 0) {
|
|
return (float) $live;
|
|
}
|
|
|
|
return (float) (Price::latest('id')->value('price') ?? 0);
|
|
}
|
|
|
|
$product = Product::query()
|
|
->where('active', 1)
|
|
->where('metal_id', $metalId)
|
|
->where('price', '>', 0)
|
|
->orderBy('id')
|
|
->first();
|
|
|
|
if (!$product) {
|
|
return 0.0;
|
|
}
|
|
|
|
$unitPrice = (float) $product->price + (float) ($product->price_profit ?? 0);
|
|
$amount = (float) ($product->amount ?? 1);
|
|
|
|
return $amount > 0 ? $unitPrice * $amount : $unitPrice;
|
|
}
|
|
|
|
private function lineProduct(mixed $line): ?object
|
|
{
|
|
if (is_object($line) && isset($line->product) && $line->product) {
|
|
return $line->product;
|
|
}
|
|
|
|
if (is_array($line) && isset($line['product']) && $line['product']) {
|
|
$product = $line['product'];
|
|
|
|
return is_object($product) ? $product : (object) $product;
|
|
}
|
|
|
|
$productId = (int) ($this->lineValue($line, 'product_id') ?? 0);
|
|
if ($productId > 0) {
|
|
return Product::withTrashed()
|
|
->select(['id', 'title', 'metal_id', 'unit', 'amount', 'group_type', 'trade_by_quantity', 'direct_price'])
|
|
->find($productId);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function lineFund(mixed $line): ?object
|
|
{
|
|
if (is_object($line) && isset($line->fund)) {
|
|
return $line->fund;
|
|
}
|
|
|
|
if (is_array($line) && isset($line['fund'])) {
|
|
$fund = $line['fund'];
|
|
|
|
return is_object($fund) ? $fund : (object) $fund;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function walletLineGoldGrams(mixed $line): float
|
|
{
|
|
$gold = (float) ($this->lineValue($line, 'gold') ?? 0);
|
|
if (abs($gold) < 0.0000001) {
|
|
return 0.0;
|
|
}
|
|
|
|
$product = $this->lineProduct($line);
|
|
if ($product !== null) {
|
|
return Controller::productLineWeightToGrams($product, $gold);
|
|
}
|
|
|
|
return Controller::weightToGrams($gold);
|
|
}
|
|
|
|
/** @param Collection|array<int, mixed>|null $wallets */
|
|
private function mainWalletLine(Collection|array|null $wallets, ?int $ownerType = null): mixed
|
|
{
|
|
foreach ($this->walletLines($wallets) as $line) {
|
|
if ($this->lineValue($line, 'fund_id') !== null || $this->lineValue($line, 'product_id') !== null) {
|
|
continue;
|
|
}
|
|
|
|
if ($ownerType !== null) {
|
|
$lineOwnerType = $this->lineValue($line, 'owner_type');
|
|
if ($lineOwnerType !== null && (int) $lineOwnerType !== $ownerType) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return $line;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/** @param Collection|array<int, mixed>|null $wallets */
|
|
private function walletLines(Collection|array|null $wallets): array
|
|
{
|
|
if ($wallets === null) {
|
|
return [];
|
|
}
|
|
|
|
if ($wallets instanceof Collection) {
|
|
return $wallets->all();
|
|
}
|
|
|
|
return is_array($wallets) ? $wallets : [];
|
|
}
|
|
|
|
private function lineValue(mixed $line, string $key): mixed
|
|
{
|
|
if (is_array($line)) {
|
|
return $line[$key] ?? null;
|
|
}
|
|
|
|
if (is_object($line)) {
|
|
return $line->{$key} ?? null;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|