src/Controller/IikoOrderController.php line 132

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.             if (299624 != $offerID) { //TODO: remove after bepaid approve
  117.                 return $this->redirect($seoResourceService->getOfferSeo($offerID)->getMainAlias());
  118.             }
  119.         }
  121.         $orderUtil = AbstractDelivery::instance($offerCached);
  122.         $orderUtil->setContainer($container);
  124.         $isDominos = $orderUtil instanceof Dominos;
  125.         $isSushiHouse = $orderUtil instanceof SushiHouse;
  127.         $data['isDominos'] = $isDominos;
  128.         $data['showSortingIndexOrder'] = !($isSushiHouse || $isDominos);
  130.         $cityID = $entityManager->getRepository(Offer::class)->getCityID($offerID);
  131.         $city = $entityManager->find(City::class, $cityID);
  132.         $request->getSession()->set(City::CITY_ID_SESSION_KEY, $city->getID());
  133.         $request->getSession()->set(City::CITY_DOMAIN_SESSION_KEY, $city->getDomain());
  135.         $data['offer'] = $offerCached;
  136.         Logger::instance('IIKO-DEBUG')->info($offerID);
  138.         $director = $directorRepository->getById((int) $offerCached->getDirectorID());
  140.         $data['company'] = $director;
  142.         $data['domain'] = $orderUtil->getDomain();
  143.         if (null !== $offerCached->getOnlineOrderSettings() && $offerCached->getOnlineOrderSettings()->getDomain()) {
  144.             $data['domain'] = $offerCached->getOnlineOrderSettings()->getDomain();
  145.         }
  147.         $data['dishes'] = [];
  149.         $user = $this->getUser();
  150.         if (null !== $user) {
  151.             if ($subscriptionService->isSubscriber($user)) {
  152.                 $data['allowedCodesToBuy'] = $subscriptionService->getSubscription($user)->getNumberOfCodes();
  153.             } elseif ($user->isBatchCodesAllowed()) {
  154.                 $data['allowedCodesToBuyBatchCodes'] = $user->getBatchCodesCount();
  155.             }
  156.         }
  158.         $codeCost = $this->getOfferRepository()->getCodeCost($offerCached);
  160.         $data['options'] = [];
  161.         $data['robotsMeta'] = 'noindex, follow';
  162.         $data['offerID'] = $offerID;
  163.         $data['director'] = $director;
  164.         $data['minSumForFreeDelivery'] = $orderUtil->getMinSumForFreeDelivery();
  165.         $data['minOrderSum'] = $orderUtil->getMinOrderSum();
  166.         $data['foodOffer'] = true;
  167.         $data['formAction'] = '/delivery/order/checkout';
  168.         $data['showDelivery'] = true;
  169.         $data['categoryName'] = $orderUtil::CATEGORY_NAME;
  170.         $data['footerOfferConditionID'] = $offerID;
  171.         $data['categoryURL'] = $entityManager->getRepository(Seo::class)->getSeoForEntity(SeoRepository::RESOURCE_URL_OFFER_CATEGORY, $orderUtil::CATEGORY_ID)->getMainAlias();
  172.         $data['deliveryPrice'] = $orderUtil->getDeliveryPriceSettings();
  174.         $data['pickupEnabled'] = $orderUtil->isPickupEnabled();
  175.         $data['deliveryEnabled'] = $orderUtil->isDeliveryEnabled();
  176.         $data['isBuyCodeDisable'] = $offerCached->isBuyCodeDisable();
  177.         $data['isOnlineOrderAllowed'] = $offerCached->isFoodOnlineOrderAllowedOnSite();
  178.         $data['isAvailableOnFood'] = $offerCached->isAvailableOnFood();
  180.         $data['visitCount'] = $entityManager->getRepository(Visit::class)->getVisitCount($orderUtil::OFFER_ID, Visit::TYPE_OFFER, 30, true);
  181.         $data['filterAction'] = $foodFilterCounterRepository->findByOfferId((int) $offerID);
  183.         $purchaseCount = $purchaseCountRepository->findByOfferId((int) $offerID);
  184.         $data['purchaseCountMonth'] = null === $purchaseCount ? 0 : $purchaseCount->getPurchaseCountLastMonthWithCorrection();
  186.         $data['sortList'] = CustomProductOfferSorter::SORT_LIST;
  187.         $data['codeCost'] = $codeCost;
  188.         if (!$offerFastDeliveryDao->isOfferHasActiveFastDelivery($offerID)) {
  189.             unset($data['sortList'][CustomProductOfferSorter::FAST_CUSTOM_PRODUCT_SORT]);
  190.         }
  192.         $view = CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/order.html.twig' : 'Slivki/delivery/order.html.twig';
  193.         $response->setContent($this->renderView($view, $data));
  195.         return $response;
  196.     }
  198.     /** @Route("/delivery/order/checkout", name = "deliveryOrderCheckout") */
  199.     public function checkoutAction(
  200.         Request $request,
  201.         ShippingSchedulerService $shippingSchedulerService,
  202.         ContainerInterface $container,
  203.         ManagerRegistry $registry,
  204.         SeoResourceService $seoResourceService,
  205.         SubscriptionService $subscriptionService,
  206.         DeliveryZoneDaoInterface $deliveryZoneDao,
  207.         DeliveryZoneSorter $deliveryZoneSorter,
  208.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder
  209.     ) {
  210.         ini_set('memory_limit', '1g');
  211.         $additionalDominos = null;
  212.         $response = new Response();
  214.         $offerID = $request->request->getInt('offerID');
  215.         $entityManager = $this->getDoctrine()->getManager();
  216.         $requestBasket = $request->request->get('basket');
  217.         $pickupDeliveryType = empty($request->request->get('pickupDeliveryType')) ? FoodOfferExtension::DELIVERY_METHOD : $request->request->getInt('pickupDeliveryType');
  218.         if (!$requestBasket) {
  219.             return $this->redirectToRoute('deliveryOrder', ['offerID' => $offerID]);
  220.         }
  221.         $request->getSession()->set(OnlineOrderHistory::SORT_SESSION_NAME, $request->request->get('dishSortBy'));
  223.         /** @var Offer $offer */
  224.         $offer = $entityManager->find(Offer::class, $offerID);
  227.         $slivkiDeliveryOption = $entityManager->getRepository(EntityOption::class)->findBy([
  228.             'entityID' => $offerID,
  229.             'name' => EntityOption::OPTION_SLIVKI_DELIVERY
  230.         ]);
  232.         if (!$offer->hasFreeCodes()) {
  233.             return $this->redirect($seoResourceService->getOfferSeo($offerID)->getMainAlias());
  234.         }
  236.         $iikoUtil = AbstractDelivery::instance($offer);
  237.         $iikoUtil->setContainer($container);
  238.         $isSushiVesla = $iikoUtil instanceof SushiVesla;
  239.         $isDominos = $iikoUtil instanceof Dominos;
  240.         if ($isDominos) {
  241.             $dominosSpesialData = [
  242.                 'amountPizza' => 0,
  243.             ];
  244.         }
  246.         $requestBasket = json_decode($requestBasket, true);
  247.         $basket = [];
  248.         foreach ($requestBasket as $basketItem) {
  249.             $key = array_key_first($basketItem);
  250.             $variants = [];
  251.             if (is_array($basketItem[$key])) {
  252.                 foreach ($basketItem[$key] as $variantItem) {
  253.                     $variantKey = array_key_first($variantItem);
  254.                     $variants[$variantKey] = $variantItem[$variantKey];
  255.                 }
  256.             } else {
  257.                 $variants = $basketItem[$key];
  258.             }
  259.             $basket[$key] = $variants;
  260.         }
  262.         $totalDishCount = 0;
  263.         foreach ($basket as $dishID => $variants) {
  264.             $extension = $entityManager->find(OfferExtension::class, $dishID);
  265.             if (!$extension || $extension instanceof FoodOfferOptionExtension) {
  266.                 continue;
  267.             }
  268.             $dishCount = 0;
  269.             if (!is_array($variants)) {
  270.                 $dishCount = $variants;
  271.             } else {
  272.                 foreach ($variants as $variantID => $variantCount) {
  273.                     $extensionVariant = $entityManager->find(OfferExtensionVariant::class, $variantID);
  274.                     if (!$extensionVariant) {
  275.                         continue;
  276.                     }
  278.                     $dishCount += $variantCount;
  279.                     
  280.                     if ($isDominos) {
  281.                         $dominosSpesialData['amountPizza'] += $variantCount;
  282.                     }
  283.                 }
  284.             }
  285.             $totalDishCount += $dishCount;
  286.         }
  287.         
  288.         if ($isDominos && $dominosSpesialData['amountPizza'] === 0) {
  289.             return new JsonResponse(['status' => 'error', 'error' => true, 'message' => 'Скидка на доп. меню действует только при заказе пиццы']);
  290.         }
  292.         if ($totalDishCount == 0) {
  293.             return $this->redirectToRoute('deliveryOrder', ['offerID' => $offerID]);
  294.         }
  296.         $user = $this->getUser();
  298.         /** @var OfferOrder $order */
  299.         $order = new FoodOrder();
  300.         $order->setUser($user);
  301.         $order->setStatus(FoodOrder::STATUS_INIT);
  302.         $order->setOffer($offer);
  304.         $totalAmount = 0;
  305.         $totalOfferAmount = 0;
  306.         $codesCount = 0;
  307.         $city = $entityManager->find(City::class, $iikoUtil::CITY_ID);
  308.         $request->getSession()->set(City::CITY_ID_SESSION_KEY, $city->getID());
  309.         $request->getSession()->set(City::CITY_DOMAIN_SESSION_KEY, $city->getDomain());
  311.         $offersDetails = [];
  313.         foreach ($basket as $dishID => $variants) {
  314.             /** @var OfferExtension $extension */
  315.             $extension = $entityManager->find(OfferExtension::class, $dishID);
  316.             if (!$extension) {
  317.                 continue;
  318.             }
  319.             if (is_array($variants)) {
  320.                 foreach ($variants as $variantID => $variantCount) {
  321.                     /** @var OfferExtensionVariant $extensionVariant */
  322.                     $extensionVariant = $entityManager->find(OfferExtensionVariant::class, $variantID);
  323.                     if (!$extensionVariant) {
  324.                         continue;
  325.                     }
  326.                     $productsPerCode = $extension->getProductsPerCode();
  327.                     if ($productsPerCode > 0) {
  328.                         $codesCount += $productsPerCode == 1 ? $variantCount : $variantCount/$productsPerCode;
  329.                     }
  331.                     $variantOfferPrice = PriceDeliveryType::calcDeliveryPickupPrice(
  332.                         $extension,
  333.                         $pickupDeliveryType,
  334.                         $extensionVariant->getRegularPrice(),
  335.                         $extensionVariant->getOfferPrice(),
  336.                         $additionalDominos
  337.                     );
  339.                     $totalOfferAmount += $variantCount * $variantOfferPrice;
  340.                     $totalAmount += $variantCount * $extensionVariant->getRegularPrice();
  342.                     $details = new OfferOrderDetails();
  343.                     $details->setOfferExtension($extension);
  344.                     $details->setOfferExtensionVariant($extensionVariant);
  345.                     $details->setItemsCount($variantCount);
  346.                     $order->addOfferOrderDetails($details);
  347.                 }
  348.             } else {
  349.                 $count = (int) $variants;
  350.                 if (0 === $count) {
  351.                     continue;
  352.                 }
  354.                 $product = $isSushiVesla
  355.                     ? $iikoUtil->getProductByDB($extension->getPartnerItemID(), $registry)
  356.                     : $iikoUtil->getProduct($extension->getPartnerItemID());
  358.                 if ($product->regularPrice == 0) {
  359.                     $product->regularPrice = $extension->getPrice();
  360.                 }
  362.                 $totalAmount += $count * $product->regularPrice;
  364.                 $recalculatedOfferPriceValue = PriceDeliveryType::calcDeliveryPickupPrice(
  365.                     $extension,
  366.                     $pickupDeliveryType,
  367.                     $product->regularPrice,
  368.                     $extension->getCurrentPrice(null, $pickupDeliveryType),
  369.                 );
  370.                 $product->offerPrice = $recalculatedOfferPriceValue;
  372.                 $totalOfferAmount += $count * $product->offerPrice;
  374.                 if (!$extension instanceof FoodOfferOptionExtension) {
  375.                     $productsPerCode = $extension->getProductsPerCode();
  376.                     if ($productsPerCode > 0) {
  377.                         $codesCount += $productsPerCode == 1 ? $count : $count/$productsPerCode;
  378.                     }
  379.                 }
  380.                 $details = new OfferOrderDetails();
  381.                 $details->setOfferExtension($extension);
  382.                 $details->setItemsCount($count);
  383.                 $order->addOfferOrderDetails($details);
  384.             }
  385.         }
  387.         $codesCount = \ceil($codesCount);
  388.         $totalAmountWithoutCode = $totalOfferAmount;
  389.         $codeCost = $pricePromocodeForOnlineOrder->getPrice($order, $offer, $codesCount, $totalAmountWithoutCode);
  390.         $codeCostRegular = $codeCost;
  392.         $user = $order->getUser();
  393.         $allowedCodesToBuyBalance = false;
  394.         if ($subscriptionService->isSubscriber($user) || $user->isBatchCodesAllowed()) {
  395.             $codeCost = 0;
  396.         } elseif ($user->isBalanceAllowed($codesCount * $codeCost)) {
  397.             $codeCost = 0;
  398.             $allowedCodesToBuyBalance = true;
  399.         }
  401.         $totalOfferAmount += $codesCount * $codeCost;
  402.         $order->setCodesCount($codesCount);
  403.         $order->setCodeCost($codeCostRegular);
  404.         $deliveryPrice = $iikoUtil->getMinSumForFreeDelivery() > 0 && $totalAmountWithoutCode < $iikoUtil->getMinSumForFreeDelivery() ? $iikoUtil->getDeliveryPriceSettings() : 0;
  406.         // Delivery price will be calculated after choosing the address
  407.         if (null !== $offer->getOfferDeliveryZone() && $offer->getOfferDeliveryZone()->count() > 0) {
  408.             $deliveryPrice = 0;
  409.         }
  411.         if ($pickupDeliveryType === FoodOfferExtension::DELIVERY_METHOD_PICKUP) {
  412.             $deliveryPrice = 0;
  413.         }
  415.         $order->setAmount($totalOfferAmount + $deliveryPrice);
  416.         $order->setDeliveryCost($deliveryPrice);
  417.         if (CommonUtil::isMobileDevice($request)) {
  418.             $order->setDeviceType(SiteController::DEVICE_TYPE_MOBILE);
  419.         } else {
  420.             $order->setDeviceType(SiteController::DEVICE_TYPE_DESKTOP);
  421.         }
  422.         $entityManager->persist($order);
  423.         $entityManager->flush();
  424.         $entityManager->detach($order);
  426.         $deliveryAddresses = $user->getAvailableUserAddresses($offerID);
  427.         $defaultDeliveryAddress = empty($deliveryAddresses) ? false : $deliveryAddresses[0];
  429.         $deliveryAddressesGift = $user->getAvailableUserAddressesGift($offerID);
  430.         if ($order->isOnlineGift()) {
  431.             $defaultDeliveryAddress = $deliveryAddressesGift[0] ?? false;
  432.             $deliveryAddresses = $deliveryAddressesGift;
  433.         }
  435.         $brandboxEnabled = $offer->getBrandboxEnabled();
  436.         $deliveryEnabled = $iikoUtil->isDeliveryEnabled();
  437.         $pickupEnabled = $iikoUtil->isPickupEnabled();
  439.         $isAjaxScheduleForDelivery = false;
  440.         $schedule = $shippingSchedulerService->getEmptySchedule($iikoUtil, $pickupDeliveryType);
  441.         if (
  442.             ($brandboxEnabled && $pickupDeliveryType === FoodOfferExtension::DELIVERY_METHOD && $deliveryAddresses) ||
  443.             (!$brandboxEnabled && $deliveryEnabled && $deliveryAddresses)
  444.         ) {
  445.             $schedule = $shippingSchedulerService->getDeliverySchedule($iikoUtil, $pickupDeliveryType);
  446.         }
  448.         $citySelect = '';
  449.         $citySelectData = $iikoUtil->getCitySelectData($entityManager);
  450.         if ($citySelectData) {
  451.             $citySelect = $this->renderView(CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/city_select.html.twig'
  452.                 : 'Slivki/delivery/city_select.html.twig', ['deliveryLocations' => $citySelectData]);
  453.         }
  455.         $workHourFrom = 0;
  456.         $workHourTo = 0;
  458.         $pickupLocations = '';
  459.         $defaultLocationID = null;
  460.         /** @var GeoLocation $geoLocation */
  461.         foreach ($offer->getGeoLocations() as $geoLocation) {
  462.             if (!$geoLocation->isActive()) {
  463.                 continue;
  464.             }
  466.             if (!$defaultLocationID) {
  467.                 $defaultLocationID = $geoLocation->getID();
  468.             }
  470.             $pickupPointScheduleParsed = $geoLocation->getPickupPointScheduleParsed();
  471.             if (!$pickupPointScheduleParsed) {
  472.                 continue;
  473.             }
  475.             $pickupLocations .= $this->renderView('Slivki/delivery/pickup_location_item.html.twig', [
  476.                 'location' => $geoLocation,
  477.             ]);
  478.         }
  480.         $nearestTime = 'Ближайшее';
  482.         $deliveryTimeFrom = $iikoUtil->getDeliveryTimeFrom();
  483.         $deliveryTimeTill = $iikoUtil->getDeliveryTimeTill();
  485.         $additionalDominos = !(null === $additionalDominos);
  486.         $this->reCalcOrder(
  487.             $order,
  488.             0,
  489.             $pickupDeliveryType,
  490.             $subscriptionService->isSubscriber($this->getUser()),
  491.             $pricePromocodeForOnlineOrder
  492.         );
  494.         $data = [
  495.             'order' => $order,
  496.             'offer' => $offer,
  497.             'codeCost' => $codeCost,
  498.             'codeCostRegular' => $codeCostRegular,
  499.             'deliveryPrice' => $deliveryPrice,
  500.             'offerURL' => $entityManager->getRepository(Seo::class)->getOfferURL($offer->getID())->getMainAlias(),
  501.             'totalAmount' => $totalAmount + $deliveryPrice,
  502.             'director' => $offer->getDirectors()->first(),
  503.             'robotsMeta' => 'noindex, follow',
  504.             'offerID' => $offerID,
  505.             'showCheckAddressButton' => $iikoUtil::SHOW_CHECK_ADDRESS_BUTTON,
  506.             'streetSuggest' => $iikoUtil::STREET_SUGGEST,
  507.             'workHourFrom' => $workHourFrom,
  508.             'workHourTo' => $workHourTo,
  509.             'citySelect' => $citySelect,
  510.             'multipleLocationDelivery' => $iikoUtil::MULTIPLE_LOCATIONS_DELIVERY,
  511.             'formAction' => '/delivery/order/check-payment',
  512.             'categoryName' => $iikoUtil::CATEGORY_NAME,
  513.             'categoryURL' => $entityManager->getRepository(Seo::class)->getSeoForEntity(SeoRepository::RESOURCE_URL_OFFER_CATEGORY, $iikoUtil::CATEGORY_ID)->getMainAlias(),
  514.             'pickupLocations' => $pickupLocations,
  515.             'nearestTimeLabel' => $nearestTime,
  516.             'showDelivery' => true,
  517.             'defaultLocationID' => $defaultLocationID,
  518.             'pickupEnabled' => $pickupEnabled,
  519.             'deliveryEnabled' => $deliveryEnabled,
  520.             'allowedPaymentMethods' => $iikoUtil->getAllowedPaymentMethods(),
  521.             'footerOfferConditionID' => $offerID,
  522.             'pickupDiscount' => $iikoUtil->getPickupDiscount(),
  523.             'pickupDeliveryType' => $pickupDeliveryType,
  524.             'deliveryTimeFrom' => $deliveryTimeFrom,
  525.             'deliveryTimeTill' => $deliveryTimeTill,
  526.             'orderPeriodInDays' => $iikoUtil->getOrderPeriodInDays(),
  527.             'offersDetails' => $offersDetails,
  528.             'schedule' => $schedule,
  529.             'deliveryAddresses' => $deliveryAddresses,
  530.             'deliveryAddressesGift' => $deliveryAddressesGift,
  531.             'defaultDeliveryAddress' => $defaultDeliveryAddress,
  532.             'brandboxEnabled' => $brandboxEnabled,
  533.             'additionalDominos' => $additionalDominos,
  534.             'isSushiVesla' => $isSushiVesla,
  535.             'isDominos' => $isDominos,
  536.             'isAjaxScheduleForDelivery' => $isAjaxScheduleForDelivery,
  537.             'isOnlineGift' => $offer->isOnlineOrderGiftEnabled(),
  538.             'allowedCodesToBuyBalance' => $allowedCodesToBuyBalance,
  539.             'deliveryZones' => $deliveryZoneSorter->sortByDefault($deliveryZoneDao->findByOfferId($offerID)),
  540.             'offerForSlivkiDelivery' => $slivkiDeliveryOption,
  541.         ];
  543.         $data['iikoOrder'] = true;
  545.         $view = CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/delivery_checkout.html.twig' : 'Slivki/delivery/delivery_checkout.html.twig';
  547.         $content = $this->renderView($view, $data);
  548.         $response->setContent($content);
  550.         $response->headers->addCacheControlDirective('no-cache', true);
  551.         $response->headers->addCacheControlDirective('max-age', 0);
  552.         $response->headers->addCacheControlDirective('must-revalidate', true);
  553.         $response->headers->addCacheControlDirective('no-store', true);
  555.         return $response;
  556.     }
  558.     /**
  559.      * @Route("/delivery/order/payment/{orderID}", name="delivery_order_payment")
  560.      */
  561.     public function deliveryOrderPaymentAction(
  562.         Request $request,
  563.         PartnerBePaidService $partnerBePaidService,
  564.         OnlineOrderHistoryHandler $onlineOrderHistoryHandler,
  565.         SubscriptionService $subscriptionService,
  566.         CreditCardRepositoryInterface $creditCardRepository,
  567.         DirectorRepositoryInterface $directorRepository,
  568.         VirtualWalletChecker $virtualWalletChecker,
  569.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder,
  570.         $orderID
  571.     ) {
  572.         $entityManager = $this->getDoctrine()->getManager();
  573.         $response = new Response();
  574.         /** @var FoodOrder $order */
  575.         $order = $entityManager->find(FoodOrder::class, $orderID);
  576.         if (!$order) {
  577.             throw $this->createNotFoundException();
  578.         }
  580.         $user = $order->getUser();
  581.         $offer = $order->getOffer();
  582.         $offerID = $offer->getID();
  583.         $iikoUtil = IikoUtil::instance($offer);
  584.         $iikoUtil->setContainer($this->kernel->getContainer());
  586.         $isPickup = $order->getDeliveryAddress()->isPickup();
  588.         $detailIdCount = [];
  589.         $totalAmount = 0;
  590.         /** @var OfferOrderDetails $details */
  591.         $extensionIds = [];
  592.         foreach ($order->getOfferOrderDetails() as $details) {
  593.             $extension = $details->getOfferExtension();
  594.             $extensionIds[] = $extension->getId();
  596.             if ($iikoUtil instanceof SushiHouse) {
  597.                 if (isset($detailIdCount[$extension->getID()])) {
  598.                     $detailIdCount[$extension->getID()] += $details->getItemsCount();
  599.                 } else {
  600.                     $detailIdCount[$extension->getID()] = $details->getItemsCount();
  601.                 }
  602.             }
  604.             $variant = $details->getOfferExtensionVariant();
  605.             $regularPrice = $variant ? $variant->getRegularPrice() : $details->getOfferExtension()->getPrice();
  606.             $totalAmount += $details->getItemsCount() * $regularPrice;
  608.             $sortByFromDelivery = $request->getSession()->get(OnlineOrderHistory::SORT_SESSION_NAME);
  609.             if (null !== $sortByFromDelivery) {
  610.                 $onlineOrderHistoryHandler->handle(
  611.                     $order,
  612.                     $extension->getID(),
  613.                     $sortByFromDelivery
  614.                 );
  615.             }
  616.         }
  618.         $request->getSession()->set(OnlineOrderHistory::SORT_SESSION_NAME, null);
  620.         $pickupDeliveryType = $isPickup ? FoodOfferExtension::DELIVERY_METHOD_PICKUP : FoodOfferExtension::DELIVERY_METHOD;
  622.         $deliveryCost = 0;
  623.         if ($pickupDeliveryType === FoodOfferExtension::DELIVERY_METHOD || !$isPickup) {
  624.             $totalAmount += $order->getDeliveryCost();
  626.             $deliveryCost = $order->getDeliveryCost();
  627.         }
  629.         $codeCost = $order->getCodeCost();
  630.         $regularCodeCost = $codeCost;
  632.         $allowedCodesToBuyBalance = false;
  633.         if ($subscriptionService->isSubscriber($user) || $user->isBatchCodesAllowed()) {
  634.             $codeCost = 0;
  635.         } elseif ($user->isBalanceAllowed($codeCost * $order->getCodesCount())) {
  636.             $codeCost = 0;
  637.             $allowedCodesToBuyBalance = true;
  638.         }
  640.         $partnerBePaidService->setOrder($order);
  641.         $paymentToken = $partnerBePaidService->getPaymentToken($order, null, $codeCost);
  643.         $view = CommonUtil::isMobileDevice($request)
  644.             ? 'Slivki/mobile/delivery/delivery_payment.html.twig'
  645.             : 'Slivki/delivery/delivery_payment.html.twig';
  647.         $offersDetails = [];
  649.         $director = $directorRepository->findById($offer->getDirectorID());
  651.         $fullOrderAmount = $order->getAmount();
  652.         if ($allowedCodesToBuyBalance) {
  653.             $fullOrderAmount += $regularCodeCost * $order->getCodesCount();
  654.         }
  656.         $this->reCalcOrder(
  657.             $order,
  658.             0,
  659.             $pickupDeliveryType,
  660.             $subscriptionService->isSubscriber($this->getUser()),
  661.             $pricePromocodeForOnlineOrder
  662.         );
  664.         $content =  $this->renderView($view, [
  665.             'order' => $order,
  666.             'offer' => $offer,
  667.             'offerURL' => $entityManager->getRepository(Seo::class)->getOfferURL($offerID)->getMainAlias(),
  668.             'offerID' => $offerID,
  669.             'categoryName' => $iikoUtil::CATEGORY_NAME,
  670.             'deliveryPrice' => $deliveryCost,
  671.             'codeCost' => $codeCost,
  672.             'totalAmount' => $totalAmount,
  673.             'showCheckAddressButton' => false,
  674.             'categoryURL' => $entityManager->getRepository(Seo::class)->getSeoForEntity(SeoRepository::RESOURCE_URL_OFFER_CATEGORY, $iikoUtil::CATEGORY_ID)->getMainAlias(),
  675.             'isPickup' => $isPickup,
  676.             'allowedPaymentMethods' => $iikoUtil->getAllowedPaymentMethods()[$isPickup ? 'pickup' : 'delivery'],
  677.             'pickupDiscount' => $isPickup ? $iikoUtil->getPickupDiscount() : 0,
  678.             'pickupDeliveryType' => $pickupDeliveryType,
  679.             'paymentToken' => $paymentToken['checkout']['token'],
  680.             'offersDetails' => $offersDetails,
  681.             'additionalDominos' => false,
  682.             'isDominos' => $iikoUtil instanceof Dominos,
  683.             'activeCreditCards' => !$offer->isRecurrentDisabled() ? $creditCardRepository->findActiveByUser($user) : [],
  684.             'directorName' => $director instanceof Director ? $director->getName() : '',
  685.             'allowedCodesToBuyBalance' => $allowedCodesToBuyBalance,
  686.             'isSlivkiPayAllowed' => $virtualWalletChecker->availableSlivkiPay($fullOrderAmount, $user),
  687.             'allowedCashbackSumToPay' => $iikoUtil->getAllowedCashbackSumToPay($order, $entityManager),
  688.             'allowedFastDeliveryForSushiHouse' => $iikoUtil->enabledFastDelivery($order),
  689.         ]);
  690.         $response->setContent($content);
  692.         return $response;
  693.     }
  695.     /** @Route("/delivery/order/check-payment", name = "deliveryOrderCheckPayment") */
  696.     public function checkPaymentAction(
  697.         Request $request,
  698.         CoordinatesYandex $coordinatesYandex,
  699.         DeliveryZoneRepositoryInterface $deliveryZoneRepository,
  700.         ShippingSchedulerService $shippingSchedulerService,
  701.         SubscriptionService $subscriptionService,
  702.         PhoneNumberUtil $phoneNumberUtil,
  703.         PhoneNumberHelper $phoneNumberHelper,
  704.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder,
  705.         VisibilityFilterService $visibilityFilterService
  706.     ) {
  707.         if (!$request->isMethod(Request::METHOD_POST)) {
  708.             throw $this->createNotFoundException();
  709.         }
  711.         $entityManager = $this->getDoctrine()->getManager();
  712.         $orderID = $request->request->getInt('orderID');
  713.         $pickupDeliveryType = $request->request->get('pickupDeliveryType');
  714.         $pickupDeliveryType = $pickupDeliveryType ? (int) $pickupDeliveryType : null;
  715.         $isOnlineOrderGift = $request->request->getBoolean('isOnlineGift');
  717.         $discount = 0;
  718.         /** @var FoodOrder $order */
  719.         $order = $entityManager->find(FoodOrder::class, $orderID);
  720.         if (!$order || $order->getUser()->getID() != $this->getUser()->getID() || $order->getStatus() != FoodOrder::STATUS_INIT) {
  721.             throw $this->createNotFoundException();
  722.         }
  723.         $order->setComment($request->request->get('comment'));
  724.         $order->setDeliveryTime($request->request->get('deliveryTime'));
  725.         $order->setIsOnlineGift($isOnlineOrderGift);
  726.         $iikoUtil = IikoUtil::instance($order->getOffer());
  727.         $iikoUtil->setContainer($this->kernel->getContainer());
  729.         $possibilityOrder = $iikoUtil->getPossibilityOrderStatus($order);
  730.         if ($possibilityOrder['status'] === 'error') {
  731.             return new JsonResponse(['status' => 'error', 'error' => true, 'message' => $possibilityOrder['message']]);
  732.         }
  734.         $isSushiHouse = $iikoUtil instanceof SushiHouse;
  735.         $isSushiVesla = $iikoUtil instanceof SushiVesla;
  737.         if (!$isSushiHouse && !$isSushiVesla) {
  738.             $this->reCalcOrder(
  739.                 $order,
  740.                 0,
  741.                 $pickupDeliveryType,
  742.                 $subscriptionService->isSubscriber($this->getUser()),
  743.                 $pricePromocodeForOnlineOrder
  744.             );
  745.         }
  747.         $request->getSession()->set("pickupDiscount", null);
  748.         if ($request->request->has('pickup')) {
  749.             $addressID = $request->request->getInt('pickupAddressID');
  750.             $discount = $request->request->getInt('pickupDiscount');
  751.             $request->getSession()->set("pickupDiscount", $discount);
  752.             $geoLocation = $entityManager->find(GeoLocation::class, $addressID);
  753.             $userAddresses = $entityManager->getRepository(UserAddress::class)->findBy(['user' => $this->getUser(), 'geoLocation' => $geoLocation]);
  754.             $address = null;
  755.             foreach ($userAddresses as $location) {
  756.                 if ($location->getGeoLocation()->getID() == $addressID) {
  757.                     $address = $location;
  758.                     break;
  759.                 }
  760.             }
  761.             if (!$address) {
  762.                 $address = new UserAddress();
  763.                 $address->setUser($this->getUser());
  764.                 $address->setGeoLocation($geoLocation);
  765.                 $address->setOfferID($order->getOffer()->getID());
  766.                 $entityManager->persist($address);
  767.             }
  769.             $address->setPickup(true);
  770.         } else {
  771.             $address = $entityManager->find(UserAddress::class, $request->request->getInt('addressID'));
  772.             $geoLocation = null;
  773.         }
  774.         if ($address) {
  775.             $name = $request->request->get('name', '');
  776.             $phone = $request->request->get('phone', '');
  778.             if (trim($name) == '' || trim($phone) == '') {
  779.                 return new JsonResponse(['error' => true]);
  780.             }
  782.             if (\mb_strlen($phone) > 0) {
  783.                 $phoneNumberObject = $phoneNumberUtil->parse($phone);
  785.                 if (!$phoneNumberUtil->isValidNumber($phoneNumberObject)) {
  786.                     return new JsonResponse(['error' => true, 'message' => 'Введен некорректный номер телефона']);
  787.                 }
  788.             }
  790.             $address->setPhone($phone);
  791.             $address->setName($name);
  792.             $address->setIsOnlineGift($isOnlineOrderGift);
  793.             if ($isOnlineOrderGift) {
  794.                 $address->setNameGift($request->request->get('nameGift'));
  795.                 $address->setPhoneNumberGift(
  796.                     $phoneNumberHelper->convert($request->request->get('phoneNumberGift'), ''),
  797.                 );
  798.             }
  800.             $order->setDeliveryAddress($address);
  801.         } else {
  802.             return new JsonResponse(['error' => true, 'message' => 'Не выбран адрес']);
  803.         }
  805.         $result = $iikoUtil->checkOrder($entityManager, $order, $subscriptionService);
  807.         if (!$result || $result->resultState > 0) {
  808.             $message = null;
  809.             if ($result) {
  810.                 switch ($result->resultState) {
  811.                     case 1:
  812.                         if (isset($result->problem)) {
  813.                             $message = $result->problem;
  814.                         }
  815.                         if (isset($result->minSumForFreeDelivery)) {
  816.                             $message = \sprintf('Минимальная сумма заказа %s руб.', (string) $result->minSumForFreeDelivery);
  817.                         }
  818.                         break;
  819.                     case 2:
  820.                         $message = 'Извините, в данное время заказ невозможен. Пожалуйста, выберите другое время';
  821.                         break;
  822.                     case 3:
  823.                         $message = 'Извините, на данный адрес доставка не осуществляется';
  824.                         break;
  825.                     case 4:
  826.                     case 5:
  827.                         $message = 'На данный момент заказ одного из товаров невозможен';
  828.                         break;
  829.                     case 9999:
  830.                         $message = 'Заказы принимаются с 11:00 по 22:20';
  831.                         break;
  832.                 }
  833.             }
  834.             return new JsonResponse(['error' => true, 'message' => $message]);
  835.         }
  837.         try {
  838.             $visibilityFilterService->assertAllVisibleOrFail(array_map(
  839.                 static fn (OfferOrderDetails $orderDetail) => $orderDetail->getOfferExtension(),
  840.                 $order->getOfferOrderDetails()->toArray(),
  841.             ));
  842.         } catch (OfferExtensionNotVisibleException $e) {
  843.             return new JsonResponse(['error' => true, 'message' => $e->getMessage()]);
  844.         }
  846.         if ($request->request->get('deliveryTime') !== self::NEARLY) {
  847.             if ($request->request->get('deliveryTime') === null) {
  848.                 $checkSchedule = [
  849.                     'status' => 'error',
  850.                     'message' => 'Выберите время',
  851.                 ];
  852.             } else {
  853.                 $checkSchedule = $iikoUtil->checkSchedule($shippingSchedulerService, $geoLocation, $entityManager, $pickupDeliveryType, $request->request->get('deliveryTime'));
  854.             }
  856.             if ($checkSchedule['status'] === 'error') {
  857.                 return new JsonResponse(['status' => $checkSchedule['status'], 'message' => $checkSchedule['message'], 'error' => true], Response::HTTP_OK);
  858.             }
  859.         }
  861.         if (null !== $order->getOffer()->getOfferDeliveryZone() && $order->getOffer()->getOfferDeliveryZone()->count() > 0) {
  862.             if (null === $address->isPickup()) {
  863.                 $points = $address->getCoordinatesForDeliveryZone() ?? $coordinatesYandex->getGeoCoordinates(
  864.                     $address->buildFullAddress(),
  865.                     ['offerId' => (int)$order->getOffer()->getID()]
  866.                 );
  868.                 $deliveryZone = $deliveryZoneRepository->getPolygonByPoint($order->getOffer(), $points);
  870.                 if (null !== $deliveryZone) {
  871.                     $user = $order->getUser();
  873.                     $codeCost = $order->getCodeCost();
  874.                     if ($subscriptionService->isSubscriber($user) || $user->isBatchCodesAllowed() || $user->isBalanceAllowed($codeCost * $order->getCodesCount())) {
  875.                         $codeCost = 0;
  876.                     }
  878.                     $total = $order->getAmount() - ($order->getCodesCount() * $codeCost);
  880.                     if ($total < $deliveryZone->getMinOrderAmount()) {
  881.                         return new JsonResponse([
  882.                             'error' => true,
  883.                             'message' => \sprintf('До минимальной суммы заказа в этой зоне %s р.', (string) ($deliveryZone->getMinOrderAmount() - $total)),
  884.                         ]);
  885.                     }
  887.                     $order->setDeliveryZoneLocationId($deliveryZone->getGeoLocationId());
  888.                     $order->setDeliveryCost($deliveryZone->getPaidDeliveryAmount());
  889.                     if ($total >= $deliveryZone->getFreeDeliveryAmount()) {
  890.                         $order->setDeliveryCost(0);
  891.                     }
  893.                     if (null === $address->getCoordinatesForDeliveryZone()) {
  894.                         $coordinates = explode(' ', $points);
  896.                         $address->setLatitude($coordinates[1]);
  897.                         $address->setLongitude($coordinates[0]);
  898.                     }
  899.                 } else {
  900.                     return new JsonResponse([
  901.                         'error' => true,
  902.                         'message' => 'Данный адрес не входит в зону доставки. Выберите другой адрес.',
  903.                     ]);
  904.                 }
  905.             } else {
  906.                 $order->setDeliveryZoneLocationId($address->getGeoLocation()->getID());
  907.             }
  908.         }
  910.         $this->reCalcOrder(
  911.             $order,
  912.             $discount,
  913.             $pickupDeliveryType,
  914.             $subscriptionService->isSubscriber($this->getUser()),
  915.             $pricePromocodeForOnlineOrder
  916.         );
  918.         $entityManager->flush();
  920.         return new JsonResponse(['error' => false, 'redirectURL' => '/delivery/order/payment/' . $order->getID() ]);
  921.     }
  923.     /**
  924.      * @Route("/delivery/order/pay/{orderID}", name="deliveryOrderPay")
  925.      */
  926.     public function payAction(
  927.         Request $request,
  928.         PartnerBePaidService $partnerBePaidService,
  929.         PaymentService $paymentService,
  930.         CreditCardRepositoryInterface $creditCardRepository,
  931.         SubscriptionService $subscriptionService,
  932.         ContainerInterface $container,
  933.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder,
  934.         VirtualWalletChecker $virtualWalletChecker,
  935.         $orderID
  936.     ) {
  937.         $paymentMethod = $request->request->getInt('paymentMethod');
  938.         $entityManager = $this->getDoctrine()->getManager();
  939.         $order = $entityManager->find(FoodOrder::class, $orderID);
  940.         if (null === $order) {
  941.             return new JsonResponse(['error' => true]);
  942.         }
  943.         $iikoUtil = IikoUtil::instance($order->getOffer());
  944.         $iikoUtil->setContainer($container);
  945.         $order->setPaymentType($paymentMethod);
  946.         $order->setPaymentMethodID(OfferOrder::METHOD_BEPAID);
  947.         $isUsePartnerCashbackBalance = $request->request->getBoolean('usePartnerCashbackBalance');
  948.         $order->setUsePartnerCashbackBalance($isUsePartnerCashbackBalance);
  949.         if ($isUsePartnerCashbackBalance) {
  950.             $allowedCashbackSumToPay = $iikoUtil->getAllowedCashbackSumToPay($order, $entityManager);
  951.             $order->setUsedPartnerCashbackSum($allowedCashbackSumToPay);
  952.         }
  954.         $order->setUseFastDelivery(
  955.             $request->request->getBoolean('useFastDelivery')
  956.         );
  958.         $order->setChangeAmount(
  959.             $request->request->get('changeAmount')
  960.                 ? (float) $request->request->get('changeAmount')
  961.                 : null
  962.         );
  964.         $codeCost = $order->getCodeCost();
  965.         $codeCostRegular = $codeCost;
  966.         $user = $order->getUser();
  968.         $subscriber = false;
  969.         if ($subscriptionService->isSubscriber($user)) {
  970.             $subscriber = true;
  971.             $codeCost = 0;
  972.         }
  974.         $isBatchCodes = false;
  975.         if ($user->isBatchCodesAllowed()) {
  976.             $isBatchCodes = true;
  977.             $codeCost = 0;
  978.         }
  980.         if (in_array($paymentMethod, [PaymentType::CASH, PaymentType::TERMINAL], true)) {
  981.             if ($subscriber || $isBatchCodes) {
  982.                 $order->setAmount($codeCost);
  983.                 $paymentService->createCode(
  984.                     $order,
  985.                     $order->getCodesCount(),
  986.                     false,
  987.                     null,
  988.                     false,
  989.                     $isBatchCodes ? UserBalanceActivity::TYPE_REDUCTION_BATCH_CODES : null
  990.                 );
  992.                 return new JsonResponse(['error' => false]);
  993.             }
  995.             $order->setAmount($order->getCodesCount() * $codeCost);
  996.             $entityManager->flush();
  998.             return new JsonResponse([
  999.                 'redirectURL' => $this->redirectToRoute('buyCode', [
  1000.                         'offerID' => $order->getOffer()->getID(),
  1001.                         'codesCount' =>  $order->getCodesCount(),
  1002.                         'orderID' => $order->getID()
  1003.                     ]
  1004.                 )->getTargetUrl()
  1005.             ]);
  1006.         }
  1008.         $deliveryType = $order->getDeliveryAddress()->isPickup() ? FoodOfferExtension::DELIVERY_METHOD_PICKUP : FoodOfferExtension::DELIVERY_METHOD;
  1009.         $discount = $request->getSession()->get("pickupDiscount") ? $request->getSession()->get("pickupDiscount") : 0;
  1011.         $this->reCalcOrder(
  1012.             $order,
  1013.             $discount,
  1014.             $deliveryType,
  1015.             $subscriptionService->isSubscriber($user),
  1016.             $pricePromocodeForOnlineOrder
  1017.         );
  1019.         if ($paymentMethod === PaymentType::SLIVKI_PAY) {
  1020.             $codeCostForSlivkiPay = $order->getCodesCount() * (float) $order->getCodeCost();
  1021.             try {
  1022.                 $orderAmount = $order->getAmount();
  1023.                 if ($order->getUsedPartnerCashbackSum() > 0) {
  1024.                     $orderAmount -= $order->getUsedPartnerCashbackSum();
  1025.                 }
  1027.                 if ($codeCost === 0 || $user->isBalanceAllowed($codeCost * $order->getCodesCount())) {
  1028.                     $orderAmount += $codeCostForSlivkiPay;
  1029.                 }
  1031.                 if (!$virtualWalletChecker->availableSlivkiPay($orderAmount, $user)) {
  1032.                     return new JsonResponse(
  1033.                         [
  1034.                             'error' => true,
  1035.                             'message' => 'Недостаточно средств на балансе SlivkiPay',
  1036.                             'slivkiPay' => true,
  1037.                         ]
  1038.                     );
  1039.                 }
  1041.                 $paymentService->payOrder($user, $orderAmount);
  1042.                 $paymentService->createCode($order, $order->getCodesCount(), false);
  1043.             } catch (InsufficientBalanceFundsException $exception) {
  1044.                 return new JsonResponse(['error' => true]);
  1045.             }
  1047.             return new JsonResponse(['error' => false]);
  1048.         }
  1050.         $order->setPaymentType(PaymentType::ONLINE);
  1052.         if ($user->isBalanceAllowed($codeCost * $order->getCodesCount())) {
  1053.             $codeCost = 0;
  1054.         }
  1056.         $iikoUtil->modifyOrder($order, $entityManager);
  1058.         $entityManager->flush();
  1060.         $partnerBePaidService->setOrder($order);
  1062.         $card = $creditCardRepository->findById($request->request->getInt('creditCardID'));
  1063.         if (null === $card || !$card->isOwner($this->getUser()->getID())) {
  1064.             $paymentToken = $partnerBePaidService->getPaymentToken($order, null, $codeCost);
  1065.             if (!$paymentToken) {
  1066.                 return new JsonResponse(['error' => true]);
  1067.             }
  1069.             $partnerBePaidService->createBePaidPaiment($order, $paymentToken['checkout']['token']);
  1071.             return new JsonResponse([
  1072.                 'token' => $paymentToken['checkout']['token'],
  1073.             ]);
  1074.         }
  1076.         $offerSettings = $order->getOffer()->getOnlineOrderSettings();
  1077.         if (($iikoUtil::SPLIT_PAYMENT || ($offerSettings && $offerSettings->isSplitPayment()))
  1078.             && (!$subscriber && !$user->isBatchCodesAllowed() && !$user->isBalanceAllowed($codeCostRegular * $order->getCodesCount()))
  1079.         ) {
  1080.             $amount = $order->getAmount() - $order->getCodesCount() * $codeCost;
  1081.         } else {
  1082.             $amount = $order->getAmount();
  1083.         }
  1085.         $result = $partnerBePaidService->checkoutByToken($order, $card->getID(), $amount);
  1086.         if (!$result) {
  1087.             return new JsonResponse(['error' => true]);
  1088.         }
  1090.         if (is_array($result) && isset($result['token'])) {
  1091.             return new JsonResponse(['token' => $result['token']]);
  1092.         }
  1094.         $partnerBePaidService->createBePaidPaiment($order, $result);
  1095.         
  1096.         return new JsonResponse(['error' => false]);
  1097.     }
  1099.     /** @Route("/delivery/street/suggest/{offerID}") */
  1100.     public function deliveryStreetSuggest(Request $request, $offerID): JsonResponse
  1101.     {
  1102.         /** @var StreetRepository $street */
  1103.         $street = $this->getDoctrine()->getManager()->getRepository(Street::class);
  1104.         $streets = $street->getStreets($offerID, $request->query->get('q'));
  1106.         return new JsonResponse($streets);
  1107.     }
  1109.     /** @Route("/delivery/feedback/{offerID}") */
  1110.     public function feedbackAction(Request $request, Mailer $mailer, $offerID) {
  1111.         $text = $request->request->get('name') . ', ' . $request->request->get('email') . "\n" . $request->request->get('message') . "\n";
  1112.         $subj ='';
  1113.         if (is_numeric($offerID)) {
  1114.             $offerID = (int)$offerID;
  1115.             $offer = $this->getDoctrine()->getManager()->find(Offer::class, $offerID);
  1116.             if ($offer) {
  1117.                 $subj = 'Жалоба на акцию: ' . $offer->getTitle();
  1118.             } else {
  1119.                 $subj = 'Фидбек с доставки суши';
  1120.             }
  1121.         }
  1122.         else if ($offerID == 'subscription-landing') {
  1123.             $subj = 'Фидбек с лендинга подписки';
  1124.         }
  1125.         else if ($offerID == 'auth') {
  1126.             $subj = 'Фидбек с попапа авторизации';
  1127.         }
  1128.         $message = $mailer->createMessage($subj, $text);
  1129.         $message->setFrom('info@slivki.by', 'Slivki.by');
  1130.         $message->setTo('1@slivki.by')
  1131.             ->addTo('info@slivki.by')
  1132.             ->addTo('yuri@slivki.com')
  1133.             ->addCc('dmitry.kazak@slivki.com');
  1134.         $mailer->send($message);
  1135.         return new Response();
  1136.     }
  1138.     private function reCalcOrder(
  1139.         FoodOrder $order,
  1140.         $discount = 0,
  1141.         $typePrice = null,
  1142.         bool $isSubscriber = false,
  1143.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder
  1144.     ) {
  1145.         /** @var OfferOrderDetails $details */
  1146.         $orderSum = 0;
  1147.         $additionalInfo = $order->getAdditionalInfo();
  1149.         $additionalDominos = false;
  1150.         if (isset($additionalInfo['dominosCoupon'])) {
  1151.             $additionalDominos = true;
  1152.         }
  1154.         $iikoUtil = AbstractDelivery::instance($order->getOffer());
  1155.         $iikoUtil->setContainer($this->kernel->getContainer());
  1157.         foreach ($order->getOfferOrderDetails() as $details) {
  1158.             $variant = $details->getOfferExtensionVariant();
  1159.             if ($variant) {
  1160.                 $extension = $variant->getOfferExtension();
  1162.                 if ($additionalDominos) {
  1163.                     $variantAdditionalDominos = $variant;
  1164.                 } else {
  1165.                     $variantAdditionalDominos = null;
  1166.                 }
  1168.                 $purchasePrice = PriceDeliveryType::calcDeliveryPickupPrice(
  1169.                     $extension,
  1170.                     $typePrice,
  1171.                     $variant->getRegularPrice(),
  1172.                     $variant->getOfferPrice(),
  1173.                     $variantAdditionalDominos
  1174.                 );
  1175.             } else {
  1176.                 $extension = $details->getOfferExtension();
  1177.                 $product = $iikoUtil->getProduct($extension->getPartnerItemID());
  1179.                 $purchasePrice = PriceDeliveryType::calcDeliveryPickupPrice(
  1180.                     $extension,
  1181.                     $typePrice,
  1182.                     $product->regularPrice,
  1183.                     $extension->getCurrentPrice(null, $typePrice),
  1184.                 );
  1185.             }
  1187.             $orderSum += $details->getItemsCount() * $purchasePrice;
  1188.             $details->setPurchasePrice($purchasePrice);
  1189.         }
  1191.         $deliveryCost = $order->getDeliveryCost();
  1193.         if (
  1194.             ($typePrice !== null && (int) $typePrice === FoodOfferExtension::DELIVERY_METHOD_PICKUP)
  1195.             || (null !== $order->getDeliveryAddress() && $order->getDeliveryAddress()->isPickup())
  1196.         ) {
  1197.             $deliveryCost = 0;
  1198.         }
  1199.         $order->setDeliveryCost($deliveryCost);
  1201.         $regularCodeCost = $pricePromocodeForOnlineOrder->getPrice(
  1202.             $order,
  1203.             $order->getOffer(),
  1204.             $order->getCodesCount(),
  1205.             $orderSum + $deliveryCost
  1206.         );
  1208.         $codeCost = 0;
  1209.         if (!$isSubscriber
  1210.             && !$order->getUser()->isBatchCodesAllowed()
  1211.             && !$order->getUser()->isBalanceAllowed($regularCodeCost * $order->getCodesCount())
  1212.         ) {
  1213.             $codeCost = $regularCodeCost;
  1214.         }
  1216.         $orderSum += $codeCost * $order->getCodesCount() + $deliveryCost;
  1217.         if ($discount > 0) {
  1218.             $orderSum -= ($orderSum * ($discount / 100));
  1219.         }
  1221.         if ($order->getUsedPartnerCashbackSum() > 0) {
  1222.             $orderSum -= $order->getUsedPartnerCashbackSum();
  1223.         }
  1225.         $order->setAmount($orderSum);
  1226.     }
  1228.     /**
  1229.      * @Route("/delivery/check-address", name="delivery_check_address")
  1230.      */
  1231.     public function checkAddressAction(
  1232.         Request $request,
  1233.         SubscriptionService $subscriptionService,
  1234.         VisibilityFilterService $visibilityFilterService
  1235.     ): JsonResponse {
  1236.         $entityManager = $this->getDoctrine()->getManager();
  1237.         $orderID = $request->request->getInt('orderID');
  1238.         $addressID = $request->request->getInt('addressID');
  1239.         $deliveryTime = $request->request->get('deliveryTime');
  1240.         $order = $entityManager->find(FoodOrder::class, $orderID);
  1241.         $order->setDeliveryTime($deliveryTime);
  1242.         $order->setPaymentType($request->request->getInt('paymentType', 1));
  1243.         $address = $entityManager->find(UserAddress::class, $addressID);
  1244.         $order->setDeliveryAddress($address);
  1245.         $orderInfo = IikoUtil::instance($order->getOffer())->checkOrder($entityManager, $order, $subscriptionService);
  1246.         if (!$orderInfo) {
  1247.             return new JsonResponse(['error' => true]);
  1248.         }
  1249.         $entityManager->flush();
  1251.         $response = $this->getCheckAddressResponse($orderInfo);
  1253.         try {
  1254.             $visibilityFilterService->assertAllVisibleOrFail(array_map(
  1255.                 static fn (OfferOrderDetails $orderDetail) => $orderDetail->getOfferExtension(),
  1256.                 $order->getOfferOrderDetails()->toArray(),
  1257.             ));
  1258.         } catch (OfferExtensionNotVisibleException $e) {
  1259.             return new JsonResponse([
  1260.                 'status' => 'error',
  1261.                 'error' => true,
  1262.                 'deliveryPrice' => $response['deliveryPrice'],
  1263.                 'message' => $e->getMessage(),
  1264.             ]);
  1265.         }
  1267.         return new JsonResponse($response);
  1268.     }
  1270.     /** @Route("/delivery/reload/offer/{offerId}/type/{typePrice}", name="deliveryReloadDish") */
  1271.     public function reloadDish(
  1272.         Request $request,
  1273.         ImageService $imageService,
  1274.         ProductFastDeliveryService $productFastDeliveryService,
  1275.         CustomProductOfferSorter $productSorter,
  1276.         ContainerInterface $container,
  1277.         FoodFilterCounterRepositoryInterface $foodFilterCounterRepository,
  1278.         CustomProductOfferSorter $customProductOfferSorter,
  1279.         OfferOrderPurchaseCountDaoInterface $offerOrderPurchaseCountDao,
  1280.         OfferCacheService $offerCacheService,
  1281.         FoodOfferExtensionRepositoryInterface $foodOfferExtensionRepository,
  1282.         WeightParserHelper $weightParserHelper,
  1283.         ShippingSchedulerService $shippingSchedulerService,
  1284.         FoodByOnlineCategoriesBuilder $foodByOnlineCategoriesBuilder,
  1285.         VisibilityFilterService $visibilityFilterService,
  1286.         $offerId,
  1287.         $typePrice
  1288.     ) {
  1289.         $offerCached = $offerCacheService->getOffer($offerId, true, true);
  1291.         $data['offer'] = $offerCached;
  1292.         $orderUtil = AbstractDelivery::instance($offerCached);
  1293.         $orderUtil->setContainer($container);
  1294.         $data['filterAction'] = $foodFilterCounterRepository->findByOfferId((int) $offerCached->getID());
  1295.         $isSushiVesla = $orderUtil instanceof SushiVesla;
  1296.         $isDominos = $orderUtil instanceof Dominos;
  1297.         $isSushiHouse = $orderUtil instanceof SushiHouse;
  1298.         $isSushiChefArts = $orderUtil instanceof SushiChefArts;
  1299.         $data['isDominos'] = $isDominos;
  1300.         $data['showSortingIndexOrder'] = $isSushiVesla || $isDominos ? false : true;
  1302.         $allDishes = [];
  1303.         if ($isSushiVesla) {
  1304.             $allDishes = $foodOfferExtensionRepository->findActiveByOfferIdAndShippingType($offerId, $typePrice);
  1305.         }
  1307.         $shippingType = FoodOfferExtension::LABEL_SHIPPING_TYPE[$typePrice];
  1309.         if ($isSushiVesla) {
  1310.             $dishes = $orderUtil->getProductsDBByShippingType(
  1311.                 array_filter($allDishes, static fn (OfferExtension $offerExtension): bool => !is_subclass_of($offerExtension, FoodOfferExtension::class)),
  1312.             );
  1313.         } else {
  1314.             $dishes = $orderUtil->getDishes();
  1315.         }
  1317.         $extensions = $foodOfferExtensionRepository->findActiveByOfferIdAndShippingType($offerId, $typePrice);
  1318.         $extensions = array_combine(
  1319.             array_map(static fn (FoodOfferExtension $e) => $e->getPartnerItemID(), $extensions),
  1320.             $extensions,
  1321.         );
  1323.         $dishPurchaseCount = $offerOrderPurchaseCountDao->getPurchaseCountsForPeriodByOffer((int) $offerId, PurchaseCountPeriod::LAST_MONTH);
  1324.         $dishPurchaseDayCount = $offerOrderPurchaseCountDao->getPurchaseCountsForPeriodByOffer((int) $offerId, PurchaseCountPeriod::LAST_DAY);
  1326.         $data['dishes'] = [];
  1327.         $data['showPricePerKilogram'] = false;
  1329.         foreach ($dishes as $dish) {
  1330.             if (!array_key_exists($dish->id, $extensions)) {
  1331.                 continue;
  1332.             }
  1334.             $offerExtension = $extensions[$dish->id];
  1335.             $dish->productsPerCode = $offerExtension->getProductsPerCode();
  1336.             $dish->offerPrice = $offerExtension->getCurrentPrice(null, $typePrice);
  1337.             $dish->sauceNeed = $offerExtension->isSauceNeed();
  1338.             $dish->rating = (float) $offerCached->getRating();
  1340.             $dish->onlineCategories = array_map(
  1341.                 static fn (OfferExtensionOnlineCategory $category): string => $category->getName(),
  1342.                 $offerExtension->getActiveOnlineCategories()->getValues(),
  1343.             );
  1345.             if (isset($dish->regularPrice) && $dish->regularPrice == 0) {
  1346.                 $dish->regularPrice = $offerExtension->getPrice();
  1347.             }
  1349.             $dishSizeFull = $dish->sizeFull;
  1350.             $dish->sizeFull = '';
  1351.             $dish->pricePerKilogram = null;
  1352.             $dish->itemCount = (int) $offerExtension->getComponentsCount();
  1354.             $dish->offerPrice = (float) PriceDeliveryType::calcDeliveryPickupPrice(
  1355.                 $offerExtension,
  1356.                 $typePrice,
  1357.                 $dish->regularPrice,
  1358.                 $dish->offerPrice,
  1359.             );
  1361.             if ($extensions[$dish->id]->getWeight()) {
  1362.                 $dish->sizeFull = $offerExtension->getWeight() . ' г';
  1363.                 $dish->pricePerKilogram = $this->calcPricePerKilogram(
  1364.                     $dish->offerPrice,
  1365.                     (float) $offerExtension->getWeight(),
  1366.                 );
  1368.                 $data['showPricePerKilogram'] = true;
  1369.             }
  1371.             if ($offerExtension->getComponentsCount()) {
  1372.                 if ($dish->sizeFull != '') {
  1373.                     $dish->sizeFull .= ', ';
  1374.                 }
  1375.                 $dish->sizeFull .= $offerExtension->getComponentsCount() . ' шт';
  1376.             }
  1378.             if ($dish->sizeFull === '') {
  1379.                 $dish->sizeFull = $dishSizeFull;
  1380.             }
  1382.             if (null === $dish->pricePerKilogram && !empty($dish->sizeFull)) {
  1383.                 $dish->pricePerKilogram = $this->calcPricePerKilogram(
  1384.                     $dish->offerPrice,
  1385.                     (float) $weightParserHelper->parse($dish->sizeFull),
  1386.                 );
  1388.                 $data['showPricePerKilogram'] = true;
  1389.             }
  1391.             $dish->originId = $dish->id;
  1392.             $dish->position = $offerExtension->getPosition() ?: CustomProductOfferSorter::DEFAULT_POSITION;
  1393.             $dish->id = $offerExtension->getID();
  1394.             $dish->description = str_replace("\n", '<br/>', $dish->description);
  1395.             $dish->imageURL = null;
  1396.             if (isset($dish->images[count($dish->images) - 1])) {
  1397.                 if ($dish->images[count($dish->images) - 1] instanceof OfferExtensionMedia) {
  1398.                     $dish->imageURL = $imageService->getImageURLCached($dish->images[count($dish->images) - 1], 540, 0);
  1399.                 } else if ($dish->images[count($dish->images) - 1]) {
  1400.                     $dish->imageURL = $dish->images[count($dish->images) - 1]->imageUrl;
  1401.                 }
  1402.             }
  1404.             $key = array_search($dish->id, array_column($dishPurchaseCount, 'id'), true);
  1405.             $dish->purchaseCount = isset($dishPurchaseCount[$key]['cnt']) && $key !== false ? $dishPurchaseCount[$key]['cnt'] : 0;
  1407.             $keyDay = array_search($dish->id, array_column($dishPurchaseDayCount, 'id'), true);
  1408.             $dish->purchaseDayCount = isset($dishPurchaseDayCount[$keyDay]['cnt']) && $keyDay !== false
  1409.                 ? $dishPurchaseDayCount[$keyDay]['cnt']
  1410.                 : 0;
  1412.             $deliveryTime = $productFastDeliveryService->findProductFastDelivery($offerCached, $dish->originId);
  1414.             $dish->fastDeliveryTime = CustomProductOfferSorter::DEFAULT_POSITION;
  1415.             if ($deliveryTime) {
  1416.                 $dish->fastDelivery = $deliveryTime;
  1417.                 $dish->fastDeliveryTime = (int) $deliveryTime['time'];
  1418.             }
  1420.             if (isset($dish->variants) && count($dish->variants) > 0) {
  1421.                 $offerExtensionVariants = array_reduce(
  1422.                     $extensions[$dish->originId]->getVariants()->getValues(),
  1423.                     static function (array $variants, OfferExtensionVariant $variant)
  1424.                     {
  1425.                         $variants[$variant->getPartnerID()] = $variant;
  1427.                         return $variants;
  1428.                     },
  1429.                     [],
  1430.                 );
  1432.                 foreach ($dish->variants as $key => $variant) {
  1433.                     if (!array_key_exists($variant->id, $offerExtensionVariants)) {
  1434.                         unset($dish->variants[$key]);
  1435.                         continue;
  1436.                     }
  1438.                     /**
  1439.                      * @var $offerExtensionVariant OfferExtensionVariant
  1440.                      */
  1441.                     $offerExtensionVariant = $offerExtensionVariants[$dish->variants[$key]->partnerId];
  1443.                     $dish->variants[$key]->id = $offerExtensionVariant->getID();
  1444.                     if (PriceDeliveryType::PERCENT_PRICE === $offerExtension->getPriceDeliveryType()) {
  1445.                         $dish->variants[$key]->offerPrice = (float) PriceDeliveryType::calcDeliveryPickupPrice(
  1446.                             $offerExtension,
  1447.                             $typePrice,
  1448.                             $dish->variants[$key]->regularPrice,
  1449.                             $offerExtension->getCurrentPrice(null, $typePrice),
  1450.                         );
  1451.                     }
  1452.                 }
  1453.             }
  1455.             $data['dishes'][] = $dish;
  1456.         }
  1458.         $data['dishes'] = $visibilityFilterService->filterInvisibleExtensions($data['dishes']);
  1460.         $sortType = $request->query->get('sort', CustomProductOfferSorter::DEFAULT_CUSTOM_PRODUCT_SORT);
  1461.         $data['dishes'] = $productSorter->sort($data['dishes'], $sortType);
  1463.         $dishGroup = $orderUtil->getDishGroups();
  1465.         $foodDishExtensionId = $request->query->get('extension');
  1466.         if (null !== $foodDishExtensionId) {
  1467.             $dishKey = array_search($foodDishExtensionId, \array_column($data['dishes'], 'id'));
  1468.             $foodCourtExtensionDish = $data['dishes'][$dishKey];
  1469.             unset($data['dishes'][$dishKey]);
  1471.             array_unshift($data['dishes'], $foodCourtExtensionDish);
  1473.             if (0 < count($dishGroup)) {
  1474.                 $category = $isSushiHouse ? $foodCourtExtensionDish->parentGroup : $foodCourtExtensionDish->groupName;
  1475.                 $keyDishGroup = array_search($category, $dishGroup);
  1476.                 $group = $dishGroup[$keyDishGroup];
  1477.                 unset($dishGroup[$keyDishGroup]);
  1479.                 array_unshift($dishGroup, $group);
  1480.             }
  1481.         }
  1483.         $data['topDishIDList'] = [];
  1484.         for ($i = 0; $i < 3; $i++) {
  1485.             if (isset($dishPurchaseCount[$i]['id'])) {
  1486.                 $data['topDishIDList'][] = $dishPurchaseCount[$i]['id'];
  1487.             }
  1488.         }
  1490.         if ($orderUtil::DISH_BY_GROUP) {
  1491.             $dishByGroupLabel = [];
  1492.             $dishByGroupContent = [];
  1494.             if ($isSushiHouse || $isSushiChefArts) {
  1495.                 foreach ($data['dishes'] as $dish) {
  1496.                     $dishByGroupContent[$dish->groupName][] = $dish;
  1497.                     if (!in_array($dish->parentGroup, $dishByGroupLabel)) {
  1498.                         $dishByGroupLabel[$dish->groupName] = $dish->parentGroup;
  1499.                     }
  1500.                 }
  1502.                 if ($isSushiHouse) {
  1503.                     $dishByGroupContent = $this->customSortDishByGroup($dishByGroupContent, $dishGroup);
  1504.                 }
  1505.             }
  1507.             if ($isDominos) {
  1508.                 foreach ($data['dishes'] as $dish) {
  1509.                     $dish->parentGroup = $dish->groupName;
  1510.                     $dishByGroupContent[$dish->groupName][] = $dish;
  1511.                     if (!in_array($dish->groupName, $dishByGroupLabel, true)) {
  1512.                         $dishByGroupLabel[$dish->groupName] = $dish->groupName;
  1513.                     }
  1514.                 }
  1515.             }
  1517.             $data['dishByGroup'] = [
  1518.                 'content' => $dishByGroupContent,
  1519.                 'label' => $dishByGroupLabel,
  1520.             ];
  1521.         }
  1523.         $dishGroup = $foodByOnlineCategoriesBuilder->create($offerId,$data['dishes']);
  1524.         if (!empty($dishGroup)) {
  1525.             $data['dishByGroup'] = array_key_exists('dishByGroup', $data)
  1526.                 ? [
  1527.                     'content' => array_merge($dishGroup['content'], $data['dishByGroup']['content']),
  1528.                     'label' => array_merge($dishGroup['label'], $data['dishByGroup']['label']),
  1529.                 ]
  1530.                 : $dishGroup;
  1531.         }
  1533.         $options = $isSushiVesla
  1534.             ? $orderUtil->getOptionsDBByShippingType(
  1535.                 $imageService,
  1536.                 \array_filter($allDishes, static fn (OfferExtension $offerExtension): bool => $offerExtension instanceof FoodOfferOptionExtension)
  1537.             )
  1538.             : $this->getOptions($imageService, $offerCached, $orderUtil, 0, $isDominos ? $shippingType : null);
  1540.         $data['options'] = $customProductOfferSorter->sort(
  1541.             $visibilityFilterService->filterInvisibleExtensions($options),
  1542.             CustomProductOfferSorter::DEFAULT_CUSTOM_PRODUCT_SORT,
  1543.         );
  1545.         $data['sortList'] = CustomProductOfferSorter::SORT_LIST;
  1546.         $data['isAvailableOnFood'] = $offerCached->isAvailableOnFood();
  1548.         $data['isAvailableOrderForToday'] = $shippingSchedulerService->availableOrderForToday($orderUtil, $offerCached, $typePrice);
  1550.         if ($isDominos) {
  1551.             $view = CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/delivery_teaser_reload_pickup.html.twig' : 'Slivki/delivery/delivery_teaser_reload_pickup.html.twig';
  1552.         } else {
  1553.             $view = CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/delivery_teaser_reload.html.twig' : 'Slivki/delivery/delivery_teaser_reload.html.twig';
  1554.         }
  1556.         return $this->render($view, $data);
  1557.     }
  1559.     private function calcPricePerKilogram(float $offerPrice, int $weight): ?float
  1560.     {
  1561.         if (!$weight) {
  1562.             return null;
  1563.         }
  1565.         return \round(self::KILOGRAM * $offerPrice / $weight, 2);
  1566.     }
  1568.     /** @Route("/expresspizza-orders") */
  1569.     public function expressPizzaOrdersAction(Request $request) {
  1570.         $offerID = 282278;
  1571.         $pass = '67380b434f';
  1572.         $objectCode = '0017-4-009';
  1574.         if ($pass != $request->query->get('pass')) {
  1575.             return new Response('ERROR: Wrong password!');
  1576.         }
  1578.         $date = \DateTime::createFromFormat('U', $request->query->get('date'));
  1580.         if (!$date) {
  1581.             return new Response('ERROR: Wrong date format!');
  1582.         }
  1584.         $entityManager = $this->getDoctrine()->getManager();
  1585.         /** @var Connection $connection */
  1586.         $connection = $entityManager->getConnection();
  1588.         $sql = "select"
  1589.                 . " offer_order.id as order_id,"
  1590.                 . " offer_order.paid_at as order_datetime,"
  1591.                 . " offer_order.delivery_time as delivery_datetime,"
  1592.                 . " user_address.name as client_name,"
  1593.                 . " user_address.phone as client_phone,"
  1594.                 . " user_address.pickup as pickup,"
  1595.                 . " street.name as street_name,"
  1596.                 . " user_address.house as house,"
  1597.                 . " user_address.block as block,"
  1598.                 . " user_address.entrance as entrance,"
  1599.                 . " user_address.floor as floor,"
  1600.                 . " user_address.doorphone as doorphone,"
  1601.                 . " user_address.appartment as appartment,"
  1602.                 . " offer_extension.partner_item_id as product_code,"
  1603.                 . " offer_extension.name as product_name,"
  1604.                 . " offer_order_details.items_count as items_count,"
  1605.                 . " offer_extension.dish_delivery_price as delivery_price,"
  1606.                 . " offer_extension.pickup_price as pickup_price,"
  1607.                 . " offer_order.parameter_int_0 as payment_type,"
  1608.                 . " offer_order.comment as comment,"
  1609.                 . " coalesce(geo_location.pickup_point_partner_id, '$objectCode') as object_code"
  1610.             . " from offer_order_details"
  1611.             . " inner join offer_order on offer_order.id = offer_order_details.offer_order_id"
  1612.             . " inner join user_address on offer_order.delivery_address_id = user_address.id"
  1613.             . " left join street on user_address.street_id = street.id"
  1614.             . " left join geo_location on user_address.geo_location_id = geo_location.id"
  1615.             . " inner join offer_extension on offer_extension.id = offer_order_details.offer_extension_id"
  1616.             . " where offer_order.offer_id = $offerID and offer_order.status > 0 and"
  1617.                 . " offer_order.paid_at >= '" . $date->format('Y-m-d H:i') . "'"
  1618.             . " order by offer_order.id";
  1620.         $orderDetails = $connection->executeQuery($sql)->fetchAll(\PDO::FETCH_ASSOC);
  1622.         $result = [];
  1623.         foreach ($orderDetails as $orderDetail) {
  1624.             $orderDateTime = new \DateTime($orderDetail['order_datetime']);
  1625.             $deliveryDateTime = new \DateTime();
  1626.             if ($orderDetail['delivery_datetime'] != 'Ближайшее') {
  1627.                 $deliveryDateTime = new \DateTime($orderDetail['delivery_datetime']);
  1628.             }
  1630.             $comment = '';
  1632.             if (trim($orderDetail['entrance'])) {
  1633.                 $comment .= 'П' . trim($orderDetail['entrance']) . ' ';
  1634.             }
  1636.             if (trim($orderDetail['floor'])) {
  1637.                 $comment .= 'Э' . trim($orderDetail['floor']) . ' ';
  1638.             }
  1640.             if (trim($orderDetail['doorphone'])) {
  1641.                 $comment .= 'Д' . trim($orderDetail['doorphone']) . ' ';
  1642.             }
  1644.             $paymentType = '';
  1645.             switch ($orderDetail['payment_type']) {
  1646.                 case 1:
  1647.                     $paymentType = 'Оплата: онлайн, ';
  1648.                     break;
  1649.                 case 2:
  1650.                     $paymentType = 'Оплата: наличные, ';
  1651.                     break;
  1652.                 case 3:
  1653.                     $paymentType = 'Оплата: терминал, ';
  1654.                     break;
  1655.                 case PaymentType::SLIVKI_PAY:
  1656.                     $paymentType = 'Оплата: SlivkiPay, ';
  1657.                     break;
  1658.             }
  1659.             $comment .= $paymentType;
  1661.             $comment .= trim($orderDetail['comment']);
  1663.             $result[] = join(chr(9), [
  1664.                 $orderDetail['object_code'], // Код объекта
  1665.                 $orderDetail['order_id'], // Номер заказа
  1666.                 $orderDateTime->format('d.m.Y'), // Дата заказа
  1667.                 $orderDateTime->format('H:i'), // Время заказа
  1668.                 $deliveryDateTime->format('H:i'), // Изготовить к какому времени
  1669.                 $orderDetail['client_name'], // Имя клиента – Контакт
  1670.                 str_replace('+375', '+375 ', $orderDetail['client_phone']), // Контактный телефон.
  1671.                 $orderDetail['pickup'] ? 0 : 1, // Тип получения: на месте (0) или доставка (1).
  1672.                 trim($orderDetail['street_name']) ?: ' ', // Улица доставки
  1673.                 trim($orderDetail['house']) ?: ' ', // Номер дома
  1674.                 trim($orderDetail['block']) ?: ' ', // Корпус
  1675.                 trim($orderDetail['appartment']) ?: ' ', // Квартира
  1676.                 ' ', // Код группы
  1677.                 $orderDetail['product_code'], // Код товара
  1678.                 ' ', // IDNT Номер выгрузки (оставляйте пустым)
  1679.                 $orderDetail['product_name'], // Название товара
  1680.                 $orderDetail['items_count'], // Количество
  1681.                 $orderDetail['pickup'] ? $orderDetail['pickup_price'] : $orderDetail['delivery_price'], // Цена
  1682.                 str_replace(["\r\n", "\n"],' ', $comment), // Примечание
  1683.             ]);
  1684.         }
  1686.         $result[] = chr(9) . 'OK';
  1688.         return new Response(join("\r\n", $result));
  1689.     }
  1691.     private function customSortDishByGroup(array $dishByGroupContent, array $sort): array
  1692.     {
  1693.         uasort($dishByGroupContent, function ($dishGroup1, $dishGroup2) use ($sort) {
  1694.             if (!count($dishGroup1)) {
  1695.                 return 1;
  1696.             }
  1697.             if (!count($dishGroup2)) {
  1698.                 return -1;
  1699.             }
  1700.             $dishGroup1Key = array_search($dishGroup1[0]->parentGroup, $sort);
  1701.             $dishGroup2Key = array_search($dishGroup2[0]->parentGroup, $sort);
  1702.             return $dishGroup1Key < $dishGroup2Key ? -1 : 1;
  1703.         });
  1705.         return $dishByGroupContent;
  1706.     }
  1707. }