src/Controller/IikoOrderController.php line 94

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