custom/plugins/ProcLiveOrderHistory/src/Subscriber/LiveOrderHistorySubscriber.php line 112

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Proc\ProcLiveOrderHistory\Subscriber;
  5. use Proc\ProcFoundation\Helper\ErrorHandler;
  6. use Proc\ProcFoundation\Helper\RequestHandler;
  7. use Proc\ProcFoundation\Service\ProcFoundationService;
  8. use Proc\ProcLiveOrderHistory\Helper\OrderHistoryStruct;
  9. use Proc\ProcLiveOrderHistory\Helper\BuildRequestHelper;
  11. use Shopware\Storefront\Page\Account\Order\AccountOrderPageLoadedEvent;
  12. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  14. use DateTime;
  15. use Exception;
  17. /**
  18.  * Class LiveOrderHistorySubscriber
  19.  * @package Proc\ProcLiveOrderHistory\Subscriber
  20.  */
  21. class LiveOrderHistorySubscriber implements EventSubscriberInterface
  22. {
  23.     private const PATH_HEADLIST = '/iman/order-history-headlist';
  24.     private const PATH_DETAILS = '/iman/order-history-details';
  25.     /**
  26.      * @todo
  27.      * Richtig muss es '/iman/order-history-document' heißen. Dies muss aber noch im iMan angepasst werden.
  28.      */
  29.     private const PATH_DOCUMENTS = '/iman/order-history-documents';
  30. //     private const PATH_DOCUMENTS = '/iman/order-history-document';
  32.     /**
  33.      * @var RequestHandler
  34.      */
  35.     private $requestHandler;
  37.     /**
  38.      * @var ErrorHandler
  39.      */
  40.     private $errorHandler;
  42.     /**
  43.      * @var string
  44.      */
  45.     private $host,
  46.             $port,
  47.             $customerNumber,
  48.             $fromDate,
  49.             $toDate;
  51.     private $error = null;
  53.     /**
  54.      * @var ProcFoundationService
  55.      */
  56.     private $foundationService;
  58.     /**
  59.      * @var AccountOrderPageLoadedEvent
  60.      */
  61.     private $event;
  63.     /**
  64.      * @var int
  65.      */
  66.     private $elementsPerPage,
  67.             $page;
  69.     /**
  70.      * @inheritDoc
  71.      */
  72.     public static function getSubscribedEvents()
  73.     {
  74.         return [
  75.             AccountOrderPageLoadedEvent::class => ['onAccountOrderPageLoaded' ,1]
  76.         ];
  77.     }
  80.     /**
  81.      * LiveOrderHistorySubscriber constructor.
  82.      * @param ProcFoundationService $foundationService
  83.      * @param RequestHandler $requestHandler
  84.      * @param ErrorHandler $errorHandler
  85.      * @throws Exception
  86.      */
  87.     public function __construct(ProcFoundationService $foundationService, RequestHandler $requestHandler, ErrorHandler $errorHandler)
  88.     {
  89.         $this->foundationService = $foundationService;
  90.         $this->requestHandler = $requestHandler;
  91.         $this->errorHandler = $errorHandler;
  92.     }
  94.     /**
  95.      * @param AccountOrderPageLoadedEvent $event
  96.      */
  97.     public function onAccountOrderPageLoaded(AccountOrderPageLoadedEvent $event)
  98.     {
  99.         $this->event = $event;
  100.         /**
  101.          * Prüfung ob Benutzer angemeldet ist, sonst keine Live-Abfrage.
  102.          */
  103.         if (!($this->checkLogin()) || !($this->checkConfig()))
  104.         {
  105.             $orderNotComplete['fromDate'] = (new DateTime())->format('Y-m-d');
  106.             $orderNotComplete['toDate'] = (new DateTime())->format('Y-m-d');
  107.             $orderNotComplete['numElements'] = 0;
  108.             $orderNotComplete['order-history-list'] = '';
  110.             $orderNotCompleteStruct = new OrderHistoryStruct();
  111.             $orderNotCompleteStruct->setOrderHistory($orderNotComplete);
  112.             $this->event->getPage()->addExtension('order_history', $orderNotCompleteStruct);
  113.             return;
  114.         }
  116.         $this->handleOrderHistory();
  117.     }
  119.     private function checkLogin()
  120.     {
  121.         $this->customerNumber = $this->foundationService->checkLogin($this->event->getSalesChannelContext(), (string)get_class($this));
  122.         if (!($this->customerNumber)) return false;
  123.         return true;
  124.     }
  126.     /**
  127.      * Hauptfunktion welche das einlesen der OrderHistory primär steuert.
  128.      * Die OrderHistory wird anhand vorhandener Daten eingelesen. Wird kein Datum ermittelt werden alle Order von 1.1.2021 bis zum aktuellen Datum vom iMan geholt.
  129.      * Standard Anzahl der Elemente pro Seite ist bei 10, kann aber über das Menü der OrderHistory auch anders ausgewählt werden.
  130.      */
  131.     public function handleOrderHistory()
  132.     {
  134.         $request = $this->event->getRequest();
  136.         if ($request->getQueryString() == '') {
  137.             $orderNotComplete['fromDate'] = (new DateTime())->format('Y-m-d');
  138.             $orderNotComplete['toDate'] = (new DateTime())->format('Y-m-d');
  139.             $orderNotComplete['numElements'] = 0;
  140.             $orderNotComplete['order-history-list'] = '';
  142.             $orderNotCompleteStruct = new OrderHistoryStruct();
  143.             $orderNotCompleteStruct->setOrderHistory($orderNotComplete);
  144.             $this->event->getPage()->addExtension('order_history', $orderNotCompleteStruct);
  145.             return;
  146.         }
  148.         $fromDate           = $request->get('fromDate');
  149.         $toDate             = $request->get('toDate');
  150.         $this->elementsPerPage    = (int)$request->get('numElements');
  151.         $this->page               = (int)$request->get('page');
  153.         $orderHistory = $this->getOrderHistory($fromDate, $toDate);
  155.         if ($orderHistory['head']['status'] === 'NOK') {
  156.             $this->error = $this->errorHandler->error($this->errorHandler::SAP_RESPONSE_ERROR, get_class($this), 'SAP Status Fehler.' . print_r($orderHistory, true));
  157.             $this->errorHandler->writeErrorLog($this->error);
  158.             $orderNotComplete['fromDate'] = $request->get('fromDate');
  159.             $orderNotComplete['toDate'] = $request->get('toDate');
  160.             $orderNotComplete['numElements'] = 0;
  161.             $orderNotComplete['order-history-list'] = '';
  163.             $orderNotCompleteStruct = new OrderHistoryStruct();
  164.             $orderNotCompleteStruct->setOrderHistory($orderNotComplete);
  165.             $this->event->getPage()->addExtension('order_history', $orderNotCompleteStruct);
  166.         } else {
  168.             $orderHistory = $this->formatOrderHistory($orderHistory);
  169.             $pageOrders = $this->getOrdersPerPage($orderHistory);
  170.             $orderComplete = $this->getOrderDetails($pageOrders);
  172.             // $numElements = count($orderComplete['order-history-list']['order']);
  173.             $numElements = $this->elementsPerPage;
  174.             $orderComplete['numElements'] = $numElements;
  176.             if (null !== $qs = $this->event->getRequest()->getQueryString()) {
  177.                 $qs = '?'.$qs;
  178.             }
  179.             $orderComplete['baseUri'] = $this->event->getSalesChannelContext()->getSalesChannel()->getDomains()->first()->getUrl() .$this->event->getRequest()->getPathInfo().$qs;
  180.             $orderComplete['fromDate'] = $this->fromDate;
  181.             $orderComplete['toDate'] = $this->toDate;
  183.             $orderCompleteStruct = new OrderHistoryStruct();
  184.             $orderCompleteStruct->setOrderHistory($orderComplete);
  185.             $this->event->getPage()->addExtension('order_history', $orderCompleteStruct);
  186.         }
  187.     }
  189.     /**
  190.      * Nimm die Liste der OrderHistory-Elemente für die Zeit von-bis, wie beim Aufruf der getOrderHistory definiert
  191.      * schneidet" die Elemente für die gewünschte Seite aus und gibt das gekürzte Array zurück.
  192.      * @param $orderHistory
  193.      * @return array
  194.      */
  195.     protected function getOrdersPerPage($orderHistory) : array
  196.     {
  197.         $numElements = count($orderHistory['order-history-list']['order']);
  199.         if ($this->page === '' || $this->elementsPerPage === '' || $this->elementsPerPage === null) {
  200.             $this->page = 1;
  201.             $this->elementsPerPage = 10;
  202.         }
  204.         if ($numElements <= $this->elementsPerPage) {
  205.             return $orderHistory;
  206.         }
  208.         $start = ($this->page - 1) * $this->elementsPerPage;
  209.         $end = ($this->page * $this->elementsPerPage) - 1;
  211.         $resultArray['head'] = $orderHistory['head'];
  212.         $resultArray['order-history-list']['order'] = array_slice($orderHistory['order-history-list']['order'], $start, $this->elementsPerPage);
  213.         $resultArray['numPages'] = (int)ceil($numElements / $this->elementsPerPage);
  215.         return $resultArray;
  216.     }
  218.     /**
  219.      * Liest die OrderHistory aus und die hinterlegten Dokumente
  220.      * füllte das Basis-Array mit diesen Daten und gibt das angereicherte Array zurück.
  221.      * @param array $iterationArray
  222.      * @param int $shopInstance
  223.      * @param string $language
  224.      * @return array
  225.      */
  226.     protected function getOrderDetails(array $iterationArray, int $shopInstance = 1, string $language = 'DE') : array
  227.     {
  228.         foreach ($iterationArray['order-history-list']['order'] as $key => $orderElement)
  229.         {
  231.             $params = [
  232.                 'shop-instance' => $shopInstance,
  233.                 'sap-order-id'  => $orderElement['sap-order-id'],
  234.                 'language'      => $language
  235.             ];
  237.             $buildRequestHelper = new BuildRequestHelper($params, 'details', $this->errorHandler);
  239.             /**
  240.              * @var string $request
  241.              */
  242.             $request = $this->requestHandler->buildRequest($buildRequestHelper, (string)get_class($this));
  244.             if ($request !== '') {
  245.                 /**
  246.                  * @var string $detailResult
  247.                  */
  248.                 $detailResult = $this->requestHandler->sendRequest($this->host, $this->port, self::PATH_DETAILS, $request);
  249.             } else {
  250.                 $this->error = $this->errorHandler->error($this->errorHandler::UNKNOWN_REQUEST, get_class($this), 'Fehler im Aufbau des Request');
  251.                 $this->errorHandler->writeErrorLog($this->error);
  252.                 continue;
  253.             }
  255.             $detailArray = RequestHandler::parseResult($detailResult);
  257.             if ($detailArray['head']['status'] === 'NOK' || count($detailArray) === 0) {
  258.                 continue;
  259.             }
  261.             /**
  262.              * Holen der Dokumente zu den einzelnen Orders
  263.              * @todo Deaktiviert, da SAP noch keine Dokumente liefern kann. Muss noch getestet werden, sobald SAP Dokumente liefern kan.
  264.              */
  265.             if (array_key_exists('sap-order-id', $detailArray['document-list']['document'])) {
  266.                 $detailIterationArray['head'] = $detailArray['head'];
  267.                 $detailIterationArray['document-list']['document'][0] = $detailArray['document-list']['document'];
  268.             } else {
  269.                 $detailIterationArray = $detailArray;
  270.             }
  271.             /**
  272.              * @todo Die Foreach war für  um nur Rechunungen heraus zu filtern. Hier sollte es konfigurierbar gemacht werden.
  273.              */
  274.             foreach ($detailIterationArray['document-list']['document'] as $key2 => $documentElement)
  275.             {
  276.                 if (($documentElement['document-type-code'] != 'M') && ($documentElement['document-type-code'] != 'C'))
  277.                 {
  278.                     unset($detailIterationArray['document-list']['document'][$key2]);
  279.                 }
  280.             }
  282. //             $detailCompleteArray = $this->getOrderDocuments($detailIterationArray);
  284.             $iterationArray['order-history-list']['order'][$key]['document-list'] = $detailIterationArray['document-list'];
  286.             $iterationArray['order-history-list']['order'][$key]['head'] = $detailArray['head'];
  288.             if ($iterationArray['order-history-list']['order'][$key]['customer-order-id'] === []) {
  289.                 $iterationArray['order-history-list']['order'][$key]['customer-order-id'] = 'keine Kunden-Bestellnummer';
  290.             }
  291.         }
  293.         return $iterationArray;
  294.     }
  296.     /**
  297.      * Liest die OrderDetails aus und die hinterlegten Dokumente
  298.      * füllte das Details-Array mit den Dokumenten und gibt das angereicherte Array zurück.
  299.      * @param array $detailsArray
  300.      * @param int$shopInstance
  301.      * @return array
  302.      * @todo In Controller auslagern, um die document.php im Plugin zu halten
  303.      */
  304.     public function getOrderDocuments(array $detailsArray, int $shopInstance = 1)
  305.     {
  306.         foreach ($detailsArray['document-list']['document'] as $key => $documentElement)
  307.         {
  308.             /**
  309.              * @todo
  310.              * Hier muss noch wegen der Dokumententypen angepasst werden.
  311.              */
  312. //             if ($documentElement['document-type-code'] == 'M') {
  313.             if (true) {
  314.                 $params = [
  315.                     'shop-instance' => $shopInstance,
  316.                     'customer' => $this->customerNumber,
  317.                     'document-number' => $documentElement['document-number'],
  318.                     'document-type-code' => $documentElement['document-type-code']
  319.                 ];
  321.                 $buildRequestHelper = new BuildRequestHelper($params, 'documents', $this->errorHandler);
  323.                 /**
  324.                  * @var string $request
  325.                  */
  326.                 $request = $this->requestHandler->buildRequest($buildRequestHelper, (string)get_class($this));
  328.                 if ($request !== '') {
  329.                     /**
  330.                      * @var string $documentResult
  331.                      */
  332.                     $documentResult = $this->requestHandler->sendRequest($this->host, $this->port, self::PATH_DOCUMENTS, $request);
  333.                 } else {
  334.                     $this->error = $this->errorHandler->error($this->errorHandler::UNKNOWN_REQUEST, get_class($this), 'Fehler im Aufbau des Request');
  335.                     $this->errorHandler->writeErrorLog($this->error);
  336.                     continue;
  337.                 }
  339.                 $documentArray = RequestHandler::parseResult($documentResult);
  341.                 if ($documentArray['head']['status'] === 'NOK' || count($documentArray) === 0) {
  342.                     continue;
  343.                 }
  345.                 if (array_key_exists('data', $documentArray['head'])) {
  346.                     $documentIterationArray['data'] = $documentArray['head']['data'];
  347.                 } else {
  348.                     $documentIterationArray['data'] = $documentArray['head']['status'];
  349.                 }
  351.                 $detailsArray['document-list']['document'][$key]['document-data'] = $documentIterationArray['data'];
  352.             /**
  353.              * @todo Hier werden alle nicht Rechnungen entfernt. Muss raus genommen werden, wenn andere Dokumente gehen
  354.              */
  355.             } else {
  356.                 unset($detailsArray['document-list']['document'][$key]);
  357.             }
  358.         }
  360.         return $detailsArray;
  361.     }
  364.     /**
  365.      * Bereitet mit dem Requesthandler die Request auf und holt die Daten vom iMan
  366.      *
  367.      * @param string|null $fromDate
  368.      * @param string|null $toDate
  369.      * @param int $shopInstance
  370.      * @param string $language
  371.      * @return array
  372.      */
  373.     protected function getOrderHistory(string $fromDate = null,
  374.                                        string $toDate = null,
  375.                                        int $shopInstance = 1,
  376.                                        string $language = 'DE') : array
  377.     {
  379.         if ($fromDate !== null && $toDate !== null) {
  380.             $this->checkDateRange($fromDate, $toDate);
  381.         }
  383.         if ($fromDate === null) {
  384.             $fromDate = '2021-01-01';
  385.         }
  387.         if ($toDate === null) {
  388.             $toDate = (new DateTime())->format('Y-m-d');
  389.         }
  391.         $this->fromDate = $fromDate;
  392.         $this->toDate = $toDate;
  394.         $params = [
  395.             'shop-instance' => $shopInstance,
  396.             'customer'      => $this->customerNumber,
  397.             'date-from'     => $this->fromDate,
  398.             'date-to'       => $this->toDate,
  399.             'language'      => $language
  400.         ];
  403.         $buildRequestHelper = new BuildRequestHelper($params, 'headlist', $this->errorHandler);
  405.         /**
  406.          * @var string $request
  407.          */
  408.         $request = $this->requestHandler->buildRequest($buildRequestHelper, (string)get_class($this));
  410.         if ($request !== '') {
  411.             /**
  412.              * @var string $result
  413.              */
  414.             $result = $this->requestHandler->sendRequest($this->host, $this->port, self::PATH_HEADLIST, $request);
  415.             $this->error = $this->errorHandler->error($this->errorHandler::UNKNOWN_REQUEST, get_class($this), 'Result: ' . print_r($this->result, true));
  416.             $this->errorHandler->writeErrorLog($this->error);
  417.         } else {
  418.             /**
  419.              * @todo Fehlerbehandlung
  420.              */
  421.             Return array();
  422.         }
  423.         return $this->requestHandler->parseResult($result);
  424.     }
  426.     /**
  427.      * Prüft die übergebenen Daten auf ihren Wert und bei vertauschte Angabe werden diese ausgewechselt.
  428.      *
  429.      * @param string|null $fromDate
  430.      * @param string|null $toDate
  431.      */
  432.     protected function checkDateRange(string &$fromDate, string &$toDate) : void
  433.     {
  434.         try {
  435.             $startDate = new DateTime($fromDate);
  436.             $endDate = new DateTime($toDate);
  437.         } catch (Exception $e) {
  438.             $this->error = $this->errorHandler->error($this->errorHandler::GENERAL_ERROR, get_class($this), 'Eine Datumsangabe entspricht nicht dem vorgegeben Format. - ' . $e->getCode() . ' - ' . $e->getMessage());
  439.             $this->errorHandler->writeErrorLog($this->error);
  440.             $fromDate = '';
  441.             $toDate = '';
  442.         }
  444.         if ($endDate < $startDate)
  445.         {
  446.             $fromDate   = $endDate->format('Y-m-d');
  447.             $toDate     = $startDate->format('Y-m-d');
  448.         }
  449.     }
  451.     /**
  452.      * Array des Response wird in ein einheitliches Format gebracht zur Vereinfachung der weiteren Handhabung
  453.      * @param array $orderHistory
  454.      * @return array
  455.      */
  456.     protected function formatOrderHistory(array $orderHistory) : array
  457.     {
  458.         if (array_key_exists('sap-order-id', $orderHistory['order-history-list']['order'])) {
  459.             $iterationArray['head'] = $orderHistory['head'];
  460.             $iterationArray['order-history-list']['order'][0] = $orderHistory['order-history-list']['order'];
  461.         } else {
  462.             $iterationArray = $orderHistory;
  463.         }
  464.         if (empty($iterationArray['head']['customer']) || is_array($iterationArray['head']['customer'])) {
  465.             $iterationArray['head']['customer'] = $this->customerNumber;
  466.         }
  468.         return $iterationArray;
  469.     }
  471.     /**
  472.      * @return bool
  473.      */
  474.     private function checkConfig() : bool
  475.     {
  476.         if ($this->foundationService->getConfigStatus()) {
  477.             $this->host = $this->foundationService->getHost();
  478.             $this->port = $this->foundationService->getPort();
  479.             return true;
  480.         }
  481.         $this->error = $this->errorHandler->error($this->errorHandler::CONFIG_NOT_VALID, get_class($this), 'Konnte die Konfiguration nicht ermitteln');
  482.         $this->errorHandler->writeErrorLog($this->error);
  483.         return false;
  484.     }
  485. }