markingcodegroup.php

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

<?php
 
namespace Bitrix\Catalog\Product\SystemField;
 
use Bitrix\Main;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Localization\LanguageTable;
use Bitrix\Main\Localization\Loc;
use Bitrix\Catalog;
use Bitrix\Catalog\Grid\Panel\ProductGroupAction;
use Bitrix\UI;
 
class MarkingCodeGroup extends Highloadblock
{
    public const FIELD_ID = 'MARKING_CODE_GROUP';
 
    protected const SHORT_FIELD_ID = 'PRODUCT_GROUP';
 
    public const TYPE_ID = Catalog\Product\SystemField\Type\HighloadBlock::class;
 
    protected const VALUE_NAME_PREFIX = 'MARKING_CODE_GROUP_TYPE_';
 
    protected const USE_PARENT_PRODUCT_VALUE = -1;
    protected const USE_PARENT_PRODUCT_XML_VALUE = 'PARENT_MARKING_GROUP';
 
    public static function getConfig(): ?array
    {
        if (!static::isAllowed())
        {
            return null;
        }

        $className = static::getTypeId();
        $fieldId = static::getFieldId();
 
        $result = [
            'HIGHLOADBLOCK' => [
                'TABLE_NAME' => $className::getTableName($fieldId),
                'NAME' => $className::getName($fieldId),
                'FIELDS' => static::getHighloadblockFields(),
                'RIGHTS' => $className::getDefaultRights(),
                'TRANSFORM_VALUES' => static::getHighloadblockTransformValues(),
                'VALUES' => static::getHighloadblockValues(),
            ],
            'FIELD' => self::getUserFieldBaseParam() + [
                'SORT' => 100,
                'SHOW_FILTER' => 'S',
                'SHOW_IN_LIST' => 'Y',
                'EDIT_IN_LIST' => 'Y',
                'IS_SEARCHABLE' => 'N',
                'SETTINGS' => $className::getDefaultSettings(),
            ],
            'FIELD_CONFIG' => [
                'HLFIELD_ID' => 'UF_NAME',
            ],
        ];
 
        $titles = static::getMessages(
            __FILE__,
            ['TITLES' => 'MARKING_CODE_GROUP_STORAGE_TITLE',]
        );
 
        $result['HIGHLOADBLOCK'] = $result['HIGHLOADBLOCK'] + $titles;
 
        $result['FIELD'] += static::getMessages(
            __FILE__,
            [
                'EDIT_FORM_LABEL' => 'MARKING_CODE_GROUP_FIELD_TITLE',
                'LIST_COLUMN_LABEL' => 'MARKING_CODE_GROUP_FIELD_TITLE',
                'LIST_FILTER_LABEL' => 'MARKING_CODE_GROUP_FIELD_TITLE',
            ]
        );
 
        return $result;
    }
 
    public static function isAllowed(): bool
    {
        $className = static::getTypeId();
 
        if (!$className::isAllowed())
        {
            return false;
        }
 
        return Main\Application::getInstance()->getLicense()->getRegion() === 'ru';
    }
 
    protected static function getTitleInternal(): ?string
    {
        return Loc::getMessage('MARKING_CODE_GROUP_FIELD_TITLE');
    }
 
    public static function getUserFieldBaseParam(): array
    {
        $className = static::getTypeId();
 
        return [
            'ENTITY_ID' => Catalog\ProductTable::getUfId(),
            'FIELD_NAME' => static::getUserFieldName(self::SHORT_FIELD_ID),
            'USER_TYPE_ID' => $className::getUserTypeId(),
            'XML_ID' => static::getFieldId(),
            'MULTIPLE' => 'N',
            'MANDATORY' => 'N',
        ];
    }

