store_docs.php

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

<?php
 
use Bitrix\Catalog;
use Bitrix\Catalog\Document\DocumentFieldsManager;
use Bitrix\Catalog\Integration\PullManager;
use Bitrix\Catalog\v2\Contractor;
use Bitrix\Main\Application;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
 
IncludeModuleLangFile(__FILE__);
 
class CAllCatalogDocs
{
    static $types = [
        Catalog\StoreDocumentTable::TYPE_ARRIVAL => "CCatalogArrivalDocs",
        Catalog\StoreDocumentTable::TYPE_STORE_ADJUSTMENT => "CCatalogStoreAdjustmentDocs",
        Catalog\StoreDocumentTable::TYPE_MOVING => "CCatalogMovingDocs",
        Catalog\StoreDocumentTable::TYPE_RETURN => "CCatalogReturnsDocs",
        Catalog\StoreDocumentTable::TYPE_DEDUCT => "CCatalogDeductDocs",
        Catalog\StoreDocumentTable::TYPE_UNDO_RESERVE => "CCatalogUnReservedDocs",
    ];
 
    public const DELETE_CONDUCTED_ERROR = 1;
    private const STORE_CONTROL_DISABLED_CONDUCT_ERROR = 'store_control_disabled_conduct';
 
    public const CONDUCTED = 'Y';
    public const CANCELLED = 'C';

    public static function update($id, $arFields)
    {
        global $DB;
        global $APPLICATION;
        global $USER_FIELD_MANAGER;
        $id = (int)$id;
 
        if ($id <= 0)
        {
            return false;
        }
 
        $oldFields = Catalog\StoreDocumentTable::getById($id)->fetch();
        if (empty($oldFields))
        {
            return false;
        }
        $allOldFields = $oldFields;
 
        $isConducted = $oldFields['STATUS'] === 'Y';
        $isStatusChangingToUnconducted = isset($arFields['STATUS']) && $arFields['STATUS'] === 'N';
        if ($isConducted && !$isStatusChangingToUnconducted)
        {
            $APPLICATION->ThrowException(GetMessage('CAT_DOC_SAVE_CONDUCTED_DOCUMENT'));
            return false;
        }
 
        foreach (GetModuleEvents("catalog", "OnBeforeDocumentUpdate", true) as $arEvent)
        {
            if (ExecuteModuleEventEx($arEvent, array($id, &$arFields)) === false)
            {
                return false;
            }
        }
 
        if (array_key_exists('DATE_CREATE',$arFields))
        {
            unset($arFields['DATE_CREATE']);
        }
        if (array_key_exists('DATE_MODIFY', $arFields))
        {
            unset($arFields['DATE_MODIFY']);
        }
        if (array_key_exists('DATE_STATUS', $arFields))
        {
            unset($arFields['DATE_STATUS']);
        }
        if (array_key_exists('CREATED_BY', $arFields))
        {
            unset($arFields['CREATED_BY']);
        }
        if (array_key_exists('DOC_TYPE', $arFields))
        {
            unset($arFields['DOC_TYPE']);
        }
        if (array_key_exists('ID', $arFields))
        {
            unset($arFields['ID']);
        }
 
        $arFields['~DATE_MODIFY'] = $DB->GetNowFunction();
 
        if (!static::checkFields('UPDATE', $arFields))
        {
            return false;
        }
 
        if (!static::checkRequiredFields($arFields, $oldFields['DOC_TYPE']))
        {
            return false;
        }
 
        $oldFields = array_intersect_key($oldFields, $arFields);
 
        $strUpdate = $DB->PrepareUpdate("b_catalog_store_docs", $arFields);
 
        if(!empty($strUpdate))
        {
            $strSql = "update b_catalog_store_docs set ".$strUpdate." where ID = ".$id;
            if(!$DB->Query($strSql, true))
                return false;
 
            if(isset($arFields["ELEMENT"]))
            {
                foreach($arFields["ELEMENT"] as $arElement)
                {
                    if(is_array($arElement))
                        CCatalogStoreDocsElement::update($arElement["ID"], $arElement);
                }
            }
 
            foreach(GetModuleEvents("catalog", "OnDocumentUpdate", true) as $arEvent)
                ExecuteModuleEventEx($arEvent, array($id, $arFields, $oldFields));
        }
 
        if (isset($arFields['DOCUMENT_FILES']) && is_array($arFields['DOCUMENT_FILES']))
        {
            static::saveFiles($id, $arFields['DOCUMENT_FILES']);
        }
 
        $typeTableClass = Catalog\Document\StoreDocumentTableManager::getTableClassByType($allOldFields['DOC_TYPE']);
        if ($typeTableClass)
        {
            $USER_FIELD_MANAGER->Update($typeTableClass::getUfId(), $id, $arFields);
        }
 
        $item = [
            'id' => $id,
            'data' => [
                'fields' => $arFields,
                'oldFields' => $allOldFields,
            ],
        ];
 
        PullManager::getInstance()->sendDocumentsUpdatedEvent(
            [
                $item,
            ]
        );
 
        return true;
    }
 
