catalogsettings.php

См. документацию.

<?php
 
namespace Bitrix\Catalog\Config;
 
use Bitrix\Catalog\Access\AccessController;
use Bitrix\Catalog\Access\ActionDictionary;
use Bitrix\Catalog\CatalogIblockTable;
use Bitrix\Catalog\Config\Options\CheckRightsOnDecreaseStoreAmount;
use Bitrix\Catalog\Product\Store\CostPriceCalculator;
use Bitrix\Catalog\Store\EnableWizard\ConditionsChecker;
use Bitrix\Catalog\Store\EnableWizard\OnecAppManager;
use Bitrix\Catalog\Store\EnableWizard\TariffChecker;
use Bitrix\Catalog\StoreBatchTable;
use Bitrix\Catalog\StoreProductTable;
use Bitrix\Catalog\v2\IoC\ServiceContainer;
use Bitrix\Catalog\VatTable;
use Bitrix\Crm\Integration\Sale\Reservation;
use Bitrix\Intranet\Settings\AbstractSettings;
use Bitrix\Intranet\Settings\SettingsInterface;
use Bitrix\Main\Application;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Context;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Result;
use Bitrix\Main\Update\Stepper;
use Bitrix\Catalog\Store\EnableWizard\Manager;
 
Loader::includeModule('intranet');
 
final class CatalogSettings extends AbstractSettings
{
    private const OPTION_DEFAULT_SUBSCRIBE = 'default_subscribe';
    private const OPTION_DEFAULT_PRODUCT_VAT_INCLUDED = 'default_product_vat_included';
    private const OPTION_DEFAULT_CAN_BUY_ZERO = 'default_can_buy_zero';
    private const OPTION_DEFAULT_QUANTITY_TRACE = 'default_quantity_trace';
    private const OPTION_PRODUCT_CARD_SLIDER_ENABLED = 'product_card_slider_enabled';
 
    private const PRODUCT_SLIDER_HELP_LINK_EU = 'https://training.bitrix24.com/support/training/course/index.php?COURSE_ID=178&LESSON_ID=25692';
    private const PRODUCT_SLIDER_HELP_LINK_RU = 'https://dev.1c-bitrix.ru/learning/course/index.php?COURSE_ID=48&LESSON_ID=25488';
 
    public function save(): Result
    {
        $result = new Result();
 
        if (Loader::includeModule('crm'))
        {
            if (is_array($this->data['reservationSettings']))
            {
                if (Manager::isOnecMode())
                {
                    foreach ($this->data['reservationSettings'] as $entityCode => $reservationSettingsValue)
                    {
                        if (isset($reservationSettingsValue['autoWriteOffOnFinalize']))
                        {
                            Reservation\Config\EntityFactory::make($entityCode)
                                ->setValue(
                                    'autoWriteOffOnFinalize',
                                    $reservationSettingsValue['autoWriteOffOnFinalize'],
                                )
                                ->save()
                            ;
                        }
                    }
                }
                else
                {
                    foreach ($this->data['reservationSettings'] as $entityCode => $reservationSettingsValue)
                    {
                        Reservation\Config\EntityFactory::make($entityCode)
                            ->setValues($reservationSettingsValue)
                            ->save()
                        ;
                    }
                }
            }
        }
 
        if (isset($this->data['checkRightsOnDecreaseStoreAmount']))
        {
            if ($this->data['checkRightsOnDecreaseStoreAmount'] === 'Y')
            {
                CheckRightsOnDecreaseStoreAmount::set(
                    CheckRightsOnDecreaseStoreAmount::ENABLED_VALUE
                );
            }
            else
            {
                CheckRightsOnDecreaseStoreAmount::set(
                    CheckRightsOnDecreaseStoreAmount::DISABLED_VALUE
                );
            }
        }
 
        if (
            !empty($this->data['costPriceCalculationMethod'])
            && Feature::isStoreBatchEnabled()
            && !State::isProductBatchMethodSelected()
        )
        {
            CostPriceCalculator::setMethod($this->data['costPriceCalculationMethod']);
            if (!StoreBatchTable::getRow(['select' => ['ID']]))
            {
                Stepper::bindClass(
                    '\Bitrix\Catalog\Update\ProductBatchConverter',
                    'catalog',
                    0
                );
            }
        }
 
        $catalogOptionSettings = [
            'defaultQuantityTrace' => self::OPTION_DEFAULT_QUANTITY_TRACE,
            'defaultCanBuyZero' => self::OPTION_DEFAULT_CAN_BUY_ZERO,
            'defaultSubscribe' => self::OPTION_DEFAULT_SUBSCRIBE,
            'defaultProductVatIncluded' => self::OPTION_DEFAULT_PRODUCT_VAT_INCLUDED,
        ];
 
        if ($this->canEnableProductCardSlider())
        {
            $catalogOptionSettings['productCardSliderEnabled'] = self::OPTION_PRODUCT_CARD_SLIDER_ENABLED;
        }
 
        if (isset($this->data['defaultProductVatId']))
        {
            $this->updateDefaultVat((int)$this->data['defaultProductVatId']);
        }
 
        foreach ($catalogOptionSettings as $key => $optionName)
        {
            if (!isset($this->data[$key]))
            {
                continue;
            }
 
            Option::set('catalog', $optionName, $this->data[$key]);
        }
 
        return $result;
    }
 
