basketreservationhistoryservice.php

<?php
 
namespace Bitrix\Sale\Reservation;
 
use Bitrix\Main\Application;
use Bitrix\Main\DB\SqlExpression;
use Bitrix\Main\Loader;
use Bitrix\Main\ORM\Data\DeleteResult;
use Bitrix\Main\Result;
use Bitrix\Sale\Internals\BasketTable;
use Bitrix\Main\Type\DateTime;
use Bitrix\Sale\Internals\StoreProductTable;
use Bitrix\Sale\Reservation\Internals\BasketReservationHistoryTable;
use Bitrix\Sale\Reservation\Internals\BasketReservationTable;
use Exception;
 
class BasketReservationHistoryService
{
    public function __construct()
    {
        Loader::includeModule('catalog');
    }
 
    private function roundQuantity(float $quantity): float
    {
        $precision = 6;
        return round($quantity, $precision, PHP_ROUND_HALF_DOWN);
    }
 
    public function getQuantityByReservation(int $reservationId): float
    {
        $total = 0.0;
 
        $rows = BasketReservationHistoryTable::getList([
            'select' => [
                'QUANTITY',
            ],
            'filter' => [
                '=RESERVATION_ID' => $reservationId,
            ],
        ]);
        foreach ($rows as $row)
        {
            $total += (float)$row['QUANTITY'];
        }
 
        return $total;
    }
 
    public function getAvailableCountForBasketItems(array $basketItemFilter): array
    {
        $basketItems =
            BasketTable::getList([
                'select' => [
                    'ID',
                    'PRODUCT_ID',
                ],
                'filter' => $basketItemFilter,
            ])
            ->fetchAll()
        ;
 
        $basket2productIds = array_column($basketItems, 'PRODUCT_ID', 'ID');
        if (empty($basket2productIds))
        {
            return [];
        }
 
        $calculator = new AvailableQuantityCalculator();
 
        $rows = StoreProductTable::getList([
            'select' => [
                'PRODUCT_ID',
                'STORE_ID',
                'AMOUNT',
            ],
            'filter' => [
                '=PRODUCT_ID' => $basket2productIds,
            ],
        ]);
        foreach ($rows as $row)
        {
            $calculator->setStoreQuantity($row['STORE_ID'], $row['PRODUCT_ID'], $row['AMOUNT']);
        }
 
        $reservationsRows = BasketReservationHistoryTable::getList([
            'select' => [
                'RESERVATION_ID',
                'QUANTITY',
                'STORE_ID' => 'RESERVATION.STORE_ID',
                'BASKET_ID' => 'RESERVATION.BASKET_ID',
                'PRODUCT_ID' => 'RESERVATION.BASKET.PRODUCT_ID',
            ],
            'filter' => [
                '!RESERVATION.STORE_ID' => null,
                '=RESERVATION.BASKET.PRODUCT_ID' => $basket2productIds,
            ],
            'order' => [
                'DATE_RESERVE' => 'ASC',
            ],
        ]);
 
        foreach ($reservationsRows as $row)
        {
            $calculator->addReservationHistory(
                $row['STORE_ID'],
                $row['PRODUCT_ID'],
                $row['BASKET_ID'],
                $row['QUANTITY']
            );
        }
 
        return $calculator->getQuantityForBatch($basket2productIds);
    }
 
    public function getAvailableCountForOrder(int $orderId): array
    {
        return $this->getAvailableCountForBasketItems([
            '=ORDER_ID' => $orderId,
        ]);
    }
 
    public function getAvailableCountForBasketItem(int $basketId, int $storeId): float
    {
        $basketItem = BasketTable::getRow([
            'select' => [
                'PRODUCT_ID',
            ],
            'filter' => [
                '=ID' => $basketId,
            ],
        ]);
        if (!$basketItem || !$basketItem['PRODUCT_ID'])
        {
            return 0.0;
        }
 
        $productId = (int)$basketItem['PRODUCT_ID'];
        $storeQuantityRow = StoreProductTable::getRow([
            'select' => [
                'AMOUNT',
            ],
            'filter' => [
                '=STORE_ID' => $storeId,
                '=PRODUCT_ID' => $productId,
            ],
        ]);
        if (!$storeQuantityRow)
        {
            return 0.0;
        }
 
        $calculator = new AvailableQuantityCalculator();
        $calculator->setStoreQuantity($storeId, $productId, $storeQuantityRow['AMOUNT']);
 
        $reservationsRows = BasketReservationHistoryTable::getList([
            'select' => [
                'RESERVATION_ID',
                'QUANTITY',
                'BASKET_ID' => 'RESERVATION.BASKET_ID',
            ],
            'filter' => [
                '=RESERVATION.STORE_ID' => $storeId,
                '=RESERVATION.BASKET.PRODUCT_ID' => $productId,
            ],
            'order' => [
                'DATE_RESERVE' => 'ASC',
            ],
        ]);
        foreach ($reservationsRows as $row)
        {
            $calculator->addReservationHistory(
                $storeId,
                $productId,
                $row['BASKET_ID'],
                $row['QUANTITY']
            );
        }
 
        return $calculator->getQuantityForItem($productId, $basketId, $storeId);
    }
 
    public function add(array $fields): Result
    {
        return BasketReservationHistoryTable::add($fields);
    }
 
    private function addQuantity(int $reservationId, float $quantity): Result
    {
        return $this->add([
            'RESERVATION_ID' => $reservationId,
            'DATE_RESERVE' => new DateTime(),
            'QUANTITY' => $quantity,
        ]);
    }
 
    public function addByReservation(int $reservationId): Result
    {
        $reservation = BasketReservationTable::getRowById($reservationId);
        if (!$reservation)
        {
            throw new Exception('Reservation not found');
        }
 
        return $this->addQuantity($reservationId, (float)$reservation['QUANTITY']);
    }
 
    public function update(int $id, array $fields): Result
    {
        return BasketReservationHistoryTable::update($id, $fields);
    }
 
    public function updateByReservation(int $reservationId): Result
    {
        $reservation = BasketReservationTable::getRowById($reservationId);
        if (!$reservation)
        {
            throw new Exception('Reservation not found');
        }
 
        $reservationQuantity = $this->roundQuantity($reservation['QUANTITY']);
        $historyQuantity = $this->roundQuantity($this->getQuantityByReservation($reservationId));
 
        if ($reservationQuantity !== $historyQuantity)
        {
            return $this->addQuantity($reservationId, $reservationQuantity - $historyQuantity);
        }
 
        return new Result();
    }
 
    public function delete(int $id): Result
    {
        return BasketReservationHistoryTable::delete($id);
    }
 
    public function deleteByReservation(int $reservationId): Result
    {
        $result = new DeleteResult();
 
        $rows = BasketReservationHistoryTable::getList([
            'select' => [
                'ID',
            ],
            'filter' => [
                '=RESERVATION_ID' => $reservationId,
            ],
        ]);
        foreach ($rows as $row)
        {
            $deleteResult = BasketReservationHistoryTable::delete($row['ID']);
            foreach ($deleteResult->getErrors() as $err)
            {
                $result->addError($err);
            }
        }
 
        return $result;
    }
}