    protected static function saveFiles(int $documentId, array $files)
    {
        if (empty($files))
        {
            return;
        }
 
        // load current file list
        $existingFiles = [];
        $fileMap = [];
        $iterator = Catalog\StoreDocumentFileTable::getList([
            'select' => [
                'ID',
                'FILE_ID',
            ],
            'filter' => [
                '=DOCUMENT_ID' => $documentId,
            ],
        ]);
        while ($row = $iterator->fetch())
        {
            $id = (int)$row['ID'];
            $fileId = (int)$row['FILE_ID'];
            $existingFiles[$id] = [
                'ID' => $id,
                'FILE_ID' => $fileId,
            ];
            $fileMap[$fileId] = $id;
        }
        unset($iterator, $row);
 
        // convert the new list of files to array format for each line if needed
        $files = static::convertFileList($fileMap, $files);
        if (empty($files))
        {
            return;
        }
 
        // checking that the passed set of document files is full
        foreach (array_keys($existingFiles) as $rowId)
        {
            if (!isset($files[$rowId]))
            {
                $files[$rowId] = $existingFiles[$rowId];
            }
        }
 
        // process file list
        $parsed = [];
        foreach ($files as $rowId => $row)
        {
            // replace or delete existing file
            if (
                is_int($rowId)
                && is_array($row)
                && isset($existingFiles[$rowId])
            )
            {
                // delete file
                if (
                    isset($row['DEL'])
                    && $row['DEL'] === 'Y'
                )
                {
                    $resultInternal = Catalog\StoreDocumentFileTable::delete($rowId);
                    if ($resultInternal->isSuccess())
                    {
                        CFile::Delete($existingFiles[$rowId]['FILE_ID']);
                    }
                }
                // replace file
                elseif (
                    isset($row['FILE_ID'])
                )
                {
                    if ($row['FILE_ID'] !== $existingFiles[$rowId]['FILE_ID'])
                    {
                        $resultInternal = Catalog\StoreDocumentFileTable::update(
                            $rowId,
                            [
                                'FILE_ID' => $row['FILE_ID'],
                            ]
                        );
                        if ($resultInternal->isSuccess())
                        {
                            CFile::Delete($existingFiles[$rowId]['FILE_ID']);
                        }
                    }
                }
            }
            // save new file
            elseif (
                preg_match('/^n[0-9]+$/', $rowId, $parsed)
                && is_array($row)
            )
            {
                // file already saved from external code
                if (isset($row['FILE_ID']))
                {
                    $resultInternal = Catalog\StoreDocumentFileTable::add([
                        'DOCUMENT_ID' => $documentId,
                        'FILE_ID' => $row['FILE_ID'],
                    ]);
                    if ($resultInternal->isSuccess())
                    {
                        $id = (int)$resultInternal->getId();
                        $fileMap[$row['FILE_ID']] = $id;
                        $existingFiles[$id] = [
                            'ID' => $id,
                            'FILE_ID' => $row['FILE_ID'],
                        ];
                    }
                }
                // save uploaded file
                elseif (
                    isset($row['FILE_UPLOAD'])
                    && is_array($row['FILE_UPLOAD'])
                )
                {
                    $row['FILE_UPLOAD']['MODULE_ID'] = 'catalog';
                    $fileId = (int)CFile::SaveFile(
                        $row['FILE_UPLOAD'],
                        'catalog',
                        false,
                        true
                    );
                    if ($fileId > 0)
                    {
                        $resultInternal = Catalog\StoreDocumentFileTable::add([
                            'DOCUMENT_ID' => $documentId,
                            'FILE_ID' => $fileId,
                        ]);
                        if ($resultInternal->isSuccess())
                        {
                            $id = (int)$resultInternal->getId();
                            $fileMap[$fileId] = $id;
                            $existingFiles[$id] = [
                                'ID' => $id,
                                'FILE_ID' => $fileId,
                            ];
                        }
                    }
                }
            }
        }
    }
 
