saveorderaction.php

<?php
namespace Bitrix\Sale\Controller\Action\Entity;
 
use Bitrix\Main;
use Bitrix\Sale;
use Bitrix\Crm;
use Bitrix\Crm\Order\Manager;
 
final class SaveOrderAction extends Sale\Controller\Action\BaseAction
{
    private ?int $compilationDealId;
 
    public function run(array $fields)
    {
        $checkFieldsResult = $this->checkFields($fields);
        if (!$checkFieldsResult->isSuccess())
        {
            $this->addErrors($checkFieldsResult->getErrors());
            return null;
        }
 
        $saveOrderResult = $this->saveOrder($fields);
        if ($saveOrderResult->isSuccess())
        {
            $saveOrderData = $saveOrderResult->getData();
 
            $order = $saveOrderData['ORDER'];
 
            $user = $saveOrderData['USER'];
 
            return array_merge(
                Sale\Helpers\Controller\Action\Entity\Order::getAggregateOrder($order),
                [
                    'USER' => $user,
                    'HASH' => $order->getHash(),
                ]
            );
        }
 
        $this->addErrors($saveOrderResult->getErrors());
        return null;
    }
 
    private function saveOrder(array $fields)
    {
        $result = new Sale\Result();
 
        $resultData = [];
 
        $prepareOrderResult = $this->prepareOrder($fields);
        if ($prepareOrderResult->isSuccess())
        {
            $getOrderData = $prepareOrderResult->getData();
 
            $order = $getOrderData['order'];
 
            $setUserResult = $this->setUser($order, $fields);
            if ($setUserResult->isSuccess())
            {
                $resultData['USER'] = $setUserResult->getData();
            }
            else
            {
                $this->fillErrorCollection(
                    $result,
                    $setUserResult->getErrors(),
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_SET_USER
                );
                return $result;
            }
 
            $userProfileData = $fields['USER_PROFILE'] ?? null;
            $setProfileResult = $this->setProfile($order, $userProfileData);
            if (!$setProfileResult->isSuccess())
            {
                $this->fillErrorCollection(
                    $result,
                    $setProfileResult->getErrors(),
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_SET_PROFILE
                );
                return $result;
            }
 
            $doFinalActionsResult = $this->doFinalActions($order);
            if (!$doFinalActionsResult->isSuccess())
            {
                $this->fillErrorCollection(
                    $result,
                    $doFinalActionsResult->getErrors(),
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_FINAL_ACTIONS
                );
                return $result;
            }
 
            $saveResult = $order->save();
            if (!$saveResult->isSuccess())
            {
                $this->fillErrorCollection(
                    $result,
                    $saveResult->getErrors(),
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_SAVE
                );
                return $result;
            }
 
            if (
                Main\Loader::includeModule('crm')
                && class_exists(Crm\Integration\CompilationManager::class)
            )
            {
                if (isset($this->compilationDealId))
                {
                    Manager::copyOrderProductsToDeal($order, $this->compilationDealId);
                }
 
                Crm\Integration\CompilationManager::sendOrderBoundEvent($order);
                Crm\Integration\CompilationManager::sendToCompilationDealTimeline($order);
            }
 
            $resultData['ORDER'] = $order;
            $result->setData($resultData);
        }
        else
        {
            $result->addErrors($prepareOrderResult->getErrors());
        }
 
        return $result;
    }
 
    private function checkFields(array $fields): Sale\Result
    {
        $result = new Sale\Result();
 
        if (empty($fields['SITE_ID']))
        {
            $result->addError(
                new Main\Error(
                    'siteId not found',
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_SITE_ID_NOT_FOUND
                )
            );
        }
 
        if (empty($fields['FUSER_ID']) || (int)$fields['FUSER_ID'] <= 0)
        {
            $result->addError(
                new Main\Error(
                    'fuserId not found',
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_FUSER_ID_NOT_FOUND
                )
            );
        }
 
        if (empty($fields['PERSON_TYPE_ID']))
        {
            $result->addError(
                new Main\Error(
                    'personTypeId not found',
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_PERSON_TYPE_ID_NOT_FOUND
                )
            );
        }
 
        return $result;
    }
 
