vendor/store.shopware.com/viob2bworkflow/src/VioB2BWorkflow.php line 38

Open in your IDE?
  1. <?php
  2. declare(strict_types=1);
  4. namespace Vio\B2BWorkflow;
  6. use Doctrine\DBAL\Exception\ForeignKeyConstraintViolationException;
  7. use RuntimeException;
  8. use Shopware\Core\Checkout\Order\OrderDefinition;
  9. use Shopware\Core\Checkout\Order\OrderStates as ShopwareOrderStates;
  10. use Shopware\Core\Checkout\Order\Aggregate\OrderTransaction\OrderTransactionStates as ShopwareOrderTransactionStates;
  11. use Shopware\Core\Defaults;
  12. use Shopware\Core\Framework\Context;
  13. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  14. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  17. use Shopware\Core\Framework\Plugin;
  18. use Shopware\Core\Framework\Plugin\Context\DeactivateContext;
  19. use Shopware\Core\Framework\Plugin\Context\InstallContext;
  20. use Shopware\Core\Framework\Plugin\Context\UninstallContext;
  21. use Shopware\Core\Framework\Plugin\Context\UpdateContext;
  22. use Shopware\Core\System\CustomField\CustomFieldTypes;
  23. use Shopware\Core\System\Language\LanguageDefinition;
  24. use Shopware\Core\System\Language\LanguageEntity;
  25. use Shopware\Core\System\StateMachine\Aggregation\StateMachineState\StateMachineStateDefinition;
  26. use Shopware\Core\System\StateMachine\Aggregation\StateMachineState\StateMachineStateEntity;
  27. use Shopware\Core\System\StateMachine\Aggregation\StateMachineTransition\StateMachineTransitionDefinition;
  28. use Shopware\Core\System\StateMachine\StateMachineDefinition;
  29. use Shopware\Core\System\StateMachine\StateMachineEntity;
  30. use VioB2BLogin\Entity\Employee\EmployeeDefinition;
  31. use VioB2BLogin\VioB2BLogin;
  32. use Vio\B2BWorkflow\Core\Checkout\Order\OrderStates;
  33. use Vio\B2BWorkflow\Core\Checkout\Order\OrderTransactionStates;
  34. use Vio\B2BWorkflow\Core\DataAbstractionLayer\Search\Filter\ArrayKeyMultiOrFilter;
  35. use Vio\B2BWorkflow\Core\DataAbstractionLayer\Search\Filter\StateMachineFilter;
  36. use Vio\B2BWorkflow\Core\System\StateMachine\Aggregation\StateMachineTransition\StateMachineTransitionActions;
  38. class VioB2BWorkflow extends Plugin
  39. {
  40.     public const APPROVAL_EMPLOYEE_FIELD = 'vio_b2b_approval_employee';
  42.     private string $enId;
  43.     private string $deId;
  45.     /**
  46.      * @param Context $context
  47.      * @param StateMachineEntity $stateMachine
  48.      * @param bool $withoutTranslations
  49.      * @return array[]
  50.      */
  51.     protected function getStates(Context $context, StateMachineEntity $stateMachine, bool $withoutTranslations = false): array
  52.     {
  53.         $translations = $this->getStateTranslations($context);
  54.         $states = [
  55.             ShopwareOrderStates::STATE_MACHINE => [
  56.                 [
  57.                     'technicalName' => OrderStates::STATE_APPROVAL_REQUESTED,
  58.                     'stateMachineId' => $stateMachine->getId(),
  59.                     'translations' => $translations[OrderStates::STATE_APPROVAL_REQUESTED]
  60.                 ],
  61.                 [
  62.                     'technicalName' => OrderStates::STATE_APPROVAL_REFUSED,
  63.                     'stateMachineId' => $stateMachine->getId(),
  64.                     'translations' => $translations[OrderStates::STATE_APPROVAL_REFUSED]
  65.                 ]
  66.             ],
  67.             ShopwareOrderTransactionStates::STATE_MACHINE => [
  68.                 [
  69.                     'technicalName' => OrderTransactionStates::STATE_PRESET,
  70.                     'stateMachineId' => $stateMachine->getId(),
  71.                     'translations' => $translations[OrderTransactionStates::STATE_PRESET]
  72.                 ]
  73.             ]
  74.         ];
  76.         $return = $states[$stateMachine->getTechnicalName()];
  77.         if ($withoutTranslations) {
  78.             $return = array_map(static function (array $stateArray) {
  79.                 return [
  80.                     'technicalName' => $stateArray['technicalName'],
  81.                     'stateMachineId' => $stateArray['stateMachineId']
  82.                 ];
  83.             }, $return);
  84.         }
  85.         return $return;
  86.     }
  88.     /**
  89.      * @param Context $context
  90.      * @return array
  91.      */
  92.     protected function getStateTranslations(Context $context): array
  93.     {
  94.         $defaultLangId = Defaults::LANGUAGE_SYSTEM;
  95.         $deDE = $this->getDeDeLanguageId($context);
  96.         $enGB = $this->getEnGbLanguageId($context);
  97.         $translations = [];
  98.         $translations[OrderStates::STATE_APPROVAL_REQUESTED] = [
  99.             $deDE => ['name' => 'Freigabe beantragt'],
  100.             $enGB => ['name' => 'Approval requested']
  101.         ];
  102.         $translations[OrderStates::STATE_APPROVAL_REFUSED] = [
  103.             $deDE => ['name' => 'Freigabe abgelehnt'],
  104.             $enGB => ['name' => 'Approval refused']
  105.         ];
  106.         $translations[OrderTransactionStates::STATE_PRESET] = [
  107.             $deDE => ['name' => 'Voreingestellt'],
  108.             $enGB => ['name' => 'Preset']
  109.         ];
  110.         if ($defaultLangId !== $deDE) {
  111.             $translations[OrderStates::STATE_APPROVAL_REQUESTED][$defaultLangId] = ['name' => 'Approval requested'];
  112.             $translations[OrderStates::STATE_APPROVAL_REFUSED][$defaultLangId] = ['name' => 'Approval refused'];
  113.             $translations[OrderTransactionStates::STATE_PRESET][$defaultLangId] = ['name' => 'Preset'];
  114.         }
  115.         return $translations;
  116.     }
  118.     /**
  119.      * @param StateMachineEntity $stateMachine
  120.      * @param string[] $states
  121.      * @return array[]
  122.      */
  123.     private function getTransitions(StateMachineEntity $stateMachine, array $states = []): array
  124.     {
  125.         $transitions = [
  126.             ShopwareOrderStates::STATE_MACHINE => [
  127.                 [
  128.                     'actionName' => StateMachineTransitionActions::ACTION_REFUSE,
  129.                     'stateMachineId' => $stateMachine->getId(),
  130.                     'fromStateId' => array_key_exists(OrderStates::STATE_APPROVAL_REQUESTED, $states) ? $states[OrderStates::STATE_APPROVAL_REQUESTED] : '',
  131.                     'toStateId' => array_key_exists(OrderStates::STATE_APPROVAL_REFUSED, $states) ? $states[OrderStates::STATE_APPROVAL_REFUSED] : '',
  132.                 ],
  133.                 [
  134.                     'actionName' => StateMachineTransitionActions::ACTION_ACCEPT,
  135.                     'stateMachineId' => $stateMachine->getId(),
  136.                     'fromStateId' => array_key_exists(OrderStates::STATE_APPROVAL_REQUESTED, $states) ? $states[OrderStates::STATE_APPROVAL_REQUESTED] : '',
  137.                     'toStateId' => array_key_exists(ShopwareOrderStates::STATE_OPEN, $states) ? $states[ShopwareOrderStates::STATE_OPEN] : '',
  138.                 ],
  139.                 [
  140.                     'actionName' => StateMachineTransitionActions::ACTION_RESTORE,
  141.                     'stateMachineId' => $stateMachine->getId(),
  142.                     'fromStateId' => array_key_exists(OrderStates::STATE_APPROVAL_REFUSED, $states) ? $states[OrderStates::STATE_APPROVAL_REFUSED] : '',
  143.                     'toStateId' => array_key_exists(OrderStates::STATE_APPROVAL_REQUESTED, $states) ? $states[OrderStates::STATE_APPROVAL_REQUESTED] : '',
  144.                 ]
  145.             ],
  146.             ShopwareOrderTransactionStates::STATE_MACHINE => [
  147.                 [
  148.                     'actionName' => StateMachineTransitionActions::ACTION_ACCEPT,
  149.                     'stateMachineId' => $stateMachine->getId(),
  150.                     'fromStateId' => array_key_exists(OrderTransactionStates::STATE_PRESET, $states) ? $states[OrderTransactionStates::STATE_PRESET] : '',
  151.                     'toStateId' => array_key_exists(ShopwareOrderTransactionStates::STATE_OPEN, $states) ? $states[ShopwareOrderTransactionStates::STATE_OPEN] : '',
  152.                 ]
  153.             ],
  155.         ];
  156.         $return = $transitions[$stateMachine->getTechnicalName()];
  157.         if (empty($states)) {
  158.             $return = array_map(static function (array $transitionArray) {
  159.                 return [
  160.                     'actionName' => $transitionArray['actionName'],
  161.                     'stateMachineId' => $transitionArray['stateMachineId']
  162.                 ];
  163.             }, $return);
  164.         }
  165.         return $return;
  166.     }
  168.     #region setup
  170.     public function install(InstallContext $installContext): void
  171.     {
  172.         parent::install($installContext);
  173.         $this->installOrUpdateStates($installContext->getContext());
  174.         $this->updateCustomFields($installContext->getContext());
  175.     }
  177.     public function update(UpdateContext $updateContext): void
  178.     {
  179.         parent::update($updateContext);
  180.         $this->installOrUpdateStates($updateContext->getContext());
  181.         $this->updateCustomFields($updateContext->getContext());
  182.     }
  184.     public function deactivate(DeactivateContext $deactivateContext): void
  185.     {
  186.         $this->removeCustomFields($deactivateContext->getContext());
  187.         parent::deactivate($deactivateContext);
  188.     }
  190.     public function uninstall(UninstallContext $uninstallContext): void
  191.     {
  192.         if (!$uninstallContext->keepUserData()) {
  193.             $this->uninstallStates($uninstallContext->getContext());
  194.         }
  195.         parent::uninstall($uninstallContext);
  196.     }
  198.     #endregion
  200.     #region setup-helper
  202.     public function getDeDeLanguageId(Context $context): string
  203.     {
  204.         if (empty($this->deId)) {
  205.             /** @var EntityRepositoryInterface $repository */
  206.             $repository = $this->container->get(LanguageDefinition::ENTITY_NAME . '.repository');
  208.             $criteria = new Criteria();
  209.             $criteria->addFilter(new EqualsFilter(LanguageDefinition::ENTITY_NAME . '.translationCode.code', 'de-DE'));
  211.             /** @var LanguageEntity $language */
  212.             $language = $repository->search($criteria, $context)->first();
  213.             $this->deId = $language->getId();
  214.         }
  215.         return $this->deId;
  216.     }
  218.     public function getEnGbLanguageId(Context $context): string
  219.     {
  220.         if (empty($this->enId)) {
  221.             /** @var EntityRepositoryInterface $repository */
  222.             $repository = $this->container->get(LanguageDefinition::ENTITY_NAME . '.repository');
  224.             $criteria = new Criteria();
  225.             $criteria->addFilter(new EqualsFilter(LanguageDefinition::ENTITY_NAME . '.translationCode.code', 'en-GB'));
  227.             /** @var LanguageEntity $language */
  228.             $language = $repository->search($criteria, $context)->first();
  230.             $this->enId = $language->getId();
  231.         }
  232.         return $this->enId;
  233.     }
  235.     /**
  236.      * @param Context $context
  237.      */
  238.     private function installOrUpdateStates(Context $context): void
  239.     {
  240.         // find order state machine
  241.         /** @var EntityRepository $stateMachineRepo */
  242.         $stateMachineRepo = $this->container->get(StateMachineDefinition::ENTITY_NAME . '.repository');
  243.         $criteria = (new Criteria())
  244.             ->addFilter(new EqualsFilter('technicalName', ShopwareOrderStates::STATE_MACHINE));
  245.         $stateMachinesResult = $stateMachineRepo->search($criteria, $context);
  246.         if ($stateMachinesResult->getTotal() === 1) {
  247.             $stateMachine = $stateMachinesResult->first();
  248.             $this->insertOrUpdateStateForStateMachine($stateMachine, $context);
  250.         }
  252.         // find order transaction state machine
  253.         $criteria = (new Criteria())
  254.             ->addFilter(new EqualsFilter('technicalName', ShopwareOrderTransactionStates::STATE_MACHINE));
  255.         $stateMachinesResult = $stateMachineRepo->search($criteria, $context);
  256.         if ($stateMachinesResult->getTotal() === 1) {
  257.             $stateMachine = $stateMachinesResult->first();
  258.             $this->insertOrUpdateStateForStateMachine($stateMachine, $context);
  260.         }
  261.     }
  263.     /**
  264.      * @param Context $context
  265.      */
  266.     private function uninstallStates(Context $context): void
  267.     {
  268. // find order state machine
  269.         /** @var EntityRepository $stateMachineRepo */
  270.         $stateMachineRepo = $this->container->get(StateMachineDefinition::ENTITY_NAME . '.repository');
  272.         $criteria = (new Criteria())
  273.             ->addFilter(new EqualsFilter('technicalName', ShopwareOrderStates::STATE_MACHINE));
  274.         $stateMachinesResult = $stateMachineRepo->search($criteria, $context);
  275.         if ($stateMachinesResult->getTotal() === 1) {
  276.             /** @var StateMachineEntity $stateMachine */
  277.             $stateMachine = $stateMachinesResult->first();
  279.             $this->uninstallStatesByStateMachine($stateMachine, $context);
  280.         }
  281.     }
  283.     /**
  284.      * @param array $states
  285.      * @param StateMachineEntity $stateMachine
  286.      * @param Context $context
  287.      * @return void
  288.      */
  289.     private function createTransitions(array $states, StateMachineEntity $stateMachine, Context $context): void
  290.     {
  291.         /** @var EntityRepository $transitionRepository */
  292.         $transitionRepository = $this->container->get(StateMachineTransitionDefinition::ENTITY_NAME . '.repository');
  293.         $transitions = $this->getTransitions($stateMachine, $states);
  295.         $transitions = array_values($this->validateTransitionsBeforeInsert($transitions, $stateMachine, $context));
  297.         $transitionRepository->upsert($transitions, $context);
  298.     }
  300.     /**
  301.      * @param StateMachineEntity $stateMachine
  302.      * @param Context $context
  303.      * @return void
  304.      */
  305.     private function deleteTransitions(StateMachineEntity $stateMachine, Context $context): void
  306.     {
  307.         /** @var EntityRepository $transitionRepository */
  308.         $transitionRepository = $this->container->get(StateMachineTransitionDefinition::ENTITY_NAME . '.repository');
  309.         $transitions = $this->getTransitions($stateMachine);
  311.         $criteria = new Criteria();
  312.         $criteria->addFilter(new StateMachineFilter($stateMachine, $transitions, 'actionName'));
  313.         $result = $transitionRepository->searchIds($criteria, $context);
  314.         $delete = array_values(array_map(static function ($id) {
  315.             return ['id' => $id];
  316.         }, $result->getIds()));
  318.         if (count($delete) > 0) {
  319.             $transitionRepository->delete($delete, $context);
  320.         }
  321.     }
  323.     /**
  324.      * @param array $upsertStates
  325.      * @param StateMachineEntity $stateMachine
  326.      * @param Context $context
  327.      * @return array
  328.      */
  329.     private function validateStatesBeforeInsert(array $upsertStates, StateMachineEntity $stateMachine, Context $context): array
  330.     {
  331.         $criteria = new Criteria();
  332.         $criteria->addFilter(new StateMachineFilter($stateMachine, $upsertStates, 'technicalName'));
  333.         /** @var EntityRepository $repository */
  334.         $repository = $this->container->get(StateMachineStateDefinition::ENTITY_NAME . '.repository');
  335.         $result = $repository->search($criteria, $context);
  336.         return array_filter($upsertStates, static function (array $state) use ($result) {
  337.             return $result->filterByProperty('technicalName', $state['technicalName'])->count() === 0;
  338.         });
  340.     }
  342.     /**
  343.      * @param array $transitions
  344.      * @param StateMachineEntity $stateMachine
  345.      * @param Context $context
  346.      * @return array
  347.      */
  348.     private function validateTransitionsBeforeInsert(array $transitions, StateMachineEntity $stateMachine, Context $context): array
  349.     {
  350.         $criteria = new Criteria();
  351.         $criteria->addFilter(new StateMachineFilter($stateMachine, $transitions, 'actionName'));
  352.         /** @var EntityRepository $repository */
  353.         $repository = $this->container->get(StateMachineTransitionDefinition::ENTITY_NAME . '.repository');
  354.         $result = $repository->search($criteria, $context);
  355.         return array_filter($transitions, static function (array $state) use ($result) {
  356.             return $result->filterByProperty('actionName', $state['actionName'])->count() === 0;
  357.         });
  358.     }
  360.     #endregion
  362.     /**
  363.      * @param StateMachineEntity $stateMachine
  364.      * @param Context $context
  365.      */
  366.     private function insertOrUpdateStateForStateMachine(StateMachineEntity $stateMachine, Context $context): void
  367.     {
  368.         /** @var EntityRepository $repository */
  369.         $repository = $this->container->get(StateMachineStateDefinition::ENTITY_NAME . '.repository');
  371.         $statesToUpsert = $this->getStates($context, $stateMachine);
  373.         $upsertStates = array_values($this->validateStatesBeforeInsert($statesToUpsert, $stateMachine, $context));
  375.         $repository->upsert($upsertStates, $context);
  377.         $states = [];
  378.         $filter = new ArrayKeyMultiOrFilter($statesToUpsert, 'technicalName');
  379.         $filter->addQuery(new EqualsFilter('technicalName', ShopwareOrderStates::STATE_OPEN));
  380.         $criteria = (new Criteria())
  381.             ->addFilter(new EqualsFilter('stateMachineId', $stateMachine->getId()))
  382.             ->addFilter($filter);
  383.         $statesResult = $repository->search($criteria, $context);
  384.         if ($statesResult->getTotal() > 0) {
  385.             /** @var StateMachineStateEntity $state */
  386.             foreach ($statesResult->getElements() as $state) {
  387.                 $states[$state->getTechnicalName()] = $state->getId();
  388.             }
  389.         }
  390.         $this->createTransitions($states, $stateMachine, $context);
  391.     }
  393.     /**
  394.      * @param StateMachineEntity $stateMachine
  395.      * @param Context $context
  396.      */
  397.     private function uninstallStatesByStateMachine(StateMachineEntity $stateMachine, Context $context): void
  398.     {
  399.         $this->deleteTransitions($stateMachine, $context);
  401.         /** @var EntityRepository $repository */
  402.         $repository = $this->container->get(StateMachineStateDefinition::ENTITY_NAME . '.repository');
  404.         $deleteStates = $this->getStates($context, $stateMachine, true);
  406.         $criteria = new Criteria();
  407.         $criteria->addFilter(new StateMachineFilter($stateMachine, $deleteStates, 'technicalName'));
  408.         $result = $repository->searchIds($criteria, $context);
  409.         $delete = [];
  410.         // check every state if it is used in an order
  411.         foreach ($result->getIds() as $stateId) {
  412.             $criteria = new Criteria();
  413.             $criteria->addFilter(new EqualsFilter('stateId', $stateId));
  415.             /** @var EntityRepository $orderRepository */
  416.             $orderRepository = $this->container->get(OrderDefinition::ENTITY_NAME . '.repository');
  417.             $orderResult = $orderRepository->searchIds($criteria, $context);
  418.             if ($orderResult->getTotal() === 0) {
  419.                 $delete[] = ['id' => $stateId];
  420.             }
  421.         }
  423.         if (count($delete) > 0) {
  424.             $repository->delete(
  425.                 $delete,
  426.                 $context
  427.             );
  428.         }
  429.     }
  431.     /**
  432.      * @param Context $context
  433.      */
  434.     private function updateCustomFields(Context $context): void
  435.     {
  436.         $customFieldSetRepository = $this->container->get('custom_field_set.repository');
  437.         if (!$customFieldSetRepository) {
  438.             throw new RuntimeException("Couldn't resolve service 'custom_field_set.repository'");
  439.         }
  440.         $fieldSetName = VioB2BLogin::CUSTOM_FIELDSET_NAME;
  441.         $fieldSetId = $customFieldSetRepository->searchIds((new Criteria())->addFilter(new EqualsFilter('name', $fieldSetName)), $context)->firstId();
  442.         if ($fieldSetId !== null) {
  443.             $this->updateCustomField(
  444.                 $fieldSetId,
  445.                 static::APPROVAL_EMPLOYEE_FIELD,
  446.                 [
  447.                     'name' => static::APPROVAL_EMPLOYEE_FIELD,
  448.                     'type' => CustomFieldTypes::ENTITY,
  449.                     'config' => [
  450.                         'label' => [
  451.                             'de-DE' => 'Freigebender Mitarbeiter',
  452.                             'en-GB' => 'Approval employee'
  453.                         ],
  454.                         'entity' => EmployeeDefinition::ENTITY_NAME,
  455.                         'componentName' => 'sw-entity-single-select',
  456.                         'labelProperty' => ['firstName', 'lastName']
  457.                     ],
  458.                 ],
  459.                 $context
  460.             );
  461.         }
  462.     }
  464.     /**
  465.      * @param string $fieldSetId
  466.      * @param string $fieldName
  467.      * @param array $fieldData
  468.      * @param Context $context
  469.      * @noinspection PhpSameParameterValueInspection
  470.      */
  471.     private function updateCustomField(string $fieldSetId, string $fieldName, array $fieldData, Context $context): void
  472.     {
  473.         $customFieldRepository = $this->container->get('custom_field.repository');
  474.         if (!$customFieldRepository) {
  475.             throw new RuntimeException("Couldn't resolve service 'custom_field.repository'");
  476.         }
  477.         if (!array_key_exists('name', $fieldData)) {
  478.             $fieldData['name'] = $fieldName;
  479.         }
  480.         if (!array_key_exists('customFieldSetId', $fieldData)) {
  481.             $fieldData['customFieldSetId'] = $fieldSetId;
  482.         }
  483.         $fieldId = $customFieldRepository->searchIds(
  484.             (new Criteria())->addFilter(
  485.                 new EqualsFilter('name', $fieldName),
  486.                 new EqualsFilter('customFieldSetId', $fieldSetId)
  487.             ), $context)
  488.             ->firstId();
  489.         if ($fieldId !== null) {
  490.             $fieldData['id'] = $fieldId;
  491.         }
  492.         $customFieldRepository->upsert([$fieldData], $context);
  493.     }
  495.     private function removeCustomFields(Context $context): void
  496.     {
  497.         $customFieldSetRepository = $this->container->get('custom_field_set.repository');
  498.         if (!$customFieldSetRepository) {
  499.             throw new RuntimeException("Couldn't resolve service 'custom_field_set.repository'");
  500.         }
  501.         $fieldSetName = VioB2BLogin::CUSTOM_FIELDSET_NAME;
  502.         $fieldSetId = $customFieldSetRepository->searchIds((new Criteria())->addFilter(new EqualsFilter('name', $fieldSetName)), $context)->firstId();
  503.         if ($fieldSetId !== null) {
  504.             $customFieldRepository = $this->container->get('custom_field.repository');
  505.             if (!$customFieldRepository) {
  506.                 throw new RuntimeException("Couldn't resolve service 'custom_field_set.repository'");
  507.             }
  508.             $fieldId = $customFieldRepository->searchIds(
  509.                 (new Criteria())->addFilter(
  510.                     new EqualsFilter('name', static::APPROVAL_EMPLOYEE_FIELD),
  511.                     new EqualsFilter('customFieldSetId', $fieldSetId)
  512.                 ), $context)
  513.                 ->firstId();
  514.             if ($fieldId) {
  515.                 $customFieldRepository->delete([
  516.                     [
  517.                         'id' => $fieldId
  518.                     ]
  519.                 ], $context);
  520.             }
  521.         }
  522.     }
  523. }