    protected static function convertFileList(array $fileMap, array $files): array
    {
        $formatArray = false;
        $formatOther = false;
        foreach ($files as $value)
        {
            if (is_array($value))
            {
                $formatArray = true;
            }
            else
            {
                $formatOther = true;
            }
        }
        unset($value);
 
        if ($formatArray && $formatOther)
        {
            return [];
        }
 
        if ($formatArray)
        {
            return $files;
        }
 
        $counter = 0;
        $list = array_values(array_unique($files));
        $files = [];
        $parsed = [];
        foreach ($list as $value)
        {
            if (!is_string($value))
            {
                continue;
            }
            if (preg_match('/^delete([0-9]+)$/', $value, $parsed))
            {
                $value = (int)$parsed[1];
                if (isset($fileMap[$value]))
                {
                    $id = $fileMap[$value];
                    $files[$id] = [
                        'DEL' => 'Y',
                    ];
                }
            }
            elseif (preg_match('/^[0-9]+$/', $value, $parsed))
            {
                $value = (int)$value;
                if (isset($fileMap[$value]))
                {
                    $id = $fileMap[$value];
                    $files[$id] = [
                        'ID' => $id,
                        'FILE_ID' => $value,
                    ];
                }
                else
                {
                    $id = 'n' . $counter;
                    $counter++;
                    $files[$id] = [
                        'ID' => null,
                        'FILE_ID' => $value,
                    ];
                }
            }
        }
        unset($value, $list);
        unset($id, $counter);
 
        return $files;
    }