    private function prepareOrder(array $fields): Sale\Result
    {
        $result = new Sale\Result();
 
        $order = $this->createOrder($fields['SITE_ID']);
 
        $personTypeId = (int)$fields['PERSON_TYPE_ID'];
        $setPersonTypeIdResult = $this->setPersonTypeId($order, $personTypeId);
        if (!$setPersonTypeIdResult->isSuccess())
        {
            $this->fillErrorCollection(
                $result,
                $setPersonTypeIdResult->getErrors(),
                Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_SET_PERSON_TYPE_ID
            );
            return $result;
        }
 
        if (!empty($fields['TRADING_PLATFORM_ID']))
        {
            $tradingPlatformId = $fields['TRADING_PLATFORM_ID'];
            $setTradeBindingResult = $this->setTradeBinding($order, $tradingPlatformId);
            if (!$setTradeBindingResult->isSuccess())
            {
                $this->fillErrorCollection(
                    $result,
                    $setTradeBindingResult->getErrors(),
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_SET_TRADE_BINDINGS
                );
                return $result;
            }
        }
 
        $properties = $fields['PROPERTIES'] ?? null;
        if ($properties)
        {
            $setPropertiesResult = $this->setProperties($order, $properties);
            if (!$setPropertiesResult->isSuccess())
            {
                $this->fillErrorCollection(
                    $result,
                    $setPropertiesResult->getErrors(),
                    Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_SET_PROPERTIES
                );
                return $result;
            }
        }
 
        $setBasketResult = $this->setBasket($order, $fields['FUSER_ID']);
        if (!$setBasketResult->isSuccess())
        {
            $this->fillErrorCollection(
                $result,
                $setBasketResult->getErrors(),
                Sale\Controller\ErrorEnumeration::SAVE_ORDER_ACTION_SET_BASKET
            );
            return $result;
        }
 
        if (
            Main\Loader::includeModule('crm')
            && class_exists(Crm\Integration\CompilationManager::class)
        )
        {
            $this->compilationDealId = Crm\Integration\CompilationManager::processOrderForCompilation($order);
        }
 
        $result->setData(['order' => $order]);
        return $result;
    }
 
    private function createOrder(string $siteId): Sale\Order
    {
        $registry = Sale\Registry::getInstance(Sale\Registry::REGISTRY_TYPE_ORDER);
        $orderClassName = $registry->getOrderClassName();
 
        return $orderClassName::create($siteId);
    }
 
    private function setPersonTypeId(Sale\Order $order, int $personTypeId): Sale\Result
    {
        $result = new Sale\Result();
 
        $setPersonTypeIdResult = $order->setPersonTypeId($personTypeId);
        if (!$setPersonTypeIdResult->isSuccess())
        {
            $result->addErrors($setPersonTypeIdResult->getErrors());
        }
 
        return $result;
    }
 
    private function setProperties(Sale\Order $order, array $properties): Sale\Result
    {
        $result = new Sale\Result();
 
        $propertyCollection = $order->getPropertyCollection();
        $setValuesResult = $propertyCollection->setValuesFromPost(['PROPERTIES' => $properties], []);
        if (!$setValuesResult->isSuccess())
        {
            foreach ($setValuesResult->getErrors() as $error)
            {
                $result->addError(new Main\Error($error->getMessage()));
            }
        }
 
        foreach ($propertyCollection as $propValue)
        {
            if ($propValue->isUtil())
            {
                continue;
            }
 
            $verifyResult = $propValue->verify();
            if (!$verifyResult->isSuccess())
            {
                foreach ($verifyResult->getErrors() as $error)
                {
                    $result->addError(
                        new Main\Error($error->getMessage(), 0, ['id' => $propValue->getPropertyId()])
                    );
                }
            }
 
            $checkRequiredValueResult = $propValue->checkRequiredValue($propValue->getPropertyId(), $propValue->getValue());
            if (!$checkRequiredValueResult->isSuccess())
            {
                foreach ($checkRequiredValueResult->getErrors() as $error)
                {
                    $result->addError(
                        new Main\Error($error->getMessage(), 0, ['id' => $propValue->getPropertyId()])
                    );
                }
            }
        }
 
        return $result;
    }
 