    protected static function getHighloadblockFields(): array
    {
        $result = [];
 
        $fieldSettings = [
            'XML_ID' => [
                'DEFAULT_VALUE' => '',
                'SIZE' => 16,
                'ROWS' => 1,
                'MIN_LENGTH' => 0,
                'MAX_LENGTH' => 0,
                'REGEXP' => '/^[0-9]{1,16}$/'
            ],
            'NAME' => [
                'DEFAULT_VALUE' => '',
                'SIZE' => 100,
                'ROWS' => 1,
                'MIN_LENGTH' => 1,
                'MAX_LENGTH' => 255,
                'REGEXP' => ''
            ]
        ];
 
        $sort = 100;
        foreach (array_keys($fieldSettings) as $fieldId)
        {
            $messageList = static::getMessages(
                __FILE__,
                [
                    'EDIT_FORM_LABEL' => 'MARKING_CODE_GROUP_UF_FIELD_'.$fieldId,
                    'LIST_COLUMN_LABEL' => 'MARKING_CODE_GROUP_UF_FIELD_'.$fieldId,
                    'LIST_FILTER_LABEL' => 'MARKING_CODE_GROUP_UF_FIELD_'.$fieldId
                ]
            );
 
            $result[] = [
                'FIELD_NAME' => static::getUserFieldName($fieldId),
                'USER_TYPE_ID' => Main\UserField\Types\StringType::USER_TYPE_ID,
                'XML_ID' => $fieldId,
                'SORT' => $sort,
                'MULTIPLE' => 'N',
                'MANDATORY' => 'Y',
                'SHOW_FILTER' => 'S',
                'SHOW_IN_LIST' => 'Y',
                'EDIT_IN_LIST' => 'Y',
                'IS_SEARCHABLE' => 'N',
                'SETTINGS' => $fieldSettings[$fieldId],
            ] + $messageList;
            $sort += 100;
        }
 
        return $result;
    }
 
    protected static function getHighloadblockValues(): array
    {
        $groupCodes = [
            '02',
            '03',
            '05',
            '17485',
            '8258',
            '8721',
            '9840',
            '06',
            '5010',
            '5137',
            '5139',
            '5140',
        ];
        $groupTitles = Loc::loadLanguageFile(
            $_SERVER['DOCUMENT_ROOT'].'/bitrix/modules/catalog/regionalsystemfields/markingcodegroup.php',
            'ru'
        );
 
        $result = [];
        foreach ($groupCodes as $id)
        {
            $result[] = [
                'UF_XML_ID' => $id,
                'UF_NAME' => $groupTitles[self::VALUE_NAME_PREFIX.$id]
            ];
        }
 
        return $result;
    }
 
    protected static function getHighloadblockTransformValues(): array
    {
        return [
            [
                'OLD_XML_ID' => '5048',
                'NEW_XML_ID' => '17485',
            ],
            [
                'OLD_XML_ID' => '5408',
                'NEW_XML_ID' => '17485',
            ],
        ];
    }
 
    protected static function getGridActionConfig(ProductGroupAction $panel): ?array
    {
        $catalog = $panel->getCatalogConfig();
        if (empty($catalog))
        {
            return null;
        }
        $allowForOffers =
            $catalog['CATALOG_TYPE'] === \CCatalogSku::TYPE_OFFERS
            && self::isUsedMarkingOffer()
        ;
        if (
            $catalog['CATALOG_TYPE'] !== \CCatalogSku::TYPE_CATALOG
            && $catalog['CATALOG_TYPE'] !== \CCatalogSku::TYPE_FULL
            && $catalog['CATALOG_TYPE'] !== \CCatalogSku::TYPE_PRODUCT
            && !$allowForOffers
        )
        {
            return null;
        }
 
        $field = static::load();
        if (empty($field))
        {
            return null;
        }
 
        $config = [
            'USER_FIELD' => $field,
            'VISUAL' => [
                'LIST' => [
                    'ID' => $panel->getFormRowFieldId($field['FIELD_NAME']),
                    'NAME' => $panel->getFormRowFieldName($field['FIELD_NAME']),
                ],
            ],
        ];
 
        if ($allowForOffers)
        {
            $config['ADDITIONAL_ITEMS'] = [
                'LIST' => [
                    [
                        'VALUE' => self::USE_PARENT_PRODUCT_VALUE,
                        'NAME' => Loc::getMessage('MARKING_CODE_GROUP_MESS_USE_PARENT_PRODUCT_VALUE'),
                    ],
                ]
            ];
        }
 
        return $config;
    }
 
    public static function getAllowedProductTypeList(): array
    {
        $result = [
            Catalog\ProductTable::TYPE_PRODUCT,
            Catalog\ProductTable::TYPE_SKU,
        ];
        if (self::isUsedMarkingOffer())
        {
            $result[] = Catalog\ProductTable::TYPE_OFFER;
        }
 
        return $result;
    }
 
