src/Controller/IikoOrderController.php line 134

Open in your IDE?
  1. <?php
  2. namespace Slivki\Controller;
  3. use Doctrine\DBAL\Connection;
  4. use Doctrine\Persistence\ManagerRegistry;
  5. use libphonenumber\PhoneNumberUtil;
  6. use Slivki\BusinessFeature\VirtualWallet\Service\VirtualWalletChecker;
  7. use Slivki\Dao\FastDelivery\OfferFastDeliveryDaoInterface;
  8. use Slivki\Dao\Offer\DeliveryZoneDaoInterface;
  9. use Slivki\Dao\Order\OfferOrderPurchaseCountDaoInterface;
  10. use Slivki\Entity\City;
  11. use Slivki\Entity\Director;
  12. use Slivki\Entity\EntityOption;
  13. use Slivki\Entity\FoodOfferExtension;
  14. use Slivki\Entity\FoodOfferOptionExtension;
  15. use Slivki\Entity\FoodOrder;
  16. use Slivki\Entity\GeoLocation;
  17. use Slivki\Entity\Media\OfferExtensionMedia;
  18. use Slivki\Entity\Offer;
  19. use Slivki\Entity\OfferExtension;
  20. use Slivki\Entity\OfferExtensionOnlineCategory;
  21. use Slivki\Entity\OfferExtensionVariant;
  22. use Slivki\Entity\OfferOrder;
  23. use Slivki\Entity\OfferOrderDetails;
  24. use Slivki\Entity\OnlineOrderHistory;
  25. use Slivki\Entity\PriceDeliveryType;
  26. use Slivki\Entity\Seo;
  27. use Slivki\Entity\Street;
  28. use Slivki\Entity\UserAddress;
  29. use Slivki\Entity\UserBalanceActivity;
  30. use Slivki\Entity\Visit;
  31. use Slivki\Enum\OfferCode\PurchaseCountPeriod;
  32. use Slivki\Enum\Order\PaymentType;
  33. use Slivki\Exception\Offer\OfferExtension\Visibility\OfferExtensionNotVisibleException;
  34. use Slivki\Exception\Order\InsufficientBalanceFundsException;
  35. use Slivki\Handler\Order\OnlineOrderHistoryHandler;
  36. use Slivki\Helpers\PhoneNumberHelper;
  37. use Slivki\Helpers\WeightParserHelper;
  38. use Slivki\Repository\Delivery\FoodFilterCounterRepositoryInterface;
  39. use Slivki\Repository\Director\DirectorRepositoryInterface;
  40. use Slivki\Repository\Offer\DeliveryZoneRepositoryInterface;
  41. use Slivki\Repository\Offer\FoodOfferExtensionRepositoryInterface;
  42. use Slivki\Repository\PurchaseCount\PurchaseCountRepositoryInterface;
  43. use Slivki\Repository\SeoRepository;
  44. use Slivki\Repository\StreetRepository;
  45. use Slivki\Repository\User\CreditCardRepositoryInterface;
  46. use Slivki\Services\ImageService;
  47. use Slivki\Services\Mailer;
  48. use Slivki\Services\MapProviders\CoordinatesYandex;
  49. use Slivki\Services\Offer\CustomProductOfferSorter;
  50. use Slivki\Services\Offer\DeliveryZoneSorter;
  51. use Slivki\Services\Offer\OfferCacheService;
  52. use Slivki\Services\Offer\ProductFastDeliveryService;
  53. use Slivki\Services\OfferExtension\FoodByOnlineCategoriesBuilder;
  54. use Slivki\Services\OfferExtension\VisibilityFilterService;
  55. use Slivki\Services\Order\PricePromocodeForOnlineOrder;
  56. use Slivki\Services\PartnerBePaidService;
  57. use Slivki\Services\Payment\PaymentService;
  58. use Slivki\Services\Seo\SeoResourceService;
  59. use Slivki\Services\ShippingSchedulerService;
  60. use Slivki\Services\Subscription\SubscriptionService;
  61. use Slivki\Services\User\UnusedOfferCodeProviderInterface;
  62. use Slivki\Util\CommonUtil;
  63. use Slivki\Util\Iiko\AbstractDelivery;
  64. use Slivki\Util\Iiko\Dominos;
  65. use Slivki\Util\Iiko\IikoUtil;
  66. use Slivki\Util\Iiko\SushiChefArts;
  67. use Slivki\Util\Iiko\SushiHouse;
  68. use Slivki\Util\Iiko\SushiVesla;
  69. use Slivki\Util\Logger;
  70. use Symfony\Component\DependencyInjection\ContainerInterface;
  71. use Symfony\Component\HttpFoundation\JsonResponse;
  72. use Symfony\Component\HttpFoundation\Request;
  73. use Symfony\Component\HttpFoundation\Response;
  74. use Symfony\Component\Routing\Annotation\Route;
  75. use function array_search;
  76. use function array_unshift;
  77. use function array_column;
  78. use function array_map;
  79. use function array_filter;
  80. use function in_array;
  81. use function is_subclass_of;
  82. use function count;
  83. use function array_key_exists;
  84. use function array_merge;
  85. class IikoOrderController extends SiteController
  86. {
  87.     private const KILOGRAM 1000;
  88.     public const NEARLY 'Ближайшее';
  89.     /** @Route("/delivery/select/{offerID}", name = "deliveryOrder") */
  90.     public function indexAction(
  91.         Request $request,
  92.         ContainerInterface $container,
  93.         FoodFilterCounterRepositoryInterface $foodFilterCounterRepository,
  94.         SeoResourceService $seoResourceService,
  95.         SubscriptionService $subscriptionService,
  96.         PurchaseCountRepositoryInterface $purchaseCountRepository,
  97.         OfferCacheService $offerCacheService,
  98.         DirectorRepositoryInterface $directorRepository,
  99.         OfferFastDeliveryDaoInterface $offerFastDeliveryDao,
  100.         $offerID
  101.     ) {
  102.         $response = new Response();
  103.         $entityManager $this->getDoctrine()->getManager();
  104.         /** @var Offer|false $offerCached */
  105.         $offerCached $offerCacheService->getOffer($offerIDtruetrue);
  106.         if (false === $offerCached
  107.             || !$offerCached->hasFreeCodes()
  108.             || !($offerCached->isFoodOnlineOrderAllowedOnSite() || $offerCached->isAvailableOnFood())) {
  109.             if (299624 != $offerID) { //TODO: remove after bepaid approve
  110.                 return $this->redirect($seoResourceService->getOfferSeo($offerID)->getMainAlias());
  111.             }
  112.         }
  113.         $orderUtil AbstractDelivery::instance($offerCached);
  114.         $orderUtil->setContainer($container);
  115.         $isDominos $orderUtil instanceof Dominos;
  116.         $isSushiHouse $orderUtil instanceof SushiHouse;
  117.         $data['isDominos'] = $isDominos;
  118.         $data['showSortingIndexOrder'] = !($isSushiHouse || $isDominos);
  119.         $cityID $entityManager->getRepository(Offer::class)->getCityID($offerID);
  120.         $city $entityManager->find(City::class, $cityID);
  121.         $request->getSession()->set(City::CITY_ID_SESSION_KEY$city->getID());
  122.         $request->getSession()->set(City::CITY_DOMAIN_SESSION_KEY$city->getDomain());
  123.         $data['offer'] = $offerCached;
  124.         Logger::instance('IIKO-DEBUG')->info($offerID);
  125.         $director $directorRepository->getById((int) $offerCached->getDirectorID());
  126.         $data['company'] = $director;
  127.         $data['domain'] = $orderUtil->getDomain();
  128.         if (null !== $offerCached->getOnlineOrderSettings() && $offerCached->getOnlineOrderSettings()->getDomain()) {
  129.             $data['domain'] = $offerCached->getOnlineOrderSettings()->getDomain();
  130.         }
  131.         $data['dishes'] = [];
  132.         $user $this->getUser();
  133.         if (null !== $user) {
  134.             if ($subscriptionService->isSubscriber($user)) {
  135.                 $data['allowedCodesToBuy'] = $subscriptionService->getSubscription($user)->getNumberOfCodes();
  136.             } elseif ($user->isBatchCodesAllowed()) {
  137.                 $data['allowedCodesToBuyBatchCodes'] = $user->getBatchCodesCount();
  138.             }
  139.         }
  140.         $codeCost $this->getOfferRepository()->getCodeCost($offerCached);
  141.         $data['options'] = [];
  142.         $data['robotsMeta'] = 'noindex, follow';
  143.         $data['offerID'] = $offerID;
  144.         $data['director'] = $director;
  145.         $data['minSumForFreeDelivery'] = $orderUtil->getMinSumForFreeDelivery();
  146.         $data['minOrderSum'] = $orderUtil->getMinOrderSum();
  147.         $data['foodOffer'] = true;
  148.         $data['formAction'] = '/delivery/order/checkout';
  149.         $data['showDelivery'] = true;
  150.         $data['categoryName'] = $orderUtil::CATEGORY_NAME;
  151.         $data['footerOfferConditionID'] = $offerID;
  152.         $data['categoryURL'] = $entityManager->getRepository(Seo::class)->getSeoForEntity(SeoRepository::RESOURCE_URL_OFFER_CATEGORY$orderUtil::CATEGORY_ID)->getMainAlias();
  153.         $data['deliveryPrice'] = $orderUtil->getDeliveryPriceSettings();
  154.         $data['pickupEnabled'] = $orderUtil->isPickupEnabled();
  155.         $data['deliveryEnabled'] = $orderUtil->isDeliveryEnabled();
  156.         $data['isBuyCodeDisable'] = $offerCached->isBuyCodeDisable();
  157.         $data['isOnlineOrderAllowed'] = $offerCached->isFoodOnlineOrderAllowedOnSite();
  158.         $data['isAvailableOnFood'] = $offerCached->isAvailableOnFood();
  159.         $data['visitCount'] = $entityManager->getRepository(Visit::class)->getVisitCount($orderUtil::OFFER_IDVisit::TYPE_OFFER30true);
  160.         $data['filterAction'] = $foodFilterCounterRepository->findByOfferId((int) $offerID);
  161.         $purchaseCount $purchaseCountRepository->findByOfferId((int) $offerID);
  162.         $data['purchaseCountMonth'] = null === $purchaseCount $purchaseCount->getPurchaseCountLastMonthWithCorrection();
  163.         $data['sortList'] = CustomProductOfferSorter::SORT_LIST;
  164.         $data['codeCost'] = $codeCost;
  165.         if (!$offerFastDeliveryDao->isOfferHasActiveFastDelivery($offerID)) {
  166.             unset($data['sortList'][CustomProductOfferSorter::FAST_CUSTOM_PRODUCT_SORT]);
  167.         }
  168.         $view CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/order.html.twig' 'Slivki/delivery/order.html.twig';
  169.         $response->setContent($this->renderView($view$data));
  170.         return $response;
  171.     }
  172.     /** @Route("/delivery/order/checkout", name = "deliveryOrderCheckout") */
  173.     public function checkoutAction(
  174.         Request $request,
  175.         ShippingSchedulerService $shippingSchedulerService,
  176.         ContainerInterface $container,
  177.         ManagerRegistry $registry,
  178.         SeoResourceService $seoResourceService,
  179.         SubscriptionService $subscriptionService,
  180.         DeliveryZoneDaoInterface $deliveryZoneDao,
  181.         DeliveryZoneSorter $deliveryZoneSorter,
  182.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder
  183.     ) {
  184.         ini_set('memory_limit''1g');
  185.         $additionalDominos null;
  186.         $response = new Response();
  187.         $offerID $request->request->getInt('offerID');
  188.         $entityManager $this->getDoctrine()->getManager();
  189.         $requestBasket $request->request->get('basket');
  190.         $pickupDeliveryType = empty($request->request->get('pickupDeliveryType')) ? FoodOfferExtension::DELIVERY_METHOD $request->request->getInt('pickupDeliveryType');
  191.         if (!$requestBasket) {
  192.             return $this->redirectToRoute('deliveryOrder', ['offerID' => $offerID]);
  193.         }
  194.         $request->getSession()->set(OnlineOrderHistory::SORT_SESSION_NAME$request->request->get('dishSortBy'));
  195.         /** @var Offer $offer */
  196.         $offer $entityManager->find(Offer::class, $offerID);
  197.         $slivkiDeliveryOption $entityManager->getRepository(EntityOption::class)->findBy([
  198.             'entityID' => $offerID,
  199.             'name' => EntityOption::OPTION_SLIVKI_DELIVERY
  200.         ]);
  201.         if (!$offer->hasFreeCodes()) {
  202.             return $this->redirect($seoResourceService->getOfferSeo($offerID)->getMainAlias());
  203.         }
  204.         $iikoUtil AbstractDelivery::instance($offer);
  205.         $iikoUtil->setContainer($container);
  206.         $isSushiVesla $iikoUtil instanceof SushiVesla;
  207.         $isDominos $iikoUtil instanceof Dominos;
  208.         if ($isDominos) {
  209.             $dominosSpesialData = [
  210.                 'amountPizza' => 0,
  211.             ];
  212.         }
  213.         $requestBasket json_decode($requestBaskettrue);
  214.         $basket = [];
  215.         foreach ($requestBasket as $basketItem) {
  216.             $key array_key_first($basketItem);
  217.             $variants = [];
  218.             if (is_array($basketItem[$key])) {
  219.                 foreach ($basketItem[$key] as $variantItem) {
  220.                     $variantKey array_key_first($variantItem);
  221.                     $variants[$variantKey] = $variantItem[$variantKey];
  222.                 }
  223.             } else {
  224.                 $variants $basketItem[$key];
  225.             }
  226.             $basket[$key] = $variants;
  227.         }
  228.         $totalDishCount 0;
  229.         foreach ($basket as $dishID => $variants) {
  230.             $extension $entityManager->find(OfferExtension::class, $dishID);
  231.             if (!$extension || $extension instanceof FoodOfferOptionExtension) {
  232.                 continue;
  233.             }
  234.             $dishCount 0;
  235.             if (!is_array($variants)) {
  236.                 $dishCount $variants;
  237.             } else {
  238.                 foreach ($variants as $variantID => $variantCount) {
  239.                     $extensionVariant $entityManager->find(OfferExtensionVariant::class, $variantID);
  240.                     if (!$extensionVariant) {
  241.                         continue;
  242.                     }
  243.                     $dishCount += $variantCount;
  244.                     
  245.                     if ($isDominos) {
  246.                         $dominosSpesialData['amountPizza'] += $variantCount;
  247.                     }
  248.                 }
  249.             }
  250.             $totalDishCount += $dishCount;
  251.         }
  252.         
  253.         if ($isDominos && $dominosSpesialData['amountPizza'] === 0) {
  254.             return new JsonResponse(['status' => 'error''error' => true'message' => 'Скидка на доп. меню действует только при заказе пиццы']);
  255.         }
  256.         if ($totalDishCount == 0) {
  257.             return $this->redirectToRoute('deliveryOrder', ['offerID' => $offerID]);
  258.         }
  259.         $user $this->getUser();
  260.         /** @var OfferOrder $order */
  261.         $order = new FoodOrder();
  262.         $order->setUser($user);
  263.         $order->setStatus(FoodOrder::STATUS_INIT);
  264.         $order->setOffer($offer);
  265.         $totalAmount 0;
  266.         $totalOfferAmount 0;
  267.         $codesCount 0;
  268.         $city $entityManager->find(City::class, $iikoUtil::CITY_ID);
  269.         $request->getSession()->set(City::CITY_ID_SESSION_KEY$city->getID());
  270.         $request->getSession()->set(City::CITY_DOMAIN_SESSION_KEY$city->getDomain());
  271.         $offersDetails = [];
  272.         foreach ($basket as $dishID => $variants) {
  273.             /** @var OfferExtension $extension */
  274.             $extension $entityManager->find(OfferExtension::class, $dishID);
  275.             if (!$extension) {
  276.                 continue;
  277.             }
  278.             if (is_array($variants)) {
  279.                 foreach ($variants as $variantID => $variantCount) {
  280.                     /** @var OfferExtensionVariant $extensionVariant */
  281.                     $extensionVariant $entityManager->find(OfferExtensionVariant::class, $variantID);
  282.                     if (!$extensionVariant) {
  283.                         continue;
  284.                     }
  285.                     $productsPerCode $extension->getProductsPerCode();
  286.                     if ($productsPerCode 0) {
  287.                         $codesCount += $productsPerCode == $variantCount $variantCount/$productsPerCode;
  288.                     }
  289.                     $variantOfferPrice PriceDeliveryType::calcDeliveryPickupPrice(
  290.                         $extension,
  291.                         $pickupDeliveryType,
  292.                         $extensionVariant->getRegularPrice(),
  293.                         $extensionVariant->getOfferPrice(),
  294.                         $additionalDominos
  295.                     );
  296.                     $totalOfferAmount += $variantCount $variantOfferPrice;
  297.                     $totalAmount += $variantCount $extensionVariant->getRegularPrice();
  298.                     $details = new OfferOrderDetails();
  299.                     $details->setOfferExtension($extension);
  300.                     $details->setOfferExtensionVariant($extensionVariant);
  301.                     $details->setItemsCount($variantCount);
  302.                     $order->addOfferOrderDetails($details);
  303.                 }
  304.             } else {
  305.                 $count = (int) $variants;
  306.                 if (=== $count) {
  307.                     continue;
  308.                 }
  309.                 $product $isSushiVesla
  310.                     $iikoUtil->getProductByDB($extension->getPartnerItemID(), $registry)
  311.                     : $iikoUtil->getProduct($extension->getPartnerItemID());
  312.                 if ($product->regularPrice == 0) {
  313.                     $product->regularPrice $extension->getPrice();
  314.                 }
  315.                 $totalAmount += $count $product->regularPrice;
  316.                 $recalculatedOfferPriceValue PriceDeliveryType::calcDeliveryPickupPrice(
  317.                     $extension,
  318.                     $pickupDeliveryType,
  319.                     $product->regularPrice,
  320.                     $extension->getCurrentPrice(null$pickupDeliveryType),
  321.                 );
  322.                 $product->offerPrice $recalculatedOfferPriceValue;
  323.                 $totalOfferAmount += $count $product->offerPrice;
  324.                 if (!$extension instanceof FoodOfferOptionExtension) {
  325.                     $productsPerCode $extension->getProductsPerCode();
  326.                     if ($productsPerCode 0) {
  327.                         $codesCount += $productsPerCode == $count $count/$productsPerCode;
  328.                     }
  329.                 }
  330.                 $details = new OfferOrderDetails();
  331.                 $details->setOfferExtension($extension);
  332.                 $details->setItemsCount($count);
  333.                 $order->addOfferOrderDetails($details);
  334.             }
  335.         }
  336.         $codesCount = \ceil($codesCount);
  337.         $totalAmountWithoutCode $totalOfferAmount;
  338.         $codeCost $pricePromocodeForOnlineOrder->getPrice($order$offer$codesCount$totalAmountWithoutCode);
  339.         $codeCostRegular $codeCost;
  340.         $user $order->getUser();
  341.         $allowedCodesToBuyBalance false;
  342.         if ($subscriptionService->isSubscriber($user) || $user->isBatchCodesAllowed()) {
  343.             $codeCost 0;
  344.         } elseif ($user->isBalanceAllowed($codesCount $codeCost)) {
  345.             $codeCost 0;
  346.             $allowedCodesToBuyBalance true;
  347.         }
  348.         $totalOfferAmount += $codesCount $codeCost;
  349.         $order->setCodesCount($codesCount);
  350.         $order->setCodeCost($codeCostRegular);
  351.         $deliveryPrice $iikoUtil->getMinSumForFreeDelivery() > && $totalAmountWithoutCode $iikoUtil->getMinSumForFreeDelivery() ? $iikoUtil->getDeliveryPriceSettings() : 0;
  352.         // Delivery price will be calculated after choosing the address
  353.         if (null !== $offer->getOfferDeliveryZone() && $offer->getOfferDeliveryZone()->count() > 0) {
  354.             $deliveryPrice 0;
  355.         }
  356.         if ($pickupDeliveryType === FoodOfferExtension::DELIVERY_METHOD_PICKUP) {
  357.             $deliveryPrice 0;
  358.         }
  359.         $order->setAmount($totalOfferAmount $deliveryPrice);
  360.         $order->setDeliveryCost($deliveryPrice);
  361.         if (CommonUtil::isMobileDevice($request)) {
  362.             $order->setDeviceType(SiteController::DEVICE_TYPE_MOBILE);
  363.         } else {
  364.             $order->setDeviceType(SiteController::DEVICE_TYPE_DESKTOP);
  365.         }
  366.         $entityManager->persist($order);
  367.         $entityManager->flush();
  368.         $entityManager->detach($order);
  369.         $deliveryAddresses $user->getAvailableUserAddresses($offerID);
  370.         $defaultDeliveryAddress = empty($deliveryAddresses) ? false $deliveryAddresses[0];
  371.         $deliveryAddressesGift $user->getAvailableUserAddressesGift($offerID);
  372.         if ($order->isOnlineGift()) {
  373.             $defaultDeliveryAddress $deliveryAddressesGift[0] ?? false;
  374.             $deliveryAddresses $deliveryAddressesGift;
  375.         }
  376.         $brandboxEnabled $offer->getBrandboxEnabled();
  377.         $deliveryEnabled $iikoUtil->isDeliveryEnabled();
  378.         $pickupEnabled $iikoUtil->isPickupEnabled();
  379.         $isAjaxScheduleForDelivery false;
  380.         $schedule $shippingSchedulerService->getEmptySchedule($iikoUtil$pickupDeliveryType);
  381.         if (
  382.             ($brandboxEnabled && $pickupDeliveryType === FoodOfferExtension::DELIVERY_METHOD && $deliveryAddresses) ||
  383.             (!$brandboxEnabled && $deliveryEnabled && $deliveryAddresses)
  384.         ) {
  385.             $schedule $shippingSchedulerService->getDeliverySchedule($iikoUtil$pickupDeliveryType);
  386.         }
  387.         $citySelect '';
  388.         $citySelectData $iikoUtil->getCitySelectData($entityManager);
  389.         if ($citySelectData) {
  390.             $citySelect $this->renderView(CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/city_select.html.twig'
  391.                 'Slivki/delivery/city_select.html.twig', ['deliveryLocations' => $citySelectData]);
  392.         }
  393.         $workHourFrom 0;
  394.         $workHourTo 0;
  395.         $pickupLocations '';
  396.         $defaultLocationID null;
  397.         /** @var GeoLocation $geoLocation */
  398.         foreach ($offer->getGeoLocations() as $geoLocation) {
  399.             if (!$geoLocation->isActive()) {
  400.                 continue;
  401.             }
  402.             if (!$defaultLocationID) {
  403.                 $defaultLocationID $geoLocation->getID();
  404.             }
  405.             $pickupPointScheduleParsed $geoLocation->getPickupPointScheduleParsed();
  406.             if (!$pickupPointScheduleParsed) {
  407.                 continue;
  408.             }
  409.             $pickupLocations .= $this->renderView('Slivki/delivery/pickup_location_item.html.twig', [
  410.                 'location' => $geoLocation,
  411.             ]);
  412.         }
  413.         $nearestTime 'Ближайшее';
  414.         $deliveryTimeFrom $iikoUtil->getDeliveryTimeFrom();
  415.         $deliveryTimeTill $iikoUtil->getDeliveryTimeTill();
  416.         $additionalDominos = !(null === $additionalDominos);
  417.         $this->reCalcOrder(
  418.             $order,
  419.             0,
  420.             $pickupDeliveryType,
  421.             $subscriptionService->isSubscriber($this->getUser()),
  422.             $pricePromocodeForOnlineOrder
  423.         );
  424.         $data = [
  425.             'order' => $order,
  426.             'offer' => $offer,
  427.             'codeCost' => $codeCost,
  428.             'codeCostRegular' => $codeCostRegular,
  429.             'deliveryPrice' => $deliveryPrice,
  430.             'offerURL' => $entityManager->getRepository(Seo::class)->getOfferURL($offer->getID())->getMainAlias(),
  431.             'totalAmount' => $totalAmount $deliveryPrice,
  432.             'director' => $offer->getDirectors()->first(),
  433.             'robotsMeta' => 'noindex, follow',
  434.             'offerID' => $offerID,
  435.             'showCheckAddressButton' => $iikoUtil::SHOW_CHECK_ADDRESS_BUTTON,
  436.             'streetSuggest' => $iikoUtil::STREET_SUGGEST,
  437.             'workHourFrom' => $workHourFrom,
  438.             'workHourTo' => $workHourTo,
  439.             'citySelect' => $citySelect,
  440.             'multipleLocationDelivery' => $iikoUtil::MULTIPLE_LOCATIONS_DELIVERY,
  441.             'formAction' => '/delivery/order/check-payment',
  442.             'categoryName' => $iikoUtil::CATEGORY_NAME,
  443.             'categoryURL' => $entityManager->getRepository(Seo::class)->getSeoForEntity(SeoRepository::RESOURCE_URL_OFFER_CATEGORY$iikoUtil::CATEGORY_ID)->getMainAlias(),
  444.             'pickupLocations' => $pickupLocations,
  445.             'nearestTimeLabel' => $nearestTime,
  446.             'showDelivery' => true,
  447.             'defaultLocationID' => $defaultLocationID,
  448.             'pickupEnabled' => $pickupEnabled,
  449.             'deliveryEnabled' => $deliveryEnabled,
  450.             'allowedPaymentMethods' => $iikoUtil->getAllowedPaymentMethods(),
  451.             'footerOfferConditionID' => $offerID,
  452.             'pickupDiscount' => $iikoUtil->getPickupDiscount(),
  453.             'pickupDeliveryType' => $pickupDeliveryType,
  454.             'deliveryTimeFrom' => $deliveryTimeFrom,
  455.             'deliveryTimeTill' => $deliveryTimeTill,
  456.             'orderPeriodInDays' => $iikoUtil->getOrderPeriodInDays(),
  457.             'offersDetails' => $offersDetails,
  458.             'schedule' => $schedule,
  459.             'deliveryAddresses' => $deliveryAddresses,
  460.             'deliveryAddressesGift' => $deliveryAddressesGift,
  461.             'defaultDeliveryAddress' => $defaultDeliveryAddress,
  462.             'brandboxEnabled' => $brandboxEnabled,
  463.             'additionalDominos' => $additionalDominos,
  464.             'isSushiVesla' => $isSushiVesla,
  465.             'isDominos' => $isDominos,
  466.             'isAjaxScheduleForDelivery' => $isAjaxScheduleForDelivery,
  467.             'isOnlineGift' => $offer->isOnlineOrderGiftEnabled(),
  468.             'allowedCodesToBuyBalance' => $allowedCodesToBuyBalance,
  469.             'deliveryZones' => $deliveryZoneSorter->sortByDefault($deliveryZoneDao->findByOfferId($offerID)),
  470.             'offerForSlivkiDelivery' => $slivkiDeliveryOption,
  471.             'isDeliveryZoneAvailable' => $offer->isDeliveryZoneAvailable(),
  472.         ];
  473.         $data['iikoOrder'] = true;
  474.         $view CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/delivery_checkout.html.twig' 'Slivki/delivery/delivery_checkout.html.twig';
  475.         $content $this->renderView($view$data);
  476.         $response->setContent($content);
  477.         $response->headers->addCacheControlDirective('no-cache'true);
  478.         $response->headers->addCacheControlDirective('max-age'0);
  479.         $response->headers->addCacheControlDirective('must-revalidate'true);
  480.         $response->headers->addCacheControlDirective('no-store'true);
  481.         return $response;
  482.     }
  483.     /**
  484.      * @Route("/delivery/order/payment/{orderID}", name="delivery_order_payment")
  485.      */
  486.     public function deliveryOrderPaymentAction(
  487.         Request $request,
  488.         PartnerBePaidService $partnerBePaidService,
  489.         OnlineOrderHistoryHandler $onlineOrderHistoryHandler,
  490.         SubscriptionService $subscriptionService,
  491.         CreditCardRepositoryInterface $creditCardRepository,
  492.         DirectorRepositoryInterface $directorRepository,
  493.         VirtualWalletChecker $virtualWalletChecker,
  494.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder,
  495.         UnusedOfferCodeProviderInterface $unusedOfferCodeProvider,
  496.         $orderID
  497.     ) {
  498.         $entityManager $this->getDoctrine()->getManager();
  499.         $response = new Response();
  500.         /** @var FoodOrder $order */
  501.         $order $entityManager->find(FoodOrder::class, $orderID);
  502.         if (!$order) {
  503.             throw $this->createNotFoundException();
  504.         }
  505.         $user $order->getUser();
  506.         $offer $order->getOffer();
  507.         $offerID $offer->getID();
  508.         $iikoUtil IikoUtil::instance($offer);
  509.         $iikoUtil->setContainer($this->kernel->getContainer());
  510.         $isPickup $order->getDeliveryAddress()->isPickup();
  511.         $detailIdCount = [];
  512.         $totalAmount 0;
  513.         foreach ($order->getOfferOrderDetails() as $details) {
  514.             $extension $details->getOfferExtension();
  515.             if ($iikoUtil instanceof SushiHouse) {
  516.                 if (isset($detailIdCount[$extension->getID()])) {
  517.                     $detailIdCount[$extension->getID()] += $details->getItemsCount();
  518.                 } else {
  519.                     $detailIdCount[$extension->getID()] = $details->getItemsCount();
  520.                 }
  521.             }
  522.             $variant $details->getOfferExtensionVariant();
  523.             $regularPrice $variant $variant->getRegularPrice() : $details->getOfferExtension()->getPrice();
  524.             $totalAmount += $details->getItemsCount() * $regularPrice;
  525.             $sortByFromDelivery $request->getSession()->get(OnlineOrderHistory::SORT_SESSION_NAME);
  526.             if (null !== $sortByFromDelivery) {
  527.                 $onlineOrderHistoryHandler->handle(
  528.                     $order,
  529.                     $extension->getID(),
  530.                     $sortByFromDelivery
  531.                 );
  532.             }
  533.         }
  534.         $request->getSession()->set(OnlineOrderHistory::SORT_SESSION_NAMEnull);
  535.         $pickupDeliveryType $isPickup FoodOfferExtension::DELIVERY_METHOD_PICKUP FoodOfferExtension::DELIVERY_METHOD;
  536.         $deliveryCost 0;
  537.         if ($pickupDeliveryType === FoodOfferExtension::DELIVERY_METHOD || !$isPickup) {
  538.             $totalAmount += $order->getDeliveryCost();
  539.             $deliveryCost $order->getDeliveryCost();
  540.         }
  541.         $codeCost $order->getCodeCost();
  542.         $regularCodeCost $codeCost;
  543.         $allowedCodesToBuyBalance false;
  544.         if ($subscriptionService->isSubscriber($user) || $user->isBatchCodesAllowed()) {
  545.             $codeCost 0;
  546.         } elseif ($user->isBalanceAllowed($codeCost $order->getCodesCount())) {
  547.             $codeCost 0;
  548.             $allowedCodesToBuyBalance true;
  549.         }
  550.         $partnerBePaidService->setOrder($order);
  551.         $paymentToken $partnerBePaidService->getPaymentToken($ordernull$codeCost);
  552.         $view CommonUtil::isMobileDevice($request)
  553.             ? 'Slivki/mobile/delivery/delivery_payment.html.twig'
  554.             'Slivki/delivery/delivery_payment.html.twig';
  555.         $offersDetails = [];
  556.         $director $directorRepository->findById($offer->getDirectorID());
  557.         $fullOrderAmount $order->getAmount();
  558.         if ($allowedCodesToBuyBalance) {
  559.             $fullOrderAmount += $regularCodeCost $order->getCodesCount();
  560.         }
  561.         $this->reCalcOrder(
  562.             $order,
  563.             0,
  564.             $pickupDeliveryType,
  565.             $subscriptionService->isSubscriber($this->getUser()),
  566.             $pricePromocodeForOnlineOrder
  567.         );
  568.         $content =  $this->renderView($view, [
  569.             'order' => $order,
  570.             'offer' => $offer,
  571.             'offerURL' => $entityManager->getRepository(Seo::class)->getOfferURL($offerID)->getMainAlias(),
  572.             'offerID' => $offerID,
  573.             'categoryName' => $iikoUtil::CATEGORY_NAME,
  574.             'deliveryPrice' => $deliveryCost,
  575.             'codeCost' => $codeCost,
  576.             'totalAmount' => $totalAmount,
  577.             'showCheckAddressButton' => false,
  578.             'categoryURL' => $entityManager->getRepository(Seo::class)->getSeoForEntity(SeoRepository::RESOURCE_URL_OFFER_CATEGORY$iikoUtil::CATEGORY_ID)->getMainAlias(),
  579.             'isPickup' => $isPickup,
  580.             'allowedPaymentMethods' => $iikoUtil->getAllowedPaymentMethods()[$isPickup 'pickup' 'delivery'],
  581.             'pickupDiscount' => $isPickup $iikoUtil->getPickupDiscount() : 0,
  582.             'pickupDeliveryType' => $pickupDeliveryType,
  583.             'paymentToken' => $paymentToken['checkout']['token'],
  584.             'offersDetails' => $offersDetails,
  585.             'additionalDominos' => false,
  586.             'isDominos' => $iikoUtil instanceof Dominos,
  587.             'activeCreditCards' => !$offer->isRecurrentDisabled() ? $creditCardRepository->findActiveByUser($user) : [],
  588.             'directorName' => $director instanceof Director $director->getName() : '',
  589.             'allowedCodesToBuyBalance' => $allowedCodesToBuyBalance,
  590.             'isSlivkiPayAllowed' => $virtualWalletChecker->availableSlivkiPay($fullOrderAmount$user),
  591.             'allowedCashbackSumToPay' => $iikoUtil->getAllowedCashbackSumToPay($order$entityManager),
  592.             'allowedFastDeliveryForSushiHouse' => $iikoUtil->enabledFastDelivery($order),
  593.             'unusedCodes' => $unusedOfferCodeProvider->getUnusedOfferCode($order$offer$user),
  594.         ]);
  595.         $response->setContent($content);
  596.         return $response;
  597.     }
  598.     /** @Route("/delivery/order/check-payment", name = "deliveryOrderCheckPayment") */
  599.     public function checkPaymentAction(
  600.         Request $request,
  601.         CoordinatesYandex $coordinatesYandex,
  602.         DeliveryZoneRepositoryInterface $deliveryZoneRepository,
  603.         ShippingSchedulerService $shippingSchedulerService,
  604.         SubscriptionService $subscriptionService,
  605.         PhoneNumberUtil $phoneNumberUtil,
  606.         PhoneNumberHelper $phoneNumberHelper,
  607.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder,
  608.         VisibilityFilterService $visibilityFilterService
  609.     ) {
  610.         if (!$request->isMethod(Request::METHOD_POST)) {
  611.             throw $this->createNotFoundException();
  612.         }
  613.         $entityManager $this->getDoctrine()->getManager();
  614.         $orderID $request->request->getInt('orderID');
  615.         $pickupDeliveryType $request->request->get('pickupDeliveryType');
  616.         $pickupDeliveryType $pickupDeliveryType ? (int) $pickupDeliveryType null;
  617.         $isOnlineOrderGift $request->request->getBoolean('isOnlineGift');
  618.         $discount 0;
  619.         /** @var FoodOrder $order */
  620.         $order $entityManager->find(FoodOrder::class, $orderID);
  621.         if (!$order || $order->getUser()->getID() != $this->getUser()->getID() || $order->getStatus() != FoodOrder::STATUS_INIT) {
  622.             throw $this->createNotFoundException();
  623.         }
  624.         $order->setComment($request->request->get('comment'));
  625.         $order->setDeliveryTime($request->request->get('deliveryTime'));
  626.         $order->setIsOnlineGift($isOnlineOrderGift);
  627.         $iikoUtil IikoUtil::instance($order->getOffer());
  628.         $iikoUtil->setContainer($this->kernel->getContainer());
  629.         $possibilityOrder $iikoUtil->getPossibilityOrderStatus($order);
  630.         if ($possibilityOrder['status'] === 'error') {
  631.             return new JsonResponse(['status' => 'error''error' => true'message' => $possibilityOrder['message']]);
  632.         }
  633.         $isSushiHouse $iikoUtil instanceof SushiHouse;
  634.         $isSushiVesla $iikoUtil instanceof SushiVesla;
  635.         if (!$isSushiHouse && !$isSushiVesla) {
  636.             $this->reCalcOrder(
  637.                 $order,
  638.                 0,
  639.                 $pickupDeliveryType,
  640.                 $subscriptionService->isSubscriber($this->getUser()),
  641.                 $pricePromocodeForOnlineOrder
  642.             );
  643.         }
  644.         $request->getSession()->set("pickupDiscount"null);
  645.         if ($request->request->has('pickup')) {
  646.             $addressID $request->request->getInt('pickupAddressID');
  647.             $discount $request->request->getInt('pickupDiscount');
  648.             $request->getSession()->set("pickupDiscount"$discount);
  649.             $geoLocation $entityManager->find(GeoLocation::class, $addressID);
  650.             $userAddresses $entityManager->getRepository(UserAddress::class)->findBy(['user' => $this->getUser(), 'geoLocation' => $geoLocation]);
  651.             $address null;
  652.             foreach ($userAddresses as $location) {
  653.                 if ($location->getGeoLocation()->getID() == $addressID) {
  654.                     $address $location;
  655.                     break;
  656.                 }
  657.             }
  658.             if (!$address) {
  659.                 $address = new UserAddress();
  660.                 $address->setUser($this->getUser());
  661.                 $address->setGeoLocation($geoLocation);
  662.                 $address->setOfferID($order->getOffer()->getID());
  663.                 $entityManager->persist($address);
  664.             }
  665.             $address->setPickup(true);
  666.         } else {
  667.             $address $entityManager->find(UserAddress::class, $request->request->getInt('addressID'));
  668.             $geoLocation null;
  669.         }
  670.         if ($address) {
  671.             $name $request->request->get('name''');
  672.             $phone $request->request->get('phone''');
  673.             if (trim($name) == '' || trim($phone) == '') {
  674.                 return new JsonResponse(['error' => true]);
  675.             }
  676.             if (\mb_strlen($phone) > 0) {
  677.                 $phoneNumberObject $phoneNumberUtil->parse($phone);
  678.                 if (!$phoneNumberUtil->isValidNumber($phoneNumberObject)) {
  679.                     return new JsonResponse(['error' => true'message' => 'Введен некорректный номер телефона']);
  680.                 }
  681.             }
  682.             $address->setPhone($phone);
  683.             $address->setName($name);
  684.             $address->setIsOnlineGift($isOnlineOrderGift);
  685.             if ($isOnlineOrderGift) {
  686.                 $address->setNameGift($request->request->get('nameGift'));
  687.                 $address->setPhoneNumberGift(
  688.                     $phoneNumberHelper->convert($request->request->get('phoneNumberGift'), ''),
  689.                 );
  690.             }
  691.             $order->setDeliveryAddress($address);
  692.         } else {
  693.             return new JsonResponse(['error' => true'message' => 'Не выбран адрес']);
  694.         }
  695.         $result $iikoUtil->checkOrder($entityManager$order$subscriptionService);
  696.         if (!$result || $result->resultState 0) {
  697.             $message null;
  698.             if ($result) {
  699.                 switch ($result->resultState) {
  700.                     case 1:
  701.                         if (isset($result->problem)) {
  702.                             $message $result->problem;
  703.                         }
  704.                         if (isset($result->minSumForFreeDelivery)) {
  705.                             $message = \sprintf('Минимальная сумма заказа %s руб.', (string) $result->minSumForFreeDelivery);
  706.                         }
  707.                         break;
  708.                     case 2:
  709.                         $message 'Извините, в данное время заказ невозможен. Пожалуйста, выберите другое время';
  710.                         break;
  711.                     case 3:
  712.                         $message 'Извините, на данный адрес доставка не осуществляется';
  713.                         break;
  714.                     case 4:
  715.                     case 5:
  716.                         $message 'На данный момент заказ одного из товаров невозможен';
  717.                         break;
  718.                     case 9999:
  719.                         $message 'Заказы принимаются с 11:00 по 22:20';
  720.                         break;
  721.                 }
  722.             }
  723.             return new JsonResponse(['error' => true'message' => $message]);
  724.         }
  725.         try {
  726.             $visibilityFilterService->assertAllVisibleOrFail(array_map(
  727.                 static fn (OfferOrderDetails $orderDetail) => $orderDetail->getOfferExtension(),
  728.                 $order->getOfferOrderDetails()->toArray(),
  729.             ));
  730.         } catch (OfferExtensionNotVisibleException $e) {
  731.             return new JsonResponse(['error' => true'message' => $e->getMessage()]);
  732.         }
  733.         if ($request->request->get('deliveryTime') !== self::NEARLY) {
  734.             if ($request->request->get('deliveryTime') === null) {
  735.                 $checkSchedule = [
  736.                     'status' => 'error',
  737.                     'message' => 'Выберите время',
  738.                 ];
  739.             } else {
  740.                 $checkSchedule $iikoUtil->checkSchedule($shippingSchedulerService$geoLocation$entityManager$pickupDeliveryType$request->request->get('deliveryTime'));
  741.             }
  742.             if ($checkSchedule['status'] === 'error') {
  743.                 return new JsonResponse(['status' => $checkSchedule['status'], 'message' => $checkSchedule['message'], 'error' => true], Response::HTTP_OK);
  744.             }
  745.         }
  746.         if (null !== $order->getOffer()->getOfferDeliveryZone() && $order->getOffer()->getOfferDeliveryZone()->count() > 0) {
  747.             if (null === $address->isPickup()) {
  748.                 $points $address->getCoordinatesForDeliveryZone() ?? $coordinatesYandex->getGeoCoordinates(
  749.                     $address->buildFullAddress(),
  750.                     ['offerId' => (int)$order->getOffer()->getID()]
  751.                 );
  752.                 $deliveryZone $deliveryZoneRepository->getPolygonByPoint($order->getOffer(), $points);
  753.                 if (null !== $deliveryZone) {
  754.                     $user $order->getUser();
  755.                     $codeCost $order->getCodeCost();
  756.                     if ($subscriptionService->isSubscriber($user) || $user->isBatchCodesAllowed() || $user->isBalanceAllowed($codeCost $order->getCodesCount())) {
  757.                         $codeCost 0;
  758.                     }
  759.                     $total $order->getAmount() - ($order->getCodesCount() * $codeCost);
  760.                     if ($total $deliveryZone->getMinOrderAmount()) {
  761.                         return new JsonResponse([
  762.                             'error' => true,
  763.                             'message' => \sprintf('До минимальной суммы заказа в этой зоне %s р.', (string) ($deliveryZone->getMinOrderAmount() - $total)),
  764.                         ]);
  765.                     }
  766.                     $order->setDeliveryZoneLocationId($deliveryZone->getGeoLocationId());
  767.                     $order->setDeliveryCost($deliveryZone->getPaidDeliveryAmount());
  768.                     if ($total >= $deliveryZone->getFreeDeliveryAmount()) {
  769.                         $order->setDeliveryCost(0);
  770.                     }
  771.                     if (null === $address->getCoordinatesForDeliveryZone()) {
  772.                         $coordinates explode(' '$points);
  773.                         $address->setLatitude($coordinates[1]);
  774.                         $address->setLongitude($coordinates[0]);
  775.                     }
  776.                 } else {
  777.                     return new JsonResponse([
  778.                         'error' => true,
  779.                         'message' => 'Данный адрес не входит в зону доставки. Выберите другой адрес.',
  780.                     ]);
  781.                 }
  782.             } else {
  783.                 $order->setDeliveryZoneLocationId($address->getGeoLocation()->getID());
  784.             }
  785.         }
  786.         $this->reCalcOrder(
  787.             $order,
  788.             $discount,
  789.             $pickupDeliveryType,
  790.             $subscriptionService->isSubscriber($this->getUser()),
  791.             $pricePromocodeForOnlineOrder
  792.         );
  793.         $entityManager->flush();
  794.         return new JsonResponse(['error' => false'redirectURL' => '/delivery/order/payment/' $order->getID() ]);
  795.     }
  796.     /**
  797.      * @Route("/delivery/order/pay/{orderID}", name="deliveryOrderPay")
  798.      */
  799.     public function payAction(
  800.         Request $request,
  801.         PartnerBePaidService $partnerBePaidService,
  802.         PaymentService $paymentService,
  803.         CreditCardRepositoryInterface $creditCardRepository,
  804.         SubscriptionService $subscriptionService,
  805.         ContainerInterface $container,
  806.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder,
  807.         VirtualWalletChecker $virtualWalletChecker,
  808.         $orderID
  809.     ) {
  810.         $paymentMethod $request->request->getInt('paymentMethod');
  811.         $entityManager $this->getDoctrine()->getManager();
  812.         $order $entityManager->find(FoodOrder::class, $orderID);
  813.         if (null === $order) {
  814.             return new JsonResponse(['error' => true]);
  815.         }
  816.         $iikoUtil IikoUtil::instance($order->getOffer());
  817.         $iikoUtil->setContainer($container);
  818.         $order->setPaymentType($paymentMethod);
  819.         $order->setPaymentMethodID(OfferOrder::METHOD_BEPAID);
  820.         $isUsePartnerCashbackBalance $request->request->getBoolean('usePartnerCashbackBalance');
  821.         $order->setUsePartnerCashbackBalance($isUsePartnerCashbackBalance);
  822.         if ($isUsePartnerCashbackBalance) {
  823.             $allowedCashbackSumToPay $iikoUtil->getAllowedCashbackSumToPay($order$entityManager);
  824.             $order->setUsedPartnerCashbackSum($allowedCashbackSumToPay);
  825.         }
  826.         $order->setUseFastDelivery(
  827.             $request->request->getBoolean('useFastDelivery')
  828.         );
  829.         $order->setChangeAmount(
  830.             $request->request->get('changeAmount')
  831.                 ? (float) $request->request->get('changeAmount')
  832.                 : null
  833.         );
  834.         $codeCost $order->getCodeCost();
  835.         $codeCostRegular $codeCost;
  836.         $user $order->getUser();
  837.         $subscriber false;
  838.         if ($subscriptionService->isSubscriber($user)) {
  839.             $subscriber true;
  840.             $codeCost 0;
  841.         }
  842.         $isBatchCodes false;
  843.         if ($user->isBatchCodesAllowed()) {
  844.             $isBatchCodes true;
  845.             $codeCost 0;
  846.         }
  847.         if (in_array($paymentMethod, [PaymentType::CASHPaymentType::TERMINAL], true)) {
  848.             if ($subscriber || $isBatchCodes) {
  849.                 $order->setAmount($codeCost);
  850.                 $paymentService->createCode(
  851.                     $order,
  852.                     $order->getCodesCount(),
  853.                     false,
  854.                     null,
  855.                     false,
  856.                     $isBatchCodes UserBalanceActivity::TYPE_REDUCTION_BATCH_CODES null
  857.                 );
  858.                 return new JsonResponse(['error' => false]);
  859.             }
  860.             $order->setAmount($order->getCodesCount() * $codeCost);
  861.             $entityManager->flush();
  862.             return new JsonResponse([
  863.                 'redirectURL' => $this->redirectToRoute('buyCode', [
  864.                         'offerID' => $order->getOffer()->getID(),
  865.                         'codesCount' =>  $order->getCodesCount(),
  866.                         'orderID' => $order->getID()
  867.                     ]
  868.                 )->getTargetUrl()
  869.             ]);
  870.         }
  871.         $deliveryType $order->getDeliveryAddress()->isPickup() ? FoodOfferExtension::DELIVERY_METHOD_PICKUP FoodOfferExtension::DELIVERY_METHOD;
  872.         $discount $request->getSession()->get("pickupDiscount") ? $request->getSession()->get("pickupDiscount") : 0;
  873.         $this->reCalcOrder(
  874.             $order,
  875.             $discount,
  876.             $deliveryType,
  877.             $subscriptionService->isSubscriber($user),
  878.             $pricePromocodeForOnlineOrder
  879.         );
  880.         if ($paymentMethod === PaymentType::SLIVKI_PAY) {
  881.             $codeCostForSlivkiPay $order->getCodesCount() * (float) $order->getCodeCost();
  882.             try {
  883.                 $orderAmount $order->getAmount();
  884.                 if ($order->getUsedPartnerCashbackSum() > 0) {
  885.                     $orderAmount -= $order->getUsedPartnerCashbackSum();
  886.                 }
  887.                 if ($codeCost === || $user->isBalanceAllowed($codeCost $order->getCodesCount())) {
  888.                     $orderAmount += $codeCostForSlivkiPay;
  889.                 }
  890.                 if (!$virtualWalletChecker->availableSlivkiPay($orderAmount$user)) {
  891.                     return new JsonResponse(
  892.                         [
  893.                             'error' => true,
  894.                             'message' => 'Недостаточно средств на балансе SlivkiPay',
  895.                             'slivkiPay' => true,
  896.                         ]
  897.                     );
  898.                 }
  899.                 $paymentService->payOrder($user$orderAmount);
  900.                 $paymentService->createCode($order$order->getCodesCount(), false);
  901.             } catch (InsufficientBalanceFundsException $exception) {
  902.                 return new JsonResponse(['error' => true]);
  903.             }
  904.             return new JsonResponse(['error' => false]);
  905.         }
  906.         $order->setPaymentType(PaymentType::ONLINE);
  907.         if ($user->isBalanceAllowed($codeCost $order->getCodesCount())) {
  908.             $codeCost 0;
  909.         }
  910.         $iikoUtil->modifyOrder($order$entityManager);
  911.         $entityManager->flush();
  912.         $partnerBePaidService->setOrder($order);
  913.         $card $creditCardRepository->findById($request->request->getInt('creditCardID'));
  914.         if (null === $card || !$card->isOwner($this->getUser()->getID())) {
  915.             $paymentToken $partnerBePaidService->getPaymentToken($ordernull$codeCost);
  916.             if (!$paymentToken) {
  917.                 return new JsonResponse(['error' => true]);
  918.             }
  919.             $partnerBePaidService->createBePaidPaiment($order$paymentToken['checkout']['token']);
  920.             return new JsonResponse([
  921.                 'token' => $paymentToken['checkout']['token'],
  922.             ]);
  923.         }
  924.         $offerSettings $order->getOffer()->getOnlineOrderSettings();
  925.         if (($iikoUtil::SPLIT_PAYMENT || ($offerSettings && $offerSettings->isSplitPayment()))
  926.             && (!$subscriber && !$user->isBatchCodesAllowed() && !$user->isBalanceAllowed($codeCostRegular $order->getCodesCount()))
  927.         ) {
  928.             $amount $order->getAmount() - $order->getCodesCount() * $codeCost;
  929.         } else {
  930.             $amount $order->getAmount();
  931.         }
  932.         $result $partnerBePaidService->checkoutByToken($order$card->getID(), $amount);
  933.         if (!$result) {
  934.             return new JsonResponse(['error' => true]);
  935.         }
  936.         if (is_array($result) && isset($result['token'])) {
  937.             return new JsonResponse(['token' => $result['token']]);
  938.         }
  939.         $partnerBePaidService->createBePaidPaiment($order$result);
  940.         
  941.         return new JsonResponse(['error' => false]);
  942.     }
  943.     /** @Route("/delivery/street/suggest/{offerID}") */
  944.     public function deliveryStreetSuggest(Request $request$offerID): JsonResponse
  945.     {
  946.         /** @var StreetRepository $street */
  947.         $street $this->getDoctrine()->getManager()->getRepository(Street::class);
  948.         $streets $street->getStreets($offerID$request->query->get('q'));
  949.         return new JsonResponse($streets);
  950.     }
  951.     /** @Route("/delivery/feedback/{offerID}") */
  952.     public function feedbackAction(Request $requestMailer $mailer$offerID) {
  953.         $text $request->request->get('name') . ', ' $request->request->get('email') . "\n" $request->request->get('message') . "\n";
  954.         $subj ='';
  955.         if (is_numeric($offerID)) {
  956.             $offerID = (int)$offerID;
  957.             $offer $this->getDoctrine()->getManager()->find(Offer::class, $offerID);
  958.             if ($offer) {
  959.                 $subj 'Жалоба на акцию: ' $offer->getTitle();
  960.             } else {
  961.                 $subj 'Фидбек с доставки суши';
  962.             }
  963.         }
  964.         else if ($offerID == 'subscription-landing') {
  965.             $subj 'Фидбек с лендинга подписки';
  966.         }
  967.         else if ($offerID == 'auth') {
  968.             $subj 'Фидбек с попапа авторизации';
  969.         }
  970.         $message $mailer->createMessage($subj$text);
  971.         $message->setFrom('info@slivki.by''Slivki.by');
  972.         $message->setTo('1@slivki.by')
  973.             ->addTo('info@slivki.by')
  974.             ->addTo('yuri@slivki.com')
  975.             ->addCc('dmitry.kazak@slivki.com');
  976.         $mailer->send($message);
  977.         return new Response();
  978.     }
  979.     private function reCalcOrder(
  980.         FoodOrder $order,
  981.         $discount 0,
  982.         $typePrice null,
  983.         bool $isSubscriber false,
  984.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder
  985.     ) {
  986.         /** @var OfferOrderDetails $details */
  987.         $orderSum 0;
  988.         $additionalInfo $order->getAdditionalInfo();
  989.         $additionalDominos false;
  990.         if (isset($additionalInfo['dominosCoupon'])) {
  991.             $additionalDominos true;
  992.         }
  993.         $iikoUtil AbstractDelivery::instance($order->getOffer());
  994.         $iikoUtil->setContainer($this->kernel->getContainer());
  995.         foreach ($order->getOfferOrderDetails() as $details) {
  996.             $variant $details->getOfferExtensionVariant();
  997.             if ($variant) {
  998.                 $extension $variant->getOfferExtension();
  999.                 if ($additionalDominos) {
  1000.                     $variantAdditionalDominos $variant;
  1001.                 } else {
  1002.                     $variantAdditionalDominos null;
  1003.                 }
  1004.                 $purchasePrice PriceDeliveryType::calcDeliveryPickupPrice(
  1005.                     $extension,
  1006.                     $typePrice,
  1007.                     $variant->getRegularPrice(),
  1008.                     $variant->getOfferPrice(),
  1009.                     $variantAdditionalDominos
  1010.                 );
  1011.             } else {
  1012.                 $extension $details->getOfferExtension();
  1013.                 $product $iikoUtil->getProduct($extension->getPartnerItemID());
  1014.                 $purchasePrice PriceDeliveryType::calcDeliveryPickupPrice(
  1015.                     $extension,
  1016.                     $typePrice,
  1017.                     $product->regularPrice,
  1018.                     $extension->getCurrentPrice(null$typePrice),
  1019.                 );
  1020.             }
  1021.             $orderSum += $details->getItemsCount() * $purchasePrice;
  1022.             $details->setPurchasePrice($purchasePrice);
  1023.         }
  1024.         $deliveryCost $order->getDeliveryCost();
  1025.         if (
  1026.             ($typePrice !== null && (int) $typePrice === FoodOfferExtension::DELIVERY_METHOD_PICKUP)
  1027.             || (null !== $order->getDeliveryAddress() && $order->getDeliveryAddress()->isPickup())
  1028.         ) {
  1029.             $deliveryCost 0;
  1030.         }
  1031.         $order->setDeliveryCost($deliveryCost);
  1032.         $regularCodeCost $pricePromocodeForOnlineOrder->getPrice(
  1033.             $order,
  1034.             $order->getOffer(),
  1035.             $order->getCodesCount(),
  1036.             $orderSum $deliveryCost
  1037.         );
  1038.         $codeCost 0;
  1039.         if (!$isSubscriber
  1040.             && !$order->getUser()->isBatchCodesAllowed()
  1041.             && !$order->getUser()->isBalanceAllowed($regularCodeCost $order->getCodesCount())
  1042.         ) {
  1043.             $codeCost $regularCodeCost;
  1044.         }
  1045.         $orderSum += $codeCost $order->getCodesCount() + $deliveryCost;
  1046.         if ($discount 0) {
  1047.             $orderSum -= ($orderSum * ($discount 100));
  1048.         }
  1049.         if ($order->getUsedPartnerCashbackSum() > 0) {
  1050.             $orderSum -= $order->getUsedPartnerCashbackSum();
  1051.         }
  1052.         $order->setAmount($orderSum);
  1053.     }
  1054.     /**
  1055.      * @Route("/delivery/check-address", name="delivery_check_address")
  1056.      */
  1057.     public function checkAddressAction(
  1058.         Request $request,
  1059.         SubscriptionService $subscriptionService,
  1060.         VisibilityFilterService $visibilityFilterService
  1061.     ): JsonResponse {
  1062.         $entityManager $this->getDoctrine()->getManager();
  1063.         $orderID $request->request->getInt('orderID');
  1064.         $addressID $request->request->getInt('addressID');
  1065.         $deliveryTime $request->request->get('deliveryTime');
  1066.         $order $entityManager->find(FoodOrder::class, $orderID);
  1067.         $order->setDeliveryTime($deliveryTime);
  1068.         $order->setPaymentType($request->request->getInt('paymentType'1));
  1069.         $address $entityManager->find(UserAddress::class, $addressID);
  1070.         $order->setDeliveryAddress($address);
  1071.         $orderInfo IikoUtil::instance($order->getOffer())->checkOrder($entityManager$order$subscriptionService);
  1072.         if (!$orderInfo) {
  1073.             return new JsonResponse(['error' => true]);
  1074.         }
  1075.         $entityManager->flush();
  1076.         $response $this->getCheckAddressResponse($orderInfo);
  1077.         try {
  1078.             $visibilityFilterService->assertAllVisibleOrFail(array_map(
  1079.                 static fn (OfferOrderDetails $orderDetail) => $orderDetail->getOfferExtension(),
  1080.                 $order->getOfferOrderDetails()->toArray(),
  1081.             ));
  1082.         } catch (OfferExtensionNotVisibleException $e) {
  1083.             return new JsonResponse([
  1084.                 'status' => 'error',
  1085.                 'error' => true,
  1086.                 'deliveryPrice' => $response['deliveryPrice'],
  1087.                 'message' => $e->getMessage(),
  1088.             ]);
  1089.         }
  1090.         return new JsonResponse($response);
  1091.     }
  1092.     /** @Route("/delivery/reload/offer/{offerId}/type/{typePrice}", name="deliveryReloadDish") */
  1093.     public function reloadDish(
  1094.         Request $request,
  1095.         ImageService $imageService,
  1096.         ProductFastDeliveryService $productFastDeliveryService,
  1097.         CustomProductOfferSorter $productSorter,
  1098.         ContainerInterface $container,
  1099.         FoodFilterCounterRepositoryInterface $foodFilterCounterRepository,
  1100.         CustomProductOfferSorter $customProductOfferSorter,
  1101.         OfferOrderPurchaseCountDaoInterface $offerOrderPurchaseCountDao,
  1102.         OfferCacheService $offerCacheService,
  1103.         FoodOfferExtensionRepositoryInterface $foodOfferExtensionRepository,
  1104.         WeightParserHelper $weightParserHelper,
  1105.         ShippingSchedulerService $shippingSchedulerService,
  1106.         FoodByOnlineCategoriesBuilder $foodByOnlineCategoriesBuilder,
  1107.         VisibilityFilterService $visibilityFilterService,
  1108.         $offerId,
  1109.         $typePrice
  1110.     ) {
  1111.         $offerCached $offerCacheService->getOffer($offerIdtruetrue);
  1112.         $data['offer'] = $offerCached;
  1113.         $orderUtil AbstractDelivery::instance($offerCached);
  1114.         $orderUtil->setContainer($container);
  1115.         $data['filterAction'] = $foodFilterCounterRepository->findByOfferId((int) $offerCached->getID());
  1116.         $isSushiVesla $orderUtil instanceof SushiVesla;
  1117.         $isDominos $orderUtil instanceof Dominos;
  1118.         $isSushiHouse $orderUtil instanceof SushiHouse;
  1119.         $isSushiChefArts $orderUtil instanceof SushiChefArts;
  1120.         $data['isDominos'] = $isDominos;
  1121.         $data['showSortingIndexOrder'] = $isSushiVesla || $isDominos false true;
  1122.         $allDishes = [];
  1123.         if ($isSushiVesla) {
  1124.             $allDishes $foodOfferExtensionRepository->findActiveByOfferIdAndShippingType($offerId$typePrice);
  1125.         }
  1126.         $shippingType FoodOfferExtension::LABEL_SHIPPING_TYPE[$typePrice];
  1127.         if ($isSushiVesla) {
  1128.             $dishes $orderUtil->getProductsDBByShippingType(
  1129.                 array_filter($allDishes, static fn (OfferExtension $offerExtension): bool => !is_subclass_of($offerExtensionFoodOfferExtension::class)),
  1130.             );
  1131.         } else {
  1132.             $dishes $orderUtil->getDishes();
  1133.         }
  1134.         $extensions $foodOfferExtensionRepository->findActiveByOfferIdAndShippingType($offerId$typePrice);
  1135.         $extensions array_combine(
  1136.             array_map(static fn (FoodOfferExtension $e) => $e->getPartnerItemID(), $extensions),
  1137.             $extensions,
  1138.         );
  1139.         $dishPurchaseCount $offerOrderPurchaseCountDao->getPurchaseCountsForPeriodByOffer((int) $offerIdPurchaseCountPeriod::LAST_MONTH);
  1140.         $dishPurchaseDayCount $offerOrderPurchaseCountDao->getPurchaseCountsForPeriodByOffer((int) $offerIdPurchaseCountPeriod::LAST_DAY);
  1141.         $data['dishes'] = [];
  1142.         $data['showPricePerKilogram'] = false;
  1143.         foreach ($dishes as $dish) {
  1144.             if (!array_key_exists($dish->id$extensions)) {
  1145.                 continue;
  1146.             }
  1147.             $offerExtension $extensions[$dish->id];
  1148.             $dish->productsPerCode $offerExtension->getProductsPerCode();
  1149.             $dish->offerPrice $offerExtension->getCurrentPrice(null$typePrice);
  1150.             $dish->sauceNeed $offerExtension->isSauceNeed();
  1151.             $dish->rating = (float) $offerCached->getRating();
  1152.             $dish->onlineCategories array_map(
  1153.                 static fn (OfferExtensionOnlineCategory $category): string => $category->getName(),
  1154.                 $offerExtension->getActiveOnlineCategories()->getValues(),
  1155.             );
  1156.             if (isset($dish->regularPrice) && $dish->regularPrice == 0) {
  1157.                 $dish->regularPrice $offerExtension->getPrice();
  1158.             }
  1159.             $dishSizeFull $dish->sizeFull;
  1160.             $dish->sizeFull '';
  1161.             $dish->pricePerKilogram null;
  1162.             $dish->itemCount = (int) $offerExtension->getComponentsCount();
  1163.             $dish->offerPrice = (float) PriceDeliveryType::calcDeliveryPickupPrice(
  1164.                 $offerExtension,
  1165.                 $typePrice,
  1166.                 $dish->regularPrice,
  1167.                 $dish->offerPrice,
  1168.             );
  1169.             if ($extensions[$dish->id]->getWeight()) {
  1170.                 $dish->sizeFull $offerExtension->getWeight() . ' г';
  1171.                 $dish->pricePerKilogram $this->calcPricePerKilogram(
  1172.                     $dish->offerPrice,
  1173.                     (float) $offerExtension->getWeight(),
  1174.                 );
  1175.                 $data['showPricePerKilogram'] = true;
  1176.             }
  1177.             if ($offerExtension->getComponentsCount()) {
  1178.                 if ($dish->sizeFull != '') {
  1179.                     $dish->sizeFull .= ', ';
  1180.                 }
  1181.                 $dish->sizeFull .= $offerExtension->getComponentsCount() . ' шт';
  1182.             }
  1183.             if ($dish->sizeFull === '') {
  1184.                 $dish->sizeFull $dishSizeFull;
  1185.             }
  1186.             if (null === $dish->pricePerKilogram && !empty($dish->sizeFull)) {
  1187.                 $dish->pricePerKilogram $this->calcPricePerKilogram(
  1188.                     $dish->offerPrice,
  1189.                     (float) $weightParserHelper->parse($dish->sizeFull),
  1190.                 );
  1191.                 $data['showPricePerKilogram'] = true;
  1192.             }
  1193.             $dish->originId $dish->id;
  1194.             $dish->position $offerExtension->getPosition() ?: CustomProductOfferSorter::DEFAULT_POSITION;
  1195.             $dish->id $offerExtension->getID();
  1196.             $dish->description str_replace("\n"'<br/>'$dish->description);
  1197.             $dish->imageURL null;
  1198.             if (isset($dish->images[count($dish->images) - 1])) {
  1199.                 if ($dish->images[count($dish->images) - 1] instanceof OfferExtensionMedia) {
  1200.                     $dish->imageURL $imageService->getImageURLCached($dish->images[count($dish->images) - 1], 5400);
  1201.                 } else if ($dish->images[count($dish->images) - 1]) {
  1202.                     $dish->imageURL $dish->images[count($dish->images) - 1]->imageUrl;
  1203.                 }
  1204.             }
  1205.             $key array_search($dish->idarray_column($dishPurchaseCount'id'), true);
  1206.             $dish->purchaseCount = isset($dishPurchaseCount[$key]['cnt']) && $key !== false $dishPurchaseCount[$key]['cnt'] : 0;
  1207.             $keyDay array_search($dish->idarray_column($dishPurchaseDayCount'id'), true);
  1208.             $dish->purchaseDayCount = isset($dishPurchaseDayCount[$keyDay]['cnt']) && $keyDay !== false
  1209.                 $dishPurchaseDayCount[$keyDay]['cnt']
  1210.                 : 0;
  1211.             $deliveryTime $productFastDeliveryService->findProductFastDelivery($offerCached$dish->originId);
  1212.             $dish->fastDeliveryTime CustomProductOfferSorter::DEFAULT_POSITION;
  1213.             if ($deliveryTime) {
  1214.                 $dish->fastDelivery $deliveryTime;
  1215.                 $dish->fastDeliveryTime = (int) $deliveryTime['time'];
  1216.             }
  1217.             if (isset($dish->variants) && count($dish->variants) > 0) {
  1218.                 $offerExtensionVariants array_reduce(
  1219.                     $extensions[$dish->originId]->getVariants()->getValues(),
  1220.                     static function (array $variantsOfferExtensionVariant $variant)
  1221.                     {
  1222.                         $variants[$variant->getPartnerID()] = $variant;
  1223.                         return $variants;
  1224.                     },
  1225.                     [],
  1226.                 );
  1227.                 foreach ($dish->variants as $key => $variant) {
  1228.                     if (!array_key_exists($variant->id$offerExtensionVariants)) {
  1229.                         unset($dish->variants[$key]);
  1230.                         continue;
  1231.                     }
  1232.                     /**
  1233.                      * @var $offerExtensionVariant OfferExtensionVariant
  1234.                      */
  1235.                     $offerExtensionVariant $offerExtensionVariants[$dish->variants[$key]->partnerId];
  1236.                     $dish->variants[$key]->id $offerExtensionVariant->getID();
  1237.                     if (PriceDeliveryType::PERCENT_PRICE === $offerExtension->getPriceDeliveryType()) {
  1238.                         $dish->variants[$key]->offerPrice = (float) PriceDeliveryType::calcDeliveryPickupPrice(
  1239.                             $offerExtension,
  1240.                             $typePrice,
  1241.                             $dish->variants[$key]->regularPrice,
  1242.                             $offerExtension->getCurrentPrice(null$typePrice),
  1243.                         );
  1244.                     }
  1245.                 }
  1246.             }
  1247.             $data['dishes'][] = $dish;
  1248.         }
  1249.         $data['dishes'] = $visibilityFilterService->filterInvisibleExtensions($data['dishes']);
  1250.         $sortType $request->query->get('sort'CustomProductOfferSorter::DEFAULT_CUSTOM_PRODUCT_SORT);
  1251.         $data['dishes'] = $productSorter->sort($data['dishes'], $sortType);
  1252.         $dishGroup $orderUtil->getDishGroups();
  1253.         $foodDishExtensionId $request->query->get('extension');
  1254.         if (null !== $foodDishExtensionId) {
  1255.             $dishKey array_search($foodDishExtensionId, \array_column($data['dishes'], 'id'));
  1256.             $foodCourtExtensionDish $data['dishes'][$dishKey];
  1257.             unset($data['dishes'][$dishKey]);
  1258.             array_unshift($data['dishes'], $foodCourtExtensionDish);
  1259.             if (count($dishGroup)) {
  1260.                 $category $isSushiHouse $foodCourtExtensionDish->parentGroup $foodCourtExtensionDish->groupName;
  1261.                 $keyDishGroup array_search($category$dishGroup);
  1262.                 $group $dishGroup[$keyDishGroup];
  1263.                 unset($dishGroup[$keyDishGroup]);
  1264.                 array_unshift($dishGroup$group);
  1265.             }
  1266.         }
  1267.         $data['topDishIDList'] = [];
  1268.         for ($i 0$i 3$i++) {
  1269.             if (isset($dishPurchaseCount[$i]['id'])) {
  1270.                 $data['topDishIDList'][] = $dishPurchaseCount[$i]['id'];
  1271.             }
  1272.         }
  1273.         if ($orderUtil::DISH_BY_GROUP) {
  1274.             $dishByGroupLabel = [];
  1275.             $dishByGroupContent = [];
  1276.             if ($isSushiHouse || $isSushiChefArts) {
  1277.                 foreach ($data['dishes'] as $dish) {
  1278.                     $dishByGroupContent[$dish->groupName][] = $dish;
  1279.                     if (!in_array($dish->parentGroup$dishByGroupLabel)) {
  1280.                         $dishByGroupLabel[$dish->groupName] = $dish->parentGroup;
  1281.                     }
  1282.                 }
  1283.                 if ($isSushiHouse) {
  1284.                     $dishByGroupContent $this->customSortDishByGroup($dishByGroupContent$dishGroup);
  1285.                 }
  1286.             }
  1287.             if ($isDominos) {
  1288.                 foreach ($data['dishes'] as $dish) {
  1289.                     $dish->parentGroup $dish->groupName;
  1290.                     $dishByGroupContent[$dish->groupName][] = $dish;
  1291.                     if (!in_array($dish->groupName$dishByGroupLabeltrue)) {
  1292.                         $dishByGroupLabel[$dish->groupName] = $dish->groupName;
  1293.                     }
  1294.                 }
  1295.             }
  1296.             $data['dishByGroup'] = [
  1297.                 'content' => $dishByGroupContent,
  1298.                 'label' => $dishByGroupLabel,
  1299.             ];
  1300.         }
  1301.         $dishGroup $foodByOnlineCategoriesBuilder->create($offerId,$data['dishes']);
  1302.         if (!empty($dishGroup)) {
  1303.             $data['dishByGroup'] = array_key_exists('dishByGroup'$data)
  1304.                 ? [
  1305.                     'content' => array_merge($dishGroup['content'], $data['dishByGroup']['content']),
  1306.                     'label' => array_merge($dishGroup['label'], $data['dishByGroup']['label']),
  1307.                 ]
  1308.                 : $dishGroup;
  1309.         }
  1310.         $options $isSushiVesla
  1311.             $orderUtil->getOptionsDBByShippingType(
  1312.                 $imageService,
  1313.                 \array_filter($allDishes, static fn (OfferExtension $offerExtension): bool => $offerExtension instanceof FoodOfferOptionExtension)
  1314.             )
  1315.             : $this->getOptions($imageService$offerCached$orderUtil0$isDominos $shippingType null);
  1316.         $data['options'] = $customProductOfferSorter->sort(
  1317.             $visibilityFilterService->filterInvisibleExtensions($options),
  1318.             CustomProductOfferSorter::DEFAULT_CUSTOM_PRODUCT_SORT,
  1319.         );
  1320.         $data['sortList'] = CustomProductOfferSorter::SORT_LIST;
  1321.         $data['isAvailableOnFood'] = $offerCached->isAvailableOnFood();
  1322.         $data['isAvailableOrderForToday'] = $shippingSchedulerService->availableOrderForToday($orderUtil$offerCached$typePrice);
  1323.         if ($isDominos) {
  1324.             $view CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/delivery_teaser_reload_pickup.html.twig' 'Slivki/delivery/delivery_teaser_reload_pickup.html.twig';
  1325.         } else {
  1326.             $view CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/delivery_teaser_reload.html.twig' 'Slivki/delivery/delivery_teaser_reload.html.twig';
  1327.         }
  1328.         return $this->render($view$data);
  1329.     }
  1330.     private function calcPricePerKilogram(float $offerPriceint $weight): ?float
  1331.     {
  1332.         if (!$weight) {
  1333.             return null;
  1334.         }
  1335.         return \round(self::KILOGRAM $offerPrice $weight2);
  1336.     }
  1337.     /** @Route("/expresspizza-orders") */
  1338.     public function expressPizzaOrdersAction(Request $request) {
  1339.         $offerID 282278;
  1340.         $pass '67380b434f';
  1341.         $objectCode '0017-4-009';
  1342.         if ($pass != $request->query->get('pass')) {
  1343.             return new Response('ERROR: Wrong password!');
  1344.         }
  1345.         $date = \DateTime::createFromFormat('U'$request->query->get('date'));
  1346.         if (!$date) {
  1347.             return new Response('ERROR: Wrong date format!');
  1348.         }
  1349.         $entityManager $this->getDoctrine()->getManager();
  1350.         /** @var Connection $connection */
  1351.         $connection $entityManager->getConnection();
  1352.         $sql "select"
  1353.                 " offer_order.id as order_id,"
  1354.                 " offer_order.paid_at as order_datetime,"
  1355.                 " offer_order.delivery_time as delivery_datetime,"
  1356.                 " user_address.name as client_name,"
  1357.                 " user_address.phone as client_phone,"
  1358.                 " user_address.pickup as pickup,"
  1359.                 " street.name as street_name,"
  1360.                 " user_address.house as house,"
  1361.                 " user_address.block as block,"
  1362.                 " user_address.entrance as entrance,"
  1363.                 " user_address.floor as floor,"
  1364.                 " user_address.doorphone as doorphone,"
  1365.                 " user_address.appartment as appartment,"
  1366.                 " offer_extension.partner_item_id as product_code,"
  1367.                 " offer_extension.name as product_name,"
  1368.                 " offer_order_details.items_count as items_count,"
  1369.                 " offer_extension.dish_delivery_price as delivery_price,"
  1370.                 " offer_extension.pickup_price as pickup_price,"
  1371.                 " offer_order.parameter_int_0 as payment_type,"
  1372.                 " offer_order.comment as comment,"
  1373.                 " coalesce(geo_location.pickup_point_partner_id, '$objectCode') as object_code"
  1374.             " from offer_order_details"
  1375.             " inner join offer_order on offer_order.id = offer_order_details.offer_order_id"
  1376.             " inner join user_address on offer_order.delivery_address_id = user_address.id"
  1377.             " left join street on user_address.street_id = street.id"
  1378.             " left join geo_location on user_address.geo_location_id = geo_location.id"
  1379.             " inner join offer_extension on offer_extension.id = offer_order_details.offer_extension_id"
  1380.             " where offer_order.offer_id = $offerID and offer_order.status > 0 and"
  1381.                 " offer_order.paid_at >= '" $date->format('Y-m-d H:i') . "'"
  1382.             " order by offer_order.id";
  1383.         $orderDetails $connection->executeQuery($sql)->fetchAll(\PDO::FETCH_ASSOC);
  1384.         $result = [];
  1385.         foreach ($orderDetails as $orderDetail) {
  1386.             $orderDateTime = new \DateTime($orderDetail['order_datetime']);
  1387.             $deliveryDateTime = new \DateTime();
  1388.             if ($orderDetail['delivery_datetime'] != 'Ближайшее') {
  1389.                 $deliveryDateTime = new \DateTime($orderDetail['delivery_datetime']);
  1390.             }
  1391.             $comment '';
  1392.             if (trim($orderDetail['entrance'])) {
  1393.                 $comment .= 'П' trim($orderDetail['entrance']) . ' ';
  1394.             }
  1395.             if (trim($orderDetail['floor'])) {
  1396.                 $comment .= 'Э' trim($orderDetail['floor']) . ' ';
  1397.             }
  1398.             if (trim($orderDetail['doorphone'])) {
  1399.                 $comment .= 'Д' trim($orderDetail['doorphone']) . ' ';
  1400.             }
  1401.             $paymentType '';
  1402.             switch ($orderDetail['payment_type']) {
  1403.                 case 1:
  1404.                     $paymentType 'Оплата: онлайн, ';
  1405.                     break;
  1406.                 case 2:
  1407.                     $paymentType 'Оплата: наличные, ';
  1408.                     break;
  1409.                 case 3:
  1410.                     $paymentType 'Оплата: терминал, ';
  1411.                     break;
  1412.                 case PaymentType::SLIVKI_PAY:
  1413.                     $paymentType 'Оплата: SlivkiPay, ';
  1414.                     break;
  1415.             }
  1416.             $comment .= $paymentType;
  1417.             $comment .= trim($orderDetail['comment']);
  1418.             $result[] = join(chr(9), [
  1419.                 $orderDetail['object_code'], // Код объекта
  1420.                 $orderDetail['order_id'], // Номер заказа
  1421.                 $orderDateTime->format('d.m.Y'), // Дата заказа
  1422.                 $orderDateTime->format('H:i'), // Время заказа
  1423.                 $deliveryDateTime->format('H:i'), // Изготовить к какому времени
  1424.                 $orderDetail['client_name'], // Имя клиента – Контакт
  1425.                 str_replace('+375''+375 '$orderDetail['client_phone']), // Контактный телефон.
  1426.                 $orderDetail['pickup'] ? 1// Тип получения: на месте (0) или доставка (1).
  1427.                 trim($orderDetail['street_name']) ?: ' '// Улица доставки
  1428.                 trim($orderDetail['house']) ?: ' '// Номер дома
  1429.                 trim($orderDetail['block']) ?: ' '// Корпус
  1430.                 trim($orderDetail['appartment']) ?: ' '// Квартира
  1431.                 ' '// Код группы
  1432.                 $orderDetail['product_code'], // Код товара
  1433.                 ' '// IDNT Номер выгрузки (оставляйте пустым)
  1434.                 $orderDetail['product_name'], // Название товара
  1435.                 $orderDetail['items_count'], // Количество
  1436.                 $orderDetail['pickup'] ? $orderDetail['pickup_price'] : $orderDetail['delivery_price'], // Цена
  1437.                 str_replace(["\r\n""\n"],' '$comment), // Примечание
  1438.             ]);
  1439.         }
  1440.         $result[] = chr(9) . 'OK';
  1441.         return new Response(join("\r\n"$result));
  1442.     }
  1443.     private function customSortDishByGroup(array $dishByGroupContent, array $sort): array
  1444.     {
  1445.         uasort($dishByGroupContent, function ($dishGroup1$dishGroup2) use ($sort) {
  1446.             if (!count($dishGroup1)) {
  1447.                 return 1;
  1448.             }
  1449.             if (!count($dishGroup2)) {
  1450.                 return -1;
  1451.             }
  1452.             $dishGroup1Key array_search($dishGroup1[0]->parentGroup$sort);
  1453.             $dishGroup2Key array_search($dishGroup2[0]->parentGroup$sort);
  1454.             return $dishGroup1Key $dishGroup2Key ? -1;
  1455.         });
  1456.         return $dishByGroupContent;
  1457.     }
  1458. }