    private function setBasket(Sale\Order $order, int $fuserId): Sale\Result
    {
        $result = new Sale\Result();
 
        $registry = Sale\Registry::getInstance(Sale\Registry::REGISTRY_TYPE_ORDER);
 
        $basketClassName = $registry->getBasketClassName();
        $basket = $basketClassName::loadItemsForFUser($fuserId, $order->getSiteId());
 
        $refreshResult = $basket->refresh();
        if ($refreshResult->isSuccess())
        {
            $saveBasketResult = $basket->save();
            if (!$saveBasketResult->isSuccess())
            {
                $result->addErrors($refreshResult->getErrors());
            }
        }
        else
        {
            $result->addErrors($refreshResult->getErrors());
        }
 
        if (!$result->isSuccess(true))
        {
            return $result;
        }
 
        $availableBasket = $basket->getOrderableItems();
        if ($availableBasket && !$availableBasket->isEmpty())
        {
            $setBasketResult = $order->setBasket($availableBasket);
            if (!$setBasketResult->isSuccess())
            {
                $result->addErrors($setBasketResult->getErrors());
            }
        }
        elseif ($availableBasket)
        {
            $result->addError(new Main\Error('basket is empty'));
        }
        else
        {
            $result->addError(new Main\Error('basket is null'));
        }
 
        return $result;
    }
 
    private function setUser(Sale\Order $order, array $fields): Sale\Result
    {
        $result = new Sale\Result();
 
        $isNewUser = false;
 
        if ((int)$fields['USER_ID'] > 0)
        {
            $userId = (int)$fields['USER_ID'];
 
            if ($this->isLandingShop($order) && Main\Loader::includeModule('crm'))
            {
                Crm\Service\Sale\Order\BuyerService::getInstance()->attachUserToBuyers($userId);
            }
        }
        else
        {
            $properties = [];
 
            foreach ($order->getPropertyCollection() as $property)
            {
                $properties[$property->getPropertyId()] = $property->getValue();
            }
 
            $userProps = Sale\Property::getMeaningfulValues($order->getPersonTypeId(), $properties);
 
            $email = $userProps['EMAIL'] ?? '';
            $phone = $userProps['PHONE'] ?? '';
 
            $userId = $this->searchExistingUser($email, $phone);
            if (!$userId)
            {
                $registerNewUserResult = $this->registerNewUser($order, $userProps);
                if ($registerNewUserResult->isSuccess())
                {
                    $registerNewUserData = $registerNewUserResult->getData();
                    $userId = $registerNewUserData['userId'];
 
                    $isNewUser = true;
                }
                else
                {
                    $result->addErrors($registerNewUserResult->getErrors());
                    return $result;
                }
            }
        }
 
        if (!$userId)
        {
            $result->addError(new Main\Error('User not found'));
            return $result;
        }
 
        $order->setFieldNoDemand('USER_ID', $userId);
 
        $result->setData([
            'ID' => $userId,
            'IS_NEW' => $isNewUser,
        ]);
 
        return $result;
    }
 
    private function searchExistingUser(string $email, string $phone): ?int
    {
        $existingUserId = null;
 
        if (!empty($email))
        {
            $res = Main\UserTable::getRow([
                'filter' => [
                    '=ACTIVE' => 'Y',
                    '=EMAIL' => $email,
                ],
                'select' => ['ID'],
            ]);
            if (isset($res['ID']))
            {
                $existingUserId = (int)$res['ID'];
            }
        }
 
        if (!$existingUserId && !empty($phone))
        {
            $normalizedPhone = NormalizePhone($phone);
            $normalizedPhoneForRegistration = Main\UserPhoneAuthTable::normalizePhoneNumber($phone);
 
            if (!empty($normalizedPhone))
            {
                $res = Main\UserTable::getRow([
                    'filter' => [
                        'ACTIVE' => 'Y',
                        [
                            'LOGIC' => 'OR',
                            '=PHONE_AUTH.PHONE_NUMBER' => $normalizedPhoneForRegistration,
                            '=PERSONAL_PHONE' => $normalizedPhone,
                            '=PERSONAL_MOBILE' => $normalizedPhone,
                        ],
                    ],
                    'select' => ['ID'],
                ]);
                if (isset($res['ID']))
                {
                    $existingUserId = (int)$res['ID'];
                }
            }
        }
 
        return $existingUserId;
    }
 