    public static function checkRestictions(array $restrictions): bool
    {
        if (!parent::checkRestictions($restrictions))
        {
            return false;
        }
 
        if (isset($restrictions['IBLOCK_ID']) && !isset($restrictions['CATALOG']))
        {
            $iterator = Catalog\CatalogIblockTable::getList([
                'select' => [
                    '*',
                ],
                'filter' => [
                    '=IBLOCK_ID' => $restrictions['IBLOCK_ID'],
                ],
                'cache' => [
                    'ttl' => 86400,
                ]
            ]);
            $row = $iterator->fetch();
            if (!empty($row))
            {
                $restrictions['CATALOG'] = $row;
            }
            unset($row, $iterator);
        }
 
        if (!empty($restrictions['CATALOG']) && is_array($restrictions['CATALOG']))
        {
            if ($restrictions['CATALOG']['SUBSCRIPTION'] === 'Y')
            {
                return false;
            }
        }
 
        return true;
    }
 
    public static function getAllowedOperations(): array
    {
        return [
            Catalog\Product\SystemField::OPERATION_PROVIDER,
            Catalog\Product\SystemField::OPERATION_EXPORT,
            Catalog\Product\SystemField::OPERATION_IMPORT,
        ];
    }
 
    public static function getOperationSelectFieldList(string $operation): array
    {
        if (!static::isAllowed())
        {
            return [];
        }
 
        $fields = static::getUserFieldBaseParam();
        switch($operation)
        {
            case Catalog\Product\SystemField::OPERATION_PROVIDER:
            case Catalog\Product\SystemField::OPERATION_EXPORT:
            case Catalog\Product\SystemField::OPERATION_IMPORT:
                $result = [
                    $fields['XML_ID'] => $fields['FIELD_NAME'],
                ];
                break;
            default:
                $result = [];
                break;
        }
 
        return $result;
    }
 
    public static function prepareValue(string $operation, array $productRow): array
    {
        $field = static::load();
        if ($field === null)
        {
            return $productRow;
        }
        if (!array_key_exists($field['XML_ID'], $productRow))
        {
            return $productRow;
        }
 
        switch ($operation)
        {
            case Catalog\Product\SystemField::OPERATION_PROVIDER:
                $productRow = self::prepareValueForProvider($field, $productRow);
                break;
            case Catalog\Product\SystemField::OPERATION_IMPORT:
                $productRow = self::prepareValueForImport($field, $productRow);
                break;
            case Catalog\Product\SystemField::OPERATION_EXPORT:
                $productRow = self::prepareValueForExport($field, $productRow);
                break;
        }
 
        return $productRow;
    }
 
    private static function prepareValueForProvider(array $field, array $productRow): array
    {
        $value = $productRow[$field['XML_ID']];
        if ($value !== null)
        {
            $value = (int)$value;
        }
        if (self::isNeedParent($productRow))
        {
            if (
                !self::isUsedMarkingOffer()
                || $value === self::USE_PARENT_PRODUCT_VALUE
            )
            {
                $productValue = self::getParentProductValue($productRow['ID'], $field);
                if ($value === self::USE_PARENT_PRODUCT_VALUE)
                {
                    $value = $productValue;
                }
                else
                {
                    $value = $productValue ?? $value;
                }
            }
        }
 
        $productRow[$field['XML_ID']] = ($value !== null
            ? self::getXmlIdById($field['SETTINGS']['HLBLOCK_ID'], (int)$value)
            : null
        );
 
        return $productRow;
    }
 
    private static function prepareValueForImport(array $field, array $productRow): array
    {
        $value = $productRow[$field['XML_ID']];
        if ($value === self::USE_PARENT_PRODUCT_XML_VALUE)
        {
            $productRow[$field['FIELD_NAME']] = self::USE_PARENT_PRODUCT_VALUE;
        }
        else
        {
            $productRow[$field['FIELD_NAME']] = ($value !== null
                ? self::getIdByXmlId($field['SETTINGS']['HLBLOCK_ID'], $value)
                : null
            );
        }
        unset($productRow[$field['XML_ID']]);
 
        return $productRow;
    }
 
    private static function prepareValueForExport(array $field, array $productRow): array
    {
        $value = $productRow[$field['XML_ID']];
        if ($value !== null)
        {
            $value = (int)$value;
        }
        if ($value === self::USE_PARENT_PRODUCT_VALUE)
        {
            $productRow[$field['XML_ID']] = self::USE_PARENT_PRODUCT_XML_VALUE;
        }
        elseif ($value !== null)
        {
            $productRow[$field['XML_ID']] = self::getXmlIdById(
                $field['SETTINGS']['HLBLOCK_ID'],
                $value
            );
        }
 
        return $productRow;
    }
 