    public static function delete($id)
    {
        global $DB;
        global $USER_FIELD_MANAGER;
 
        $id = (int)$id;
        if ($id <= 0)
        {
            return false;
        }
 
        $iterator = Catalog\StoreDocumentTable::getList([
            'select' => [
                'ID',
                'STATUS',
                'DOC_TYPE',
            ],
            'filter' => [
                '=ID' => $id,
            ],
        ]);
        $document = $iterator->fetch();
        if (empty($document))
        {
            return false;
        }
        unset($iterator);
 
        if ($document['STATUS'] === 'Y')
        {
            $GLOBALS['APPLICATION']->ThrowException(
                Loc::getMessage('CAT_DOC_WRONG_STATUS'),
                self::DELETE_CONDUCTED_ERROR
            );
            return false;
        }
 
        $events = GetModuleEvents('catalog', 'OnBeforeDocumentDelete', true);
        foreach($events as $event)
        {
            ExecuteModuleEventEx($event, [$id]);
        }
 
        $DB->Query("DELETE FROM b_catalog_store_docs WHERE ID = ".$id, true);
 
        $typeTableClass = Catalog\Document\StoreDocumentTableManager::getTableClassByType($document['DOC_TYPE']);
        if ($typeTableClass)
        {
            $USER_FIELD_MANAGER->Delete($typeTableClass::getUfId(), $id);
        }
 
        static::deleteDocumentFiles($id);
        Catalog\StoreDocumentElementTable::deleteByDocument($id);
        Catalog\StoreDocumentBarcodeTable::deleteByDocument($id);
 
        $contractorsProvider = Contractor\Provider\Manager::getActiveProvider(Contractor\Provider\Manager::PROVIDER_STORE_DOCUMENT);
        if ($contractorsProvider)
        {
            $contractorsProvider::onAfterDocumentDelete($id);
        }
        if (Loader::includeModule('crm'))
        {
            \Bitrix\Crm\Timeline\TimelineEntry::deleteByOwner(\CCrmOwnerType::StoreDocument, $id);
        }
 
        // First and second event - only for compatibility. Attention - order cannot change
        $eventList = [
            'OnDocumentBarcodeDelete',
            'OnDocumentElementDelete',
            'OnDocumentDelete',
        ];
 
        foreach ($eventList as $eventName)
        {
            foreach (GetModuleEvents('catalog', $eventName, true) as $event)
            {
                ExecuteModuleEventEx($event, [$id]);
            }
        }
 
        $item = [
            'id' => $id,
        ];
        PullManager::getInstance()->sendDocumentDeletedEvent(
            [
                $item,
            ]
        );
 
        return true;
    }
 
    protected static function deleteDocumentFiles(int $documentId): void
    {
        $documentFiles = Catalog\StoreDocumentFileTable::getList([
            'select' => ['FILE_ID'],
            'filter' => ['=DOCUMENT_ID' => $documentId],
        ])->fetchAll();
 
        $fileIds = array_column($documentFiles, 'FILE_ID');
        foreach ($fileIds as $fileId)
        {
            CFile::Delete($fileId);
        }
 
        $connection = \Bitrix\Main\Application::getConnection();
        $helper = $connection->getSqlHelper();
        $connection->queryExecute(
            'delete from ' . $helper->quote(Catalog\StoreDocumentFileTable::getTableName())
            . ' where ' . $helper->quote('DOCUMENT_ID') . ' = ' . $documentId
        );
    }

    protected static function checkRequiredFields(array $arFields, string $docType): bool
    {
        global $APPLICATION;
 
        $requiredFields = DocumentFieldsManager::getRequiredFields($docType);
        foreach ($requiredFields as $requiredField)
        {
            if (
                array_key_exists($requiredField, $arFields)
                && !$arFields[$requiredField]
            )
            {
                $APPLICATION->ThrowException(
                    GetMessage(
                        'CAT_DOC_ERROR_REQUIRED_FIELD',
                        [
                            '#FIELD_NAME#' => $requiredField,
                        ]
                    )
                );
 
                return false;
            }
        }
 
        return true;
    }

    protected static function checkFields($action, &$arFields)
    {
        global $DB;
        global $APPLICATION;
 
        if((($action == 'ADD') || isset($arFields["DOC_TYPE"])) && $arFields["DOC_TYPE"] == '' && !isset(self::$types[$arFields["DOC_TYPE"]]))
        {
            $APPLICATION->ThrowException(GetMessage("CAT_DOC_WRONG_TYPE"));
            return false;
        }
        if((($action == 'ADD') || isset($arFields["SITE_ID"])) && $arFields["SITE_ID"] == '' )
        {
            $APPLICATION->ThrowException(GetMessage("CAT_DOC_WRONG_SITE_ID"));
            return false;
        }
        if((($action == 'ADD') || isset($arFields["RESPONSIBLE_ID"])) && $arFields["RESPONSIBLE_ID"] == '' )
        {
            $APPLICATION->ThrowException(GetMessage("CAT_DOC_WRONG_RESPONSIBLE"));
            return false;
        }
        if ($action == 'ADD' || array_key_exists('STATUS', $arFields))
        {
            $arFields['STATUS'] = (isset($arFields['STATUS']) && 'Y' === $arFields['STATUS'] ? 'Y' : 'N');
        }
        if(isset($arFields["STATUS"]))
        {
            $arFields['~DATE_STATUS'] = $DB->GetNowFunction();
        }
        if(isset($arFields["DATE_DOCUMENT"]) && (!$DB->IsDate($arFields["DATE_DOCUMENT"])))
        {
            unset($arFields["DATE_DOCUMENT"]);
            $arFields['~DATE_DOCUMENT'] = $DB->GetNowFunction();
        }
        return true;
    }