    private function registerNewUser(Sale\Order $order, array $userProps): Sale\Result
    {
        $result = new Sale\Result();
 
        $siteId = $order->getSiteId();
 
        $userData = $this->generateUserData($userProps);
        $fields = [
            'LOGIN' => $userData['NEW_LOGIN'],
            'NAME' => $userData['NEW_NAME'],
            'LAST_NAME' => $userData['NEW_LAST_NAME'],
            'PASSWORD' => $userData['NEW_PASSWORD'],
            'CONFIRM_PASSWORD' => $userData['NEW_PASSWORD_CONFIRM'],
            'EMAIL' => $userData['NEW_EMAIL'],
            'GROUP_ID' => $userData['GROUP_ID'],
            'ACTIVE' => 'Y',
            'LID' => $siteId,
            'PERSONAL_PHONE' => isset($userProps['PHONE']) ? NormalizePhone($userProps['PHONE']) : '',
            'PERSONAL_ZIP' => $userProps['ZIP'] ?? '',
            'PERSONAL_STREET' => $userProps['ADDRESS'] ?? '',
        ];
 
        $userPhoneAuth = Main\Config\Option::get('main', 'new_user_phone_auth', 'N', $siteId) === 'Y';
        if ($userPhoneAuth)
        {
            $normalizedPhoneForRegistration = '';
            if (!empty($userProps['PHONE']))
            {
                $normalizedPhoneForRegistration = Main\UserPhoneAuthTable::normalizePhoneNumber($userProps['PHONE']);
            }
 
            $fields['PHONE_NUMBER'] = $normalizedPhoneForRegistration;
        }
 
        if ($this->isLandingShop($order) && Main\Loader::includeModule('crm'))
        {
            $fields['GROUP_ID'] = Crm\Order\BuyerGroup::getDefaultGroups();
            $fields['EXTERNAL_AUTH_ID'] = 'shop';
            $fields['UF_DEPARTMENT'] = [];
            if (!empty($userData['NEW_EMAIL']))
            {
                $fields['LOGIN'] = $userData['NEW_EMAIL'];
            }
        }
 
        $user = new \CUser();
        $addResult = $user->Add($fields);
        if ((int)$addResult <= 0)
        {
            $errors = explode('<br>', $user->LAST_ERROR);
            TrimArr($errors, true);
            foreach ($errors as $error)
            {
                $result->addError(new Main\Error($error));
            }
        }
        else
        {
            $result->setData(['userId' => $addResult]);
        }
 
        return $result;
    }
 