    private static function isNeedParent(array $productRow): bool
    {
        return
            isset($productRow['ID'])
            && isset($productRow['TYPE'])
            && (int)$productRow['TYPE'] === Catalog\ProductTable::TYPE_OFFER
        ;
    }
 
    private static function isUsedMarkingOffer(): bool
    {
        return Option::get('catalog', 'use_offer_marking_code_group') === 'Y';
    }
 
    private static function getParentProductValue(int $id, $field): ?string
    {
        $result = null;
        $parentsList = \CCatalogSku::getProductList($id);
        if (!empty($parentsList) && isset($parentsList[$id]))
        {
            $row = Catalog\ProductTable::getRow([
                'select' => [
                    'ID',
                    $field['FIELD_NAME'],
                ],
                'filter' => [
                    '=ID' => $parentsList[$id]['ID'],
                ],
            ]);
            if ($row !== null)
            {
                $result = $row[$field['FIELD_NAME']];
            }
        }
 
        return $result;
    }
 
    protected static function afterLoadInternalModify(array $row): array
    {
        $row = parent::afterLoadInternalModify($row);
        if (empty($row['SETTINGS']) || !is_array($row['SETTINGS']))
        {
            $row['SETTINGS'] = [];
        }
        $row['SETTINGS']['HLBLOCK_ID'] = (int)($row['SETTINGS']['HLBLOCK_ID'] ?? 0);
        $row['SETTINGS']['HLFIELD_ID'] = (int)($row['SETTINGS']['HLFIELD_ID'] ?? 0);
 
        return $row;
    }
 
    public static function updateProductFormConfiguration(): void
    {
        if (!static::isAllowed())
        {
            return;
        }
        $field = static::load();
        if ($field === null)
        {
            return;
        }
 
        Catalog\Update\UiFormConfiguration::addFormField(
            [
                'name' => $field['FIELD_NAME'],
                'optionFlags' => '1',
                'options' => [
                    'showCode' => 'true',
                ]
            ],
            Catalog\Update\UiFormConfiguration::PARENT_SECTION_MAIN
        );
    }
 
    public static function renderAdminFormControl(array $field, array $product, array $config): ?string
    {
        $result = parent::renderAdminFormControl($field, $product, $config);
        if ($result !== null)
        {
            if ($product['TYPE'] === Catalog\ProductTable::TYPE_OFFER)
            {
                $parentSelected = (int)$field['VALUE'] === self::USE_PARENT_PRODUCT_VALUE;
                $addOption = '<option value="' . self::USE_PARENT_PRODUCT_VALUE . '"'
                    . ($parentSelected ? ' selected' : '')
                    . '>' . htmlspecialcharsbx(Loc::getMessage('MARKING_CODE_GROUP_MESS_USE_PARENT_PRODUCT_VALUE'))
                    . '</option>'
                ;
                if ($parentSelected)
                {
                    $result = str_replace('selected', '', $result);
                }
                $index = strpos($result, '</option>');
                if ($index !== false)
                {
                    $index += 9; //  after first option
                    $result = substr($result, 0, $index)
                        . $addOption
                        . substr($result, $index)
                    ;
                }
            }
        }
 
        return $result;
    }
 
    protected static function getUiDescriptionInternal(array $description, array $userField, array $restrictions): ?array
    {
        $description['type'] = UI\EntityForm\Control\Type::LIST;
 
        $config = [
            'RESULT' => [
                'RETURN_FIELD_ID' => 'Y',
            ],
        ];
 
        if (
            isset($restrictions['TYPE'])
            && $restrictions['TYPE'] === Catalog\ProductTable::TYPE_OFFER
            && self::isUsedMarkingOffer()
        )
        {
            $config['ADDITIONAL_ITEMS'] = [
                'LIST' => [
                    0 => [
                        'ID' => (string)self::USE_PARENT_PRODUCT_VALUE,
                        'VALUE' => (string)self::USE_PARENT_PRODUCT_VALUE,
                        'NAME' => Loc::getMessage('MARKING_CODE_GROUP_MESS_USE_PARENT_PRODUCT_VALUE'),
                    ]
                ]
            ];
        }
 
        $items = Type\HighloadBlock::getItems($userField, $config);
        if ($items !== null)
        {
            $description['data'] += [
                'items' => $items
            ];
        }
        unset($items);
 
        return $description;
    }
}