    public static function conductDocument($documentId, $userId = 0)
    {
        global $APPLICATION;
 
        if (!Catalog\Config\State::isUsedInventoryManagement())
        {
            $APPLICATION->ThrowException(
                Loc::getMessage('CAT_DOC_CONDUCT_UNCONDUCT_NOT_AVAILABLE'),
                self::STORE_CONTROL_DISABLED_CONDUCT_ERROR,
            );
 
            return false;
        }
 
        if (Catalog\Store\EnableWizard\Manager::isOnecMode())
        {
            $APPLICATION->ThrowException(Loc::getMessage('CAT_DOC_CONDUCT_UNCONDUCT_NOT_AVAILABLE_EXTERNAL_CATALOG'));
 
            return false;
        }
 
        $documentId = (int)$documentId;
        $userId = (int)$userId;
        $currency = null;
        $contractorId = 0;
 
        $docTypes = CCatalogDocs::getList(
            [],
            [
                'ID' => $documentId,
            ],
            false,
            false,
            [
                'ID',
                'DOC_TYPE',
                'CURRENCY',
                'CONTRACTOR_ID',
                'STATUS',
            ]
        );
 
        if($docType = $docTypes->Fetch())
        {
            if ($docType['STATUS'] !== self::CONDUCTED)
            {
                $documentClass = self::$types[$docType['DOC_TYPE']];
 
                if($docType['CURRENCY'] <> '')
                {
                    $currency = $docType['CURRENCY'];
                }
 
                if($docType['CONTRACTOR_ID'] <> '')
                {
                    $contractorId = $docType['CONTRACTOR_ID'];
                }
 
                $result = $documentClass::conductDocument($documentId, $userId, $currency, $contractorId);
                if($result)
                {
                    $docFields = [
                        'STATUS' => self::CONDUCTED,
                    ];
 
                    if($userId > 0)
                    {
                        $docFields['STATUS_BY'] = $userId;
                        $docFields['MODIFIED_BY'] = $userId;
                    }
 
                    if(!self::update($documentId, $docFields))
                    {
                        return false;
                    }
                }
 
                if ($result !== false)
                {
                    AddEventToStatFile('catalog', 'conductDocument', 'success', $docType['DOC_TYPE']);
                }
 
                return $result;
            }
 
            $APPLICATION->ThrowException(Loc::getMessage('CAT_DOC_STATUS_ALREADY_YES'));
        }
 
        return false;
    }

