productaction.php

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

<?php
 
namespace Bitrix\Catalog\Grid;
 
use Bitrix\Main;
use Bitrix\Main\Localization\Loc;
use Bitrix\Iblock;
use Bitrix\Catalog;
use Bitrix\Catalog\Access\ActionDictionary;
use Bitrix\Catalog\Access\AccessController;
use Bitrix\Crm;
use Bitrix\Main\ORM;
use Bitrix\Sale;
 
class ProductAction
{
    public const SET_FIELD = 'product_field';
    public const CHANGE_PRICE = 'change_price';
    public const CONVERT_PRODUCT_TO_SERVICE = 'convert_to_service';
    public const CONVERT_SERVICE_TO_PRODUCT = 'convert_to_product';
 
    public static function updateSectionList(int $iblockId, array $sections, array $fields): Main\Result
    {
        $result = new Main\Result();
 
        if ($iblockId <= 0)
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_IBLOCK_ID')
            ));
            return $result;
        }
 
        $catalog = \CCatalogSku::GetInfoByIBlock($iblockId);
        if (empty($catalog))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_CATALOG')
            ));
            return $result;
        }
 
        if (empty($fields))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_EMPTY_FIELDS')
            ));
            return $result;
        }
 
        $filter = [];
        $allowedTypes = static::getAllowedProductTypes($catalog, $fields);
        if (empty($allowedTypes))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_FIELDS')
            ));
            return $result;
        }
        $filter['=TYPE'] = $allowedTypes;
        unset($allowedTypes);
 
        $sectionElements = self::getSectionProducts($iblockId, $sections, $filter);
        if (empty($sectionElements))
        {
            return $result;
        }
 
        $sectionIdList = array_keys($sectionElements);
        $sectionNames = [];
        $iterator = Iblock\SectionTable::getList([
            'select' => [
                'ID',
                'NAME',
            ],
            'filter' => [
                '@ID' => $sectionIdList,
                '=IBLOCK_ID' => $iblockId,
            ],
            'order' => ['ID' => 'ASC'],
        ]);
        while ($row = $iterator->fetch())
        {
            $row['ID'] = (int)$row['ID'];
            $sectionNames[$row['ID']] = $row['NAME'];
        }
        unset($row, $iterator);
 
        foreach ($sectionIdList as $sectionId)
        {
            $elementResult = static::updateElementList(
                $iblockId,
                $sectionElements[$sectionId],
                $fields
            );
            if (!$elementResult->isSuccess())
            {
                $result->addError(new Main\Error(
                    Loc::getMessage(
                        'BX_CATALOG_PRODUCT_ACTION_ERR_SECTION_PRODUCTS_UPDATE',
                        ['#ID#' => $sectionId, '#NAME#' => $sectionNames[$sectionId]]
                    ),
                    $sectionId
                ));
            }
        }
        unset($sectionId);
        unset($sectionNames, $sectionIdList, $sectionElements);
 
        return $result;
    }
 
    public static function updateElementList(int $iblockId, array $elementIds, array $fields): Main\Result
    {
        $result = new Main\Result();
 
        if ($iblockId <= 0)
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_IBLOCK_ID')
            ));
            return $result;
        }
        Main\Type\Collection::normalizeArrayValuesByInt($elementIds, true);
        if (empty($elementIds))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_EMPTY_ELEMENTS')
            ));
            return $result;
        }
        if (empty($fields))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_EMPTY_FIELDS')
            ));
            return $result;
        }
        $catalog = \CCatalogSku::GetInfoByIBlock($iblockId);
        if (empty($catalog))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_CATALOG')
            ));
            return $result;
        }
 
        $allowedTypes = static::getAllowedProductTypes($catalog, $fields);
        if (empty($allowedTypes))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_FIELDS')
            ));
            return $result;
        }
 
        $productResult = self::getProductListByTypeForModify($elementIds, $allowedTypes);
        $data = $productResult->getData();
        $newProducts = $data['NEW_PRODUCT_IDS'] ?? [];
        $existProducts = $data['EXIST_PRODUCT_IDS'] ?? [];
        unset($data);
        if (!$productResult->isSuccess())
        {
            $result->addErrors($productResult->getErrors());
        }
        unset($productResult);
 
        if (empty($newProducts) && empty($existProducts))
        {
            return $result;
        }
 
        $data = [
            'fields' => $fields,
            'external_fields' => [
                'IBLOCK_ID' => $iblockId
            ]
        ];
        foreach ($existProducts as $id)
        {
            $elementResult = Catalog\Model\Product::update($id, $data);
            if (!$elementResult->isSuccess())
            {
                $result->addError(new Main\Error(
                    implode('; ', $elementResult->getErrorMessages()),
                    $id
                ));
            }
        }
        foreach ($newProducts as $id)
        {
            $data['fields']['ID'] = $id;
            $elementResult = Catalog\Model\Product::add($data);
            if (!$elementResult->isSuccess())
            {
                $result->addError(new Main\Error(
                    implode('; ', $elementResult->getErrorMessages()),
                    $id
                ));
            }
        }
        unset($elementResult, $id, $data);
        unset($newProducts, $existProducts);
        unset($blackList, $catalog);
 
        return $result;
    }
 
    protected static function getSectionProducts(int $iblockId, array $sections, array $filter): ?array
    {
        global $USER;
 
        if (!(isset($USER) && $USER instanceof \CUser))
        {
            return null;
        }
 
        if (!AccessController::getCurrent()->check(ActionDictionary::ACTION_PRODUCT_EDIT))
        {
            return null;
        }
 
        if ($iblockId <= 0)
        {
            return null;
        }
        Main\Type\Collection::normalizeArrayValuesByInt($sections, false);
        if (empty($sections))
        {
            return null;
        }
 
        $filter['IBLOCK_ID'] = $iblockId;
        $filter['INCLUDE_SUBSECTIONS'] = 'Y';
        $filter['CHECK_PERMISSIONS'] = 'Y';
        $filter['MIN_PERMISSION'] = 'R';
 
        $dublicates = [];
        $result = [];
        foreach ($sections as $sectionId)
        {
            $result[$sectionId] = [];
            $elements = [];
            $filter['SECTION_ID'] = $sectionId;
            $iterator = \CIBlockElement::GetList(
                ['ID' => 'ASC'],
                $filter,
                false,
                false,
                ['ID']
            );
            while ($row = $iterator->fetch())
            {
                $id = (int)$row['ID'];
                if (isset($dublicates[$id]))
                {
                    continue;
                }
                $dublicates[$id] = true;
                $elements[] = $id;
            }
            unset($id, $row, $iterator);
 
            if (!empty($elements))
            {
                $operations = \CIBlockElementRights::UserHasRightTo(
                    $iblockId,
                    $elements,
                    '',
                    \CIBlockRights::RETURN_OPERATIONS
                );
                foreach ($elements as $elementId)
                {
                    if (
                        isset($operations[$elementId]['element_edit'])
                        && isset($operations[$elementId]['element_edit_price'])
                    )
                    {
                        $result[$sectionId][] = $elementId;
                    }
                }
                unset($elementId);
                unset($operations);
            }
            unset($elements);
 
            if (empty($result[$sectionId]))
            {
                unset($result[$sectionId]);
            }
        }
        unset($sectionId);
        unset($dublicates);
 
        return (!empty($result) ? $result : null);
    }
 
    public static function getAllowedProductTypes(array $catalog, array $fields): array
    {
        static $list = null;
 
        if (empty($fields))
        {
            return [];
        }
 
        if ($list === null)
        {
            $list = [
                'WEIGHT',
                'QUANTITY',
                'QUANTITY_TRACE',
                'CAN_BUY_ZERO',
                'VAT_INCLUDED',
                'VAT_ID',
                'SUBSCRIBE',
                'MEASURE',
                'PURCHASING_PRICE',
                'PURCHASING_CURRENCY',
            ];
            $baseTypes = [
                Catalog\ProductTable::TYPE_PRODUCT,
                Catalog\ProductTable::TYPE_OFFER,
                CATALOG\ProductTable::TYPE_FREE_OFFER,
            ];
            if (
                $catalog['CATALOG_TYPE'] === \CCatalogSku::TYPE_FULL
                && Main\Config\Option::get('catalog', 'show_catalog_tab_with_offers') === 'Y'
            )
            {
                $baseTypes[] = Catalog\ProductTable::TYPE_SKU;
            }
            $list = array_fill_keys($list, $baseTypes);
            unset($baseTypes);
 
            $list['VAT_INCLUDED'][] = Catalog\ProductTable::TYPE_SET;
            $list['VAT_ID'][] = Catalog\ProductTable::TYPE_SET;
            $list['SUBSCRIBE'][] = Catalog\ProductTable::TYPE_SET;
 
            $list += Catalog\Product\SystemField::getAllowedProductTypes();
        }
 
        $result = [];
        foreach (array_keys($fields) as $fieldName)
        {
            if (!isset($list[$fieldName]))
            {
                $result = [];
                break;
            }
            $result[] = $list[$fieldName];
        }
 
        if (!empty($result))
        {
            if (count($result) === 1)
            {
                $result = reset($result);
            }
            else
            {
                $check = array_shift($result);
                foreach ($result as $row)
                {
                    $check = array_intersect($check, $row);
                }
                unset($row);
                $result = array_values($check);
                unset($check);
            }
            sort($result);
        }
 
        return $result;
    }
 
    public static function convertToServiceSectionList(int $iblockId, array $sections): Main\Result
    {
        return self::convertTypeSectionList($iblockId, $sections, Catalog\ProductTable::TYPE_PRODUCT);
    }
 
    public static function convertToProductSectionList(int $iblockId, array $sections): Main\Result
    {
        return self::convertTypeSectionList($iblockId, $sections, Catalog\ProductTable::TYPE_SERVICE);
    }
 
    public static function convertToServiceElementList(int $iblockId, array $elementIds): Main\Result
    {
        return self::convertTypeElementList($iblockId, $elementIds, Catalog\ProductTable::TYPE_PRODUCT);
    }
 
    public static function convertToProductElementList(int $iblockId, array $elementIds): Main\Result
    {
        return self::convertTypeElementList($iblockId, $elementIds, Catalog\ProductTable::TYPE_SERVICE);
    }
 
    private static function convertTypeSectionList(int $iblockId, array $sections, int $type): Main\Result
    {
        $result = new Main\Result();
 
        if ($iblockId <= 0)
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_IBLOCK_ID')
            ));
 
            return $result;
        }
 
        $catalog = \CCatalogSku::GetInfoByIBlock($iblockId);
        if (empty($catalog))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_CATALOG')
            ));
 
            return $result;
        }
 
        $filter = [
            '=TYPE' => $type,
        ];
 
        $sectionElements = self::getSectionProducts($iblockId, $sections, $filter);
        if (empty($sectionElements))
        {
            return $result;
        }
 
        $sectionIdList = array_keys($sectionElements);
        $sectionNames = [];
        $iterator = Iblock\SectionTable::getList([
            'select' => [
                'ID',
                'NAME',
            ],
            'filter' => [
                '@ID' => $sectionIdList,
                '=IBLOCK_ID' => $iblockId,
            ],
            'order' => ['ID' => 'ASC'],
        ]);
        while ($row = $iterator->fetch())
        {
            $row['ID'] = (int)$row['ID'];
            $sectionNames[$row['ID']] = $row['NAME'];
        }
        unset($row, $iterator);
 
        foreach ($sectionIdList as $sectionId)
        {
            $elementResult = self::convertTypeElementList(
                $iblockId,
                $sectionElements[$sectionId],
                $type
            );
            if (!$elementResult->isSuccess())
            {
                $result->addError(new Main\Error(
                    Loc::getMessage(
                        $type === Catalog\ProductTable::TYPE_PRODUCT
                            ? 'BX_CATALOG_PRODUCT_ACTION_ERR_SECTION_PRODUCTS_CONVERT'
                            : 'BX_CATALOG_PRODUCT_ACTION_ERR_SECTION_SERVICES_CONVERT'
                        ,
                        [
                            '#ID#' => $sectionId,
                            '#NAME#' => $sectionNames[$sectionId],
                        ]
                    ),
                    $sectionId
                ));
            }
        }
        unset($sectionId);
        unset($sectionNames, $sectionIdList, $sectionElements);
 
        return $result;
    }
 
    private static function convertTypeElementList(int $iblockId, array $elementIds, int $type): Main\Result
    {
        $result = new Main\Result();
 
        if ($iblockId <= 0)
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_IBLOCK_ID')
            ));
 
            return $result;
        }
 
        $catalog = \CCatalogSku::GetInfoByIBlock($iblockId);
        if (empty($catalog))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_BAD_CATALOG')
            ));
 
            return $result;
        }
 
        Main\Type\Collection::normalizeArrayValuesByInt($elementIds, true);
        if (empty($elementIds))
        {
            $result->addError(new Main\Error(
                Loc::getMessage('BX_CATALOG_PRODUCT_ACTION_ERR_EMPTY_ELEMENTS')
            ));
 
            return $result;
        }
 
        $productResult = self::getProductListByTypeForConversion($elementIds, $type);
        $data = $productResult->getData();
        $products = $data['PRODUCT_IDS'] ?? [];
        unset($data);
        if (!$productResult->isSuccess())
        {
            $result->addErrors($productResult->getErrors());
        }
        unset($productResult);
        if (empty($products))
        {
            return $result;
        }
 
        $inventoryResult = self::checkInventoryDocumentByProducts($products);
        $data = $inventoryResult->getData();
        $products = $data['PRODUCT_IDS'] ?? [];
        unset($data);
        if (!$inventoryResult->isSuccess())
        {
            $result->addErrors($inventoryResult->getErrors());
        }
        unset($inventoryResult);
        if (empty($products))
        {
            return $result;
        }
 
        $convertResult = self::convertCatalogType($products, $type);
        if (!$convertResult->isSuccess())
        {
            $result->addErrors($convertResult->getErrors());
        }
 
        return $result;
    }
 
    private static function getProductListByTypeForModify(array $elementIds, array $types): Main\Result
    {
        $result = new Main\Result();
 
        $types = array_fill_keys($types, true);
 
        $existList = [];
        $newList = array_fill_keys($elementIds, true);
        $errorList = [];
 
        foreach (array_chunk($elementIds, 500) as $pageIds)
        {
            $iterator = Catalog\ProductTable::getList([
                'select' => [
                    'ID',
                    'TYPE',
                ],
                'filter' => [
                    '@ID' => $pageIds,
                ]
            ]);
            while ($row = $iterator->fetch())
            {
                $row['ID'] = (int)$row['ID'];
                $row['TYPE'] = (int)$row['TYPE'];
                unset($newList[$row['ID']]);
                if (isset($types[$row['TYPE']]))
                {
                    $existList[] = $row['ID'];
                }
                else
                {
                    $errorList[] = $row['ID'];
                }
            }
            unset($row, $iterator);
        }
 
        $result->setData([
            'EXIST_PRODUCT_IDS' => $existList,
            'NEW_PRODUCT_IDS' => array_values($newList),
        ]);
        unset($existList, $newList);
 
        if (!empty($errorList))
        {
            $names = [];
            $iterator = Iblock\ElementTable::getList([
                'select' => [
                    'ID',
                    'NAME',
                ],
                'filter' => [
                    '@ID' => $errorList,
                ],
            ]);
            while ($row = $iterator->fetch())
            {
                $names[] = '[' . $row['ID'] . '] ' . $row['NAME'];
            }
            unset($row, $iterator);
            $result->addError(new Main\Error(
                Loc::getMessage(
                    'BX_CATALOG_PRODUCT_ACTION_ERR_CANNOT_SET_FIELD_BY_TYPE',
                    [
                        '#NAMES#' => implode(', ', $names),
                    ]
                )
            ));
            unset($names);
        }
        unset($errorList);
 
        return $result;
    }
 
    private static function getProductListByTypeForConversion(array $elementIds, int $type): Main\Result
    {
        $result = new Main\Result();
 
        $validList = [];
        $errorList = [];
 
        foreach (array_chunk($elementIds, 500) as $pageIds)
        {
            $iterator = Catalog\ProductTable::getList([
                'select' => [
                    'ID',
                    'TYPE',
                ],
                'filter' => [
                    '@ID' => $pageIds,
                ]
            ]);
            while ($row = $iterator->fetch())
            {
                $row['ID'] = (int)$row['ID'];
                $row['TYPE'] = (int)$row['TYPE'];
                if ($row['TYPE'] === $type)
                {
                    $validList[] = $row['ID'];
                }
                else
                {
                    $errorList[] = $row['ID'];
                }
            }
            unset($row, $iterator);
        }
 
        $result->setData(['PRODUCT_IDS' => $validList]);
        unset($validList);
        if (!empty($errorList))
        {
            $names = [];
            $iterator = Iblock\ElementTable::getList([
                'select' => [
                    'ID',
                    'NAME',
                ],
                'filter' => [
                    '@ID' => $errorList,
                ],
            ]);
            while ($row = $iterator->fetch())
            {
                $names[] = '[' . $row['ID'] . '] ' . $row['NAME'];
            }
            unset($row, $iterator);
            if ($type === Catalog\ProductTable::TYPE_PRODUCT)
            {
                $result->addError(new Main\Error(
                    Loc::getMessage(
                        'BX_CATALOG_PRODUCT_ACTION_ERR_SELECTED_NOT_SIMPLE_PRODUCT',
                        ['#NAMES#' => implode(', ', $names)]
                    )
                ));
            }
            else
            {
                $result->addError(new Main\Error(
                    Loc::getMessage(
                        'BX_CATALOG_PRODUCT_ACTION_ERR_SELECTED_NOT_SERVICE',
                        ['#NAMES#' => implode(', ', $names)]
                    )
                ));
            }
            unset($names);
        }
        unset($errorList);
 
        return $result;
    }
 
    private static function checkInventoryDocumentByProducts(array $elementIds): Main\Result
    {
        $result = new Main\Result();
        if (!Catalog\Config\State::isUsedInventoryManagement())
        {
            $result->setData(['PRODUCT_IDS' => $elementIds]);
 
            return $result;
        }
 
        $validList = array_fill_keys($elementIds, true);
        $errorList = [];
 
        $query = new ORM\Query\Query(Catalog\StoreDocumentElementTable::getEntity());
        $query->setDistinct(true);
        $query->setSelect([
            'ELEMENT_ID',
            'NAME' => 'ELEMENT.NAME'
        ]);
        $query->setFilter(['=DOCUMENT.STATUS' => 'Y']);
 
        foreach (array_chunk($elementIds, 500) as $pageIds)
        {
            $query->addFilter('@ELEMENT_ID', $pageIds);
            $iterator = $query->exec();
            while ($row = $iterator->fetch())
            {
                $id = (int)$row['ELEMENT_ID'];
                unset($validList[$id]);
                $errorList[] = '[' . $row['ELEMENT_ID'] . '] ' . $row['NAME'];
            }
            unset($row, $iterator);
        }
        unset($pagesIds);
        unset($query);
 
        $result->setData(['PRODUCT_IDS' => array_keys($validList)]);
        if (!empty($errorList))
        {
            $result->addError(new Main\Error(
                Loc::getMessage(
                    'BX_CATALOG_PRODUCT_ACTION_ERR_SELECTED_INVENTORY_PRODUCTS',
                    ['#NAMES#' => implode(', ', $errorList)]
                )
            ));
        }
 
        return $result;
    }
 
    private static function convertCatalogType(array $elementIds, int $type): Main\Result
    {
        $result = new Main\Result();
 
        $connection = Main\Application::getConnection();
        $helper = $connection->getSqlHelper();
 
        $sqlMain = 'update ' . $helper->quote(Catalog\ProductTable::getTableName());
 
        if ($type === Catalog\ProductTable::TYPE_PRODUCT)
        {
            $sqlMain .= ' set ' . $helper->quote('TYPE') . ' = ' . Catalog\ProductTable::TYPE_SERVICE
                . ', ' . $helper->quote('QUANTITY') . ' = ('
                . 'CASE WHEN ' . $helper->quote('AVAILABLE') . ' = \'Y\' THEN 1 ELSE 0 END'
                . '), ' . $helper->quote('QUANTITY_RESERVED') . ' = 0'
                . ', ' . $helper->quote('QUANTITY_TRACE') . ' = \'N\''
                . ', ' . $helper->quote('CAN_BUY_ZERO') . ' = \'Y\''
                . ', ' . $helper->quote('NEGATIVE_AMOUNT_TRACE') . ' = \'Y\''
            ;
        }
        else
        {
            $available = Catalog\ProductTable::calculateAvailable([
                'QUANTITY' => 0,
                'QUANTITY_TRACE' => Catalog\ProductTable::STATUS_DEFAULT,
                'CAN_BUY_ZERO' => Catalog\ProductTable::STATUS_DEFAULT,
            ]);
            $sqlMain .= ' set ' . $helper->quote('TYPE') . ' = ' . Catalog\ProductTable::TYPE_PRODUCT
                . (Catalog\Config\State::isUsedInventoryManagement()
                        ? ', ' . $helper->quote('AVAILABLE') . ' = \'' . $helper->forSql($available) . '\', '
                                . $helper->quote('QUANTITY') . ' = 0'
                        : ''
                    )
                . ', ' . $helper->quote('QUANTITY_TRACE') . ' = \'D\''
                . ', ' . $helper->quote('CAN_BUY_ZERO') . ' = \'D\''
                . ', ' . $helper->quote('NEGATIVE_AMOUNT_TRACE') . ' = \'D\''
            ;
        }
 
        $sqlMain .= ', ' . $helper->quote('TIMESTAMP_X') . ' = ' . $helper->quote('TIMESTAMP_X')
            . ' where ID in ('
        ;
 
        $sqlStores = 'delete from ' . $helper->quote(Catalog\StoreProductTable::getTableName())
            . ' where PRODUCT_ID in ('
        ;
 
        foreach (array_chunk($elementIds, 500) as $pageIds)
        {
            $list = implode(',', $pageIds);
            $connection->query($sqlMain . $list . ')');
 
            if ($type === Catalog\ProductTable::TYPE_PRODUCT)
            {
                $connection->query($sqlStores . $list . ')');
                $result = self::convertToService($pageIds);
            }
            else
            {
                $result = self::convertToProduct($pageIds);
            }
            if (!$result->isSuccess())
            {
                return $result;
            }
        }
 
        return $result;
    }

    protected static function convertToProduct(array $productIdList): Main\Result
    {
        return self::convert($productIdList, Catalog\ProductTable::TYPE_PRODUCT);
    }

    protected static function convertToService(array $productIdList): Main\Result
    {
        return self::convert($productIdList, Catalog\ProductTable::TYPE_SERVICE);
    }
 
    private static function convert(array $productIdList, int $catalogType): Main\Result
    {
        $result = new Main\Result();
 
        if (Main\Loader::includeModule('crm'))
        {
            $convertCrmProductResult = self::convertCrmProducts($productIdList, $catalogType);
            if (!$convertCrmProductResult->isSuccess())
            {
                $result->addErrors($convertCrmProductResult->getErrors());
            }
        }
 
        if (Main\Loader::includeModule('sale'))
        {
            $convertSaleProductResult = self::convertSaleProducts($productIdList, $catalogType);
            if (!$convertSaleProductResult->isSuccess())
            {
                $result->addErrors($convertSaleProductResult->getErrors());
            }
        }
 
        return $result;
    }
 
    private static function convertCrmProducts(array $productIdList, int $type): Main\Result
    {
        $connection = Main\Application::getConnection();
        $helper = $connection->getSqlHelper();
 
        $productIdSql = $helper->forSql(implode(',', $productIdList));
        $sql = sprintf(
            'UPDATE %s SET TYPE = %d WHERE PRODUCT_ID IN (%s)',
            $helper->quote(Crm\ProductRowTable::getTableName()),
            $type,
            $productIdSql
        );
 
        try
        {
            $connection->query($sql);
        }
        catch (Main\DB\SqlQueryException $exception)
        {
            return (new Main\Result())->addError(new Main\Error($exception->getMessage()));
        }
 
        return new Main\Result();
    }
 
    private static function convertSaleProducts(array $productIdList, int $type): Main\Result
    {
        $saleType = Sale\Internals\Catalog\ProductTypeMapper::getType($type);
 
        $connection = Main\Application::getConnection();
        $helper = $connection->getSqlHelper();
 
        $productIdSql = $helper->forSql(implode(',', $productIdList));
        $sql = sprintf(
            'UPDATE %s SET TYPE = %s WHERE PRODUCT_ID IN (%s)',
            $helper->quote(Sale\Internals\BasketTable::getTableName()),
            $saleType ?: $helper->convertToDb($saleType),
            $productIdSql
        );
 
        try
        {
            $connection->query($sql);
        }
        catch (Main\DB\SqlQueryException $exception)
        {
            return (new Main\Result())->addError(new Main\Error($exception->getMessage()));
        }
 
        return new Main\Result();
    }
}