    public function get(): SettingsInterface
    {
        $data = [];
 
        // reservation options
        if (Loader::includeModule('crm'))
        {
            $data['reservationEntities'] = $this->getReservationEntities();
        }
 
        $accessController = AccessController::getCurrent();
 
        $data = array_merge($data, [
            'costPriceCalculationMethod' => $this->getCostPriceCalculationMethodSetting(),
            // product options
            'checkRightsOnDecreaseStoreAmount' => CheckRightsOnDecreaseStoreAmount::isEnabled() ? 'Y' : 'N',
            'defaultQuantityTrace' => Option::get('catalog', self::OPTION_DEFAULT_QUANTITY_TRACE, 'N'),
            'defaultSubscribe' => Option::get('catalog', self::OPTION_DEFAULT_SUBSCRIBE, 'Y'),
            'defaultProductVatIncluded' => Option::get('catalog', self::OPTION_DEFAULT_PRODUCT_VAT_INCLUDED, 'N'),
            'defaultCanBuyZero' => Option::get('catalog', self::OPTION_DEFAULT_CAN_BUY_ZERO, 'N'),
            'productCardSliderEnabled' => Option::get('catalog', self::OPTION_PRODUCT_CARD_SLIDER_ENABLED, self::isBitrix24() ? 'Y' : 'N'),
            'vats' => $this->getVats(),
            'defaultProductVatId' => $this->getDefaultProductVatId() ?? 0,
            // inventory management options
            'isEnabledInventoryManagement' => State::isEnabledInventoryManagement(),
            'storeControlMode' => Manager::getCurrentMode(),
            'storeControlAvailableModes' => Manager::getAvailableModes(),
            'hasConductedDocumentsOrQuantities' => ConditionsChecker::hasConductedDocumentsOrQuantities(),
            'onecStatusUrl' => OnecAppManager::getStatusUrl(),
            // access and misc. options
            'canEnableProductCardSlider' => $this->canEnableProductCardSlider(),
            'hasAccessToReservationSettings' => $accessController->check(ActionDictionary::ACTION_RESERVED_SETTINGS_ACCESS),
            'hasAccessToCatalogSettings' => $accessController->check(ActionDictionary::ACTION_CATALOG_SETTINGS_ACCESS),
            'isStoreBatchUsed' => Feature::isStoreBatchEnabled(),
            'isBitrix24' => self::isBitrix24() ? 'Y' : 'N',
            'isInventoryManagementRestricted' => !Feature::isInventoryManagementEnabled(),
            'is1cRestricted' => TariffChecker::isOnecInventoryManagementRestricted(),
            'hasAccessToChangeCanBuyZero' => $accessController->check(ActionDictionary::ACTION_SELL_NEGATIVE_COMMODITIES_SETTINGS_EDIT),
            'productsCount' => $this->getProductsCount(),
            'busProductCardHelpLink' => self::getBusProductCardHelpLink(),
            'configCatalogSource' => Context::getCurrent()->getRequest()->get('configCatalogSource'),
        ]);
 
        if (!State::isProductBatchMethodSelected())
        {
            $negativeBalanceItem = StoreProductTable::getList([
                'select' => ['ID'],
                'filter' => [
                    '<AMOUNT' => 0,
                ],
                'limit' => 1,
            ])
                ->fetch()
            ;
 
            $data['showNegativeStoreAmountPopup'] = !empty($negativeBalanceItem);
            if (!empty($negativeBalanceItem))
            {
                $productGridComponent = 'bitrix:catalog.report.store_stock.products.grid';
                $productGridPath = \CComponentEngine::makeComponentPath($productGridComponent);
 
                $data['storeBalancePopupLink'] = getLocalPath('components' . $productGridPath . '/slider.php');
            }
        }
 
        return new self($data);
    }

    private function getDefaultProductVatId(): ?int
    {
        $defaultProductCatalogId = \Bitrix\Crm\Product\Catalog::getDefaultId();
 
        if (!$defaultProductCatalogId)
        {
            return null;
        }
 
        $defaultProductCatalogInfo = ServiceContainer::getIblockInfo($defaultProductCatalogId);
 
        return $defaultProductCatalogInfo?->getVatId();
    }