    public static function cancellationDocument($documentId, $userId = 0)
    {
        global $APPLICATION;
 
        if (!Catalog\Config\State::isUsedInventoryManagement())
        {
            $APPLICATION->ThrowException(
                GetMessage('CAT_DOC_CONDUCT_UNCONDUCT_NOT_AVAILABLE'),
                self::STORE_CONTROL_DISABLED_CONDUCT_ERROR
            );
 
            return false;
        }
 
        if (Catalog\Store\EnableWizard\Manager::isOnecMode())
        {
            $APPLICATION->ThrowException(Loc::getMessage('CAT_DOC_CONDUCT_UNCONDUCT_NOT_AVAILABLE_EXTERNAL_CATALOG'));
 
            return false;
        }
 
        $result = false;
        $documentId = (int)$documentId;
        $userId = (int)$userId;
        $docType = null;
        $dbDocType = CCatalogDocs::getList(
            array(),
            array("ID" => $documentId),
            false,
            false,
            array('ID', 'DOC_TYPE', 'STATUS')
        );
        if($arDocType = $dbDocType->Fetch())
        {
            $docType = $arDocType["DOC_TYPE"];
            if($arDocType["STATUS"] !== "Y")
            {
                $GLOBALS["APPLICATION"]->ThrowException(GetMessage("CAT_DOC_ERROR_CANCEL_STATUS"));
                return false;
            }
            $documentClass = self::$types[$arDocType["DOC_TYPE"]];
 
            $result = $documentClass::cancellationDocument($documentId, $userId);
            if($result !== false)
            {
                $arDocFields = [
                    'STATUS' => 'N',
                    'WAS_CANCELLED' => 'Y',
                ];
 
                if ($userId > 0)
                {
                    $arDocFields["STATUS_BY"] = $userId;
                }
                if (!self::update($documentId, $arDocFields))
                {
                    return false;
                }
            }
        }
 
        if ($result !== false)
        {
            AddEventToStatFile('catalog', 'cancelDocument', 'success', $docType);
        }
 
        return $result;
    }
 
    public static function OnIBlockElementDelete($productID)
    {
        global $DB;
        $productID = (int)$productID;
        if($productID > 0)
        {
            $dbDeleteElements = CCatalogStoreDocsElement::getList(array(), array("ELEMENT_ID" => $productID), false, false, array('ID'));
            while($arDeleteElements = $dbDeleteElements->fetch())
            {
                CCatalogStoreDocsElement::delete($arDeleteElements["ID"]);
            }
            return $DB->Query("delete from b_catalog_store_barcode where PRODUCT_ID = ".$productID, true);
        }
        return true;
    }
 
    public static function OnCatalogStoreDelete($storeID)
    {
        global $DB;
        $storeID = (int)$storeID;
        if ($storeID <= 0)
            return false;
 
        return $DB->Query("delete from b_catalog_store_barcode where STORE_ID = ".$storeID, true);
    }
 
    public static function OnBeforeIBlockElementDelete($productID)
    {
        global $APPLICATION;
 
        $productID = (int)$productID;
        if ($productID > 0 && \Bitrix\Catalog\Config\State::isUsedInventoryManagement())
        {
            $iterator = Catalog\StoreDocumentElementTable::getList([
                'select' => [
                    'ELEMENT_ID',
                    'ELEMENT_NAME' => 'ELEMENT.NAME',
                ],
                'filter' => [
                    '=ELEMENT_ID' => $productID,
                ],
                'limit' => 1,
            ]);
            $row = $iterator->fetch();
            unset($iterator);
            if (!empty($row))
            {
                $APPLICATION->ThrowException(GetMessage(
                    'CAT_DOC_ERROR_ELEMENT_IN_DOCUMENT_EXISTS',
                    [
                        '#ID#' => $row['ELEMENT_ID'],
                        '#NAME#' => $row['ELEMENT_NAME'],
                    ]
                ));
 
                return false;
            }
        }
 
        return true;
    }
 
    public static function synchronizeStockQuantity($storeId, $iblockId = 0)
    {
        $storeId = (int)$storeId;
        if ($storeId <= 0)
        {
            return false;
        }
        $iblockId = (int)$iblockId;
 
        $connection = Application::getConnection();
        $helper = $connection->getSqlHelper();
 
        $internalSql = 'select CP.QUANTITY + ' . $helper->getIsNullFunction('CP.QUANTITY_RESERVED', 0) . ', CP.ID, '.$storeId.' ';
        if ($iblockId <= 0)
        {
            $internalSql .= 'from b_catalog_product CP where 1 = 1';
        }
        else
        {
            $internalSql .= 'from b_catalog_product CP inner join b_iblock_element IE on (CP.ID = IE.ID) where IE.IBLOCK_ID = '.$iblockId;
        }
 
        return $connection->query(
            "insert into b_catalog_store_product (AMOUNT, PRODUCT_ID, STORE_ID) (".$internalSql.")"
        );
    }
}