    private function generateUserData(array $userProps = []): array
    {
        $userEmail = isset($userProps['EMAIL']) ? trim((string)$userProps['EMAIL']) : '';
        $newLogin = $userEmail;
 
        if (empty($userEmail))
        {
            $newEmail = false;
 
            $normalizedPhone = NormalizePhone($userProps['PHONE']);
            if (!empty($normalizedPhone))
            {
                $newLogin = $normalizedPhone;
            }
        }
        else
        {
            $newEmail = $userEmail;
        }
 
        if (empty($newLogin))
        {
            $newLogin = Main\Security\Random::getString(5).random_int(0, 99999);
        }
 
        $pos = mb_strpos($newLogin, '@');
        if ($pos !== false)
        {
            $newLogin = mb_substr($newLogin, 0, $pos);
        }
 
        if (mb_strlen($newLogin) > 47)
        {
            $newLogin = mb_substr($newLogin, 0, 47);
        }
 
        $newLogin = str_pad($newLogin, 3, '_');
 
        $dbUserLogin = \CUser::GetByLogin($newLogin);
        if ($userLoginResult = $dbUserLogin->Fetch())
        {
            do
            {
                $newLoginTmp = $newLogin.random_int(0, 99999);
                $dbUserLogin = \CUser::GetByLogin($newLoginTmp);
            }
            while ($userLoginResult = $dbUserLogin->Fetch());
 
            $newLogin = $newLoginTmp;
        }
 
        $newName = '';
        $newLastName = '';
 
        $payerName = isset($userProps['PAYER']) ? trim((string)$userProps['PAYER']) : '';
        if (!empty($payerName))
        {
            $payerName = preg_replace('/\s{2,}/', ' ', $payerName);
            $nameParts = explode(' ', $payerName);
            if (isset($nameParts[1]))
            {
                $newName = $nameParts[1];
                $newLastName = $nameParts[0];
            }
            else
            {
                $newName = $nameParts[0];
            }
        }
 
        $groupIds = [];
 
        $defaultGroups = Main\Config\Option::get('main', 'new_user_registration_def_group', '');
        if (!empty($defaultGroups))
        {
            $groupIds = explode(',', $defaultGroups);
        }
 
        $newPassword = \CUser::GeneratePasswordByPolicy($groupIds);
 
        return [
            'NEW_EMAIL' => $newEmail,
            'NEW_LOGIN' => $newLogin,
            'NEW_NAME' => $newName,
            'NEW_LAST_NAME' => $newLastName,
            'NEW_PASSWORD' => $newPassword,
            'NEW_PASSWORD_CONFIRM' => $newPassword,
            'GROUP_ID' => $groupIds,
        ];
    }
 
    private function doFinalActions(Sale\Order $order): Sale\Result
    {
        $result = new Sale\Result();
 
        $hasMeaningfulFields = $order->hasMeaningfulField();
        $doFinalActionResult = $order->doFinalAction($hasMeaningfulFields);
 
        if (!$doFinalActionResult->isSuccess())
        {
            $result->addErrors($doFinalActionResult->getErrors());
        }
 
        return $result;
    }
 
    private function setTradeBinding(Sale\Order $order, $tradingPlatformId): Sale\Result
    {
        $result = new Sale\Result();
 
        $platform = Sale\TradingPlatform\Manager::getList([
            'select' => ['ID'],
            'filter' => [
                '=ID' => $tradingPlatformId,
            ],
        ])->fetch();
        if ($platform)
        {
            $collection = $order->getTradeBindingCollection();
 
            $binding = $collection->createItem();
            $setFieldResult = $binding->setFields([
                'TRADING_PLATFORM_ID' => $tradingPlatformId,
            ]);
 
            if (!$setFieldResult->isSuccess())
            {
                $result->addErrors($setFieldResult->getErrors());
            }
        }
        else
        {
            $result->addError(
                new Main\Error('Trading platform with id:"'.$tradingPlatformId.' not found"')
            );
        }
 
        return $result;
    }
 
    private function setProfile(Sale\Order $order, array $profileFields = null): Sale\Result
    {
        $result = new Sale\Result();
 
        $profileId = $profileFields['ID'] ?? 0;
        $profileName = $profileFields['NAME'] ?? '';
 
        $properties = [];
        foreach ($order->getPropertyCollection() as $property)
        {
            $properties[$property->getPropertyId()] = $property->getValue();
        }
 
        $errors = [];
        \CSaleOrderUserProps::DoSaveUserProfile(
            $order->getUserId(),
            $profileId,
            $profileName,
            $order->getPersonTypeId(),
            $properties,
            $errors
        );
 
        foreach ($errors as $error)
        {
            $result->addError(new Main\Error($error['TEXT']));
        }
 
        return $result;
    }
 
    private function isLandingShop(Sale\Order $order): bool
    {
        foreach ($order->getTradeBindingCollection() as $tradingItem)
        {
            $platformId = $tradingItem->getField('TRADING_PLATFORM_ID');
            $platform = Sale\TradingPlatform\Manager::getObjectById($platformId);
            if ($platform instanceof Sale\TradingPlatform\Landing\Landing)
            {
                return true;
            }
        }
 
        return false;
    }
 
    private function fillErrorCollection(Sale\Result $result, array $errors, $code): void
    {
        foreach ($errors as $error)
        {
            $result->addError(new Main\Error($error->getMessage(), $code, $error->getCustomData()));
        }
    }
}