    private function getVats(): array
    {
        $currentVat = (int)$this->getDefaultProductVatId();
        $vatList = [
            [
                'value' => 0,
                'name' => Loc::getMessage("CATALOG_SETTINGS_VAT_NOT_SELECTED"),
                'selected' => $currentVat === 0,
            ],
        ];
        $hints = [
            0 => Loc::getMessage('CATALOG_SETTINGS_VAT_HINT'),
        ];
 
        $iterator = VatTable::getList([
            'select' => [
                'ID',
                'NAME',
            ],
            'filter' => [
                '=ACTIVE' => 'Y',
            ],
            'order' => [
                'SORT' => 'ASC',
                'NAME' => 'ASC',
            ]
        ]);
 
        while ($row = $iterator->fetch())
        {
            $vatList[] = [
                'value' => $row['ID'],
                'name' => htmlspecialcharsbx($row['NAME']),
                'selected' => $currentVat === (int)$row['ID'],
            ];
 
            $hints[$row['ID']] = Loc::getMessage('CATALOG_SETTINGS_VAT_HINT');
        }
 
        unset($row, $iterator);
 
        return [
            'items' => $vatList,
            'hints' => $hints,
            'current' => $currentVat,
        ];
    }
 
    private function getReservationEntities(): array
    {
        $result = [];
 
        $reservationEntities = Reservation\Config\EntityFactory::makeAllKnown();
        foreach ($reservationEntities as $reservationEntity)
        {
            $result[] = [
                'code' => $reservationEntity::getCode(),
                'name' => $reservationEntity::getName(),
                'settings' => [
                    'scheme' => $reservationEntity::getScheme(),
                    'values' => $reservationEntity->getValues(),
                ],
            ];
        }
 
        return $result;
    }
 
    private function getCostPriceCalculationMethodSetting(): array
    {
        $currentMethod = CostPriceCalculator::getMethod();
        $methodList = CostPriceCalculator::getMethodList();
 
        return [
            'items' => [
                [
                    'value' => '',
                    'name' => Loc::getMessage('CATALOG_SETTINGS_CALCULATION_METHOD_NOT_SELECTED'),
                    'selected' => empty($currentMethod),
                    'disabled' => true,
                    'hidden' => true,
                ],
                [
                    'value' => CostPriceCalculator::METHOD_AVERAGE,
                    'name' => $methodList[CostPriceCalculator::METHOD_AVERAGE],
                    'selected' => $currentMethod === CostPriceCalculator::METHOD_AVERAGE,
                ],
                [
                    'value' => CostPriceCalculator::METHOD_FIFO,
                    'name' => $methodList[CostPriceCalculator::METHOD_FIFO],
                    'selected' => $currentMethod === CostPriceCalculator::METHOD_FIFO,
                ],
            ],
            'hints' => [
                CostPriceCalculator::METHOD_AVERAGE => Loc::getMessage('CATALOG_SETTINGS_CALCULATION_METHOD_AVERAGE_HINT'),
                CostPriceCalculator::METHOD_FIFO => Loc::getMessage('CATALOG_SETTINGS_CALCULATION_METHOD_FIFO_HINT'),
            ],
            'current' => CostPriceCalculator::getMethod(),
        ];
    }
 
    private function canEnableProductCardSlider(): bool
    {
        if (self::isBitrix24())
        {
            return Option::get('catalog', self::OPTION_PRODUCT_CARD_SLIDER_ENABLED) !== 'Y';
        }
 
        return true;
    }

    private function updateDefaultVat(int $defaultProductVatId): bool
    {
        try
        {
            $defaultProductCatalogId = \Bitrix\Crm\Product\Catalog::getDefaultId();
            $updateResult = CatalogIblockTable::update(
                $defaultProductCatalogId,
                [
                    'VAT_ID' => $defaultProductVatId,
                ]
            );
        } catch (\Exception)
        {
            return false;
        }
 
        if (!$updateResult->isSuccess())
        {
            return false;
        }
 
        return true;
    }
 
    private static function isBitrix24(): bool
    {
        static $isBitrix24Included;
 
        if (!isset($isBitrix24Included))
        {
            $isBitrix24Included = Loader::includeModule('bitrix24');
        }
 
        return $isBitrix24Included;
    }
 
    private function getProductsCount(): int
    {
        $result = 0;
 
        $catalogList = \CCatalogProductSettings::getCatalogList();
        foreach ($catalogList as $catalog)
        {
            $result += $catalog['COUNT'];
 
        }
 
        return $result;
    }
 
    private static function getBusProductCardHelpLink(): string
    {
        if (self::isBitrix24())
        {
            return '';
        }
 
        if (in_array(Application::getInstance()->getLicense()->getRegion(), ['ru', 'by', 'kz'], true))
        {
            return self::PRODUCT_SLIDER_HELP_LINK_RU;
        }
 
        return self::PRODUCT_SLIDER_HELP_LINK_EU;
    }
}