src/Controller/IikoOrderController.php line 90

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.         $codeCost = $order->getCodeCost();
  957.         $codeCostRegular = $codeCost;
  958.         $user = $order->getUser();
  960.         $subscriber = false;
  961.         if ($subscriptionService->isSubscriber($user)) {
  962.             $subscriber = true;
  963.             $codeCost = 0;
  964.         }
  966.         $isBatchCodes = false;
  967.         if ($user->isBatchCodesAllowed()) {
  968.             $isBatchCodes = true;
  969.             $codeCost = 0;
  970.         }
  972.         if (in_array($paymentMethod, [PaymentType::CASH, PaymentType::TERMINAL], true)) {
  973.             if ($subscriber || $isBatchCodes) {
  974.                 $order->setAmount($codeCost);
  975.                 $paymentService->createCode(
  976.                     $order,
  977.                     $order->getCodesCount(),
  978.                     false,
  979.                     null,
  980.                     false,
  981.                     $isBatchCodes ? UserBalanceActivity::TYPE_REDUCTION_BATCH_CODES : null
  982.                 );
  984.                 return new JsonResponse(['error' => false]);
  985.             }
  987.             $order->setAmount($order->getCodesCount() * $codeCost);
  988.             $entityManager->flush();
  990.             return new JsonResponse([
  991.                 'redirectURL' => $this->redirectToRoute('buyCode', [
  992.                         'offerID' => $order->getOffer()->getID(),
  993.                         'codesCount' =>  $order->getCodesCount(),
  994.                         'orderID' => $order->getID()
  995.                     ]
  996.                 )->getTargetUrl()
  997.             ]);
  998.         }
  1000.         $deliveryType = $order->getDeliveryAddress()->isPickup() ? FoodOfferExtension::DELIVERY_METHOD_PICKUP : FoodOfferExtension::DELIVERY_METHOD;
  1001.         $discount = $request->getSession()->get("pickupDiscount") ? $request->getSession()->get("pickupDiscount") : 0;
  1003.         $this->reCalcOrder(
  1004.             $order,
  1005.             $discount,
  1006.             $deliveryType,
  1007.             $subscriptionService->isSubscriber($user),
  1008.             $pricePromocodeForOnlineOrder
  1009.         );
  1011.         if ($paymentMethod === PaymentType::SLIVKI_PAY) {
  1012.             $codeCostForSlivkiPay = $order->getCodesCount() * (float) $order->getCodeCost();
  1013.             try {
  1014.                 $orderAmount = $order->getAmount();
  1015.                 if ($order->getUsedPartnerCashbackSum() > 0) {
  1016.                     $orderAmount -= $order->getUsedPartnerCashbackSum();
  1017.                 }
  1019.                 if ($codeCost === 0 || $user->isBalanceAllowed($codeCost * $order->getCodesCount())) {
  1020.                     $orderAmount += $codeCostForSlivkiPay;
  1021.                 }
  1023.                 if (!$virtualWalletChecker->availableSlivkiPay($orderAmount, $user)) {
  1024.                     return new JsonResponse(
  1025.                         [
  1026.                             'error' => true,
  1027.                             'message' => 'Недостаточно средств на балансе SlivkiPay',
  1028.                             'slivkiPay' => true,
  1029.                         ]
  1030.                     );
  1031.                 }
  1033.                 $paymentService->payOrder($user, $orderAmount);
  1034.                 $paymentService->createCode($order, $order->getCodesCount(), false);
  1035.             } catch (InsufficientBalanceFundsException $exception) {
  1036.                 return new JsonResponse(['error' => true]);
  1037.             }
  1039.             return new JsonResponse(['error' => false]);
  1040.         }
  1042.         $order->setPaymentType(PaymentType::ONLINE);
  1044.         if ($user->isBalanceAllowed($codeCost * $order->getCodesCount())) {
  1045.             $codeCost = 0;
  1046.         }
  1048.         $iikoUtil->modifyOrder($order, $entityManager);
  1050.         $entityManager->flush();
  1052.         $partnerBePaidService->setOrder($order);
  1054.         $card = $creditCardRepository->findById($request->request->getInt('creditCardID'));
  1055.         if (null === $card || !$card->isOwner($this->getUser()->getID())) {
  1056.             $paymentToken = $partnerBePaidService->getPaymentToken($order, null, $codeCost);
  1057.             if (!$paymentToken) {
  1058.                 return new JsonResponse(['error' => true]);
  1059.             }
  1061.             $partnerBePaidService->createBePaidPaiment($order, $paymentToken['checkout']['token']);
  1063.             return new JsonResponse([
  1064.                 'token' => $paymentToken['checkout']['token'],
  1065.             ]);
  1066.         }
  1068.         $offerSettings = $order->getOffer()->getOnlineOrderSettings();
  1069.         if (($iikoUtil::SPLIT_PAYMENT || ($offerSettings && $offerSettings->isSplitPayment()))
  1070.             && (!$subscriber && !$user->isBatchCodesAllowed() && !$user->isBalanceAllowed($codeCostRegular * $order->getCodesCount()))
  1071.         ) {
  1072.             $amount = $order->getAmount() - $order->getCodesCount() * $codeCost;
  1073.         } else {
  1074.             $amount = $order->getAmount();
  1075.         }
  1077.         $result = $partnerBePaidService->checkoutByToken($order, $card->getID(), $amount);
  1078.         if (!$result) {
  1079.             return new JsonResponse(['error' => true]);
  1080.         }
  1082.         if (is_array($result) && isset($result['token'])) {
  1083.             return new JsonResponse(['token' => $result['token']]);
  1084.         }
  1086.         $partnerBePaidService->createBePaidPaiment($order, $result);
  1087.         
  1088.         return new JsonResponse(['error' => false]);
  1089.     }
  1091.     /** @Route("/delivery/street/suggest/{offerID}") */
  1092.     public function deliveryStreetSuggest(Request $request, $offerID): JsonResponse
  1093.     {
  1094.         /** @var StreetRepository $street */
  1095.         $street = $this->getDoctrine()->getManager()->getRepository(Street::class);
  1096.         $streets = $street->getStreets($offerID, $request->query->get('q'));
  1098.         return new JsonResponse($streets);
  1099.     }
  1101.     /** @Route("/delivery/feedback/{offerID}") */
  1102.     public function feedbackAction(Request $request, Mailer $mailer, $offerID) {
  1103.         $text = $request->request->get('name') . ', ' . $request->request->get('email') . "\n" . $request->request->get('message') . "\n";
  1104.         $subj ='';
  1105.         if (is_numeric($offerID)) {
  1106.             $offerID = (int)$offerID;
  1107.             $offer = $this->getDoctrine()->getManager()->find(Offer::class, $offerID);
  1108.             if ($offer) {
  1109.                 $subj = 'Жалоба на акцию: ' . $offer->getTitle();
  1110.             } else {
  1111.                 $subj = 'Фидбек с доставки суши';
  1112.             }
  1113.         }
  1114.         else if ($offerID == 'subscription-landing') {
  1115.             $subj = 'Фидбек с лендинга подписки';
  1116.         }
  1117.         else if ($offerID == 'auth') {
  1118.             $subj = 'Фидбек с попапа авторизации';
  1119.         }
  1120.         $message = $mailer->createMessage($subj, $text);
  1121.         $message->setFrom('info@slivki.by', 'Slivki.by');
  1122.         $message->setTo('1@slivki.by')
  1123.             ->addTo('info@slivki.by')
  1124.             ->addTo('yuri@slivki.com')
  1125.             ->addCc('dmitry.kazak@slivki.com');
  1126.         $mailer->send($message);
  1127.         return new Response();
  1128.     }
  1130.     private function reCalcOrder(
  1131.         FoodOrder $order,
  1132.         $discount = 0,
  1133.         $typePrice = null,
  1134.         bool $isSubscriber = false,
  1135.         PricePromocodeForOnlineOrder $pricePromocodeForOnlineOrder
  1136.     ) {
  1137.         /** @var OfferOrderDetails $details */
  1138.         $orderSum = 0;
  1139.         $additionalInfo = $order->getAdditionalInfo();
  1141.         $additionalDominos = false;
  1142.         if (isset($additionalInfo['dominosCoupon'])) {
  1143.             $additionalDominos = true;
  1144.         }
  1146.         $iikoUtil = AbstractDelivery::instance($order->getOffer());
  1147.         $iikoUtil->setContainer($this->kernel->getContainer());
  1149.         foreach ($order->getOfferOrderDetails() as $details) {
  1150.             $variant = $details->getOfferExtensionVariant();
  1151.             if ($variant) {
  1152.                 $extension = $variant->getOfferExtension();
  1154.                 if ($additionalDominos) {
  1155.                     $variantAdditionalDominos = $variant;
  1156.                 } else {
  1157.                     $variantAdditionalDominos = null;
  1158.                 }
  1160.                 $purchasePrice = PriceDeliveryType::calcDeliveryPickupPrice(
  1161.                     $extension,
  1162.                     $typePrice,
  1163.                     $variant->getRegularPrice(),
  1164.                     $variant->getOfferPrice(),
  1165.                     $variantAdditionalDominos
  1166.                 );
  1167.             } else {
  1168.                 $extension = $details->getOfferExtension();
  1169.                 $product = $iikoUtil->getProduct($extension->getPartnerItemID());
  1171.                 $purchasePrice = PriceDeliveryType::calcDeliveryPickupPrice(
  1172.                     $extension,
  1173.                     $typePrice,
  1174.                     $product->regularPrice,
  1175.                     $extension->getCurrentPrice(null, $typePrice),
  1176.                 );
  1177.             }
  1179.             $orderSum += $details->getItemsCount() * $purchasePrice;
  1180.             $details->setPurchasePrice($purchasePrice);
  1181.         }
  1183.         $deliveryCost = $order->getDeliveryCost();
  1185.         if (
  1186.             ($typePrice !== null && (int) $typePrice === FoodOfferExtension::DELIVERY_METHOD_PICKUP)
  1187.             || (null !== $order->getDeliveryAddress() && $order->getDeliveryAddress()->isPickup())
  1188.         ) {
  1189.             $deliveryCost = 0;
  1190.         }
  1191.         $order->setDeliveryCost($deliveryCost);
  1193.         $regularCodeCost = $pricePromocodeForOnlineOrder->getPrice(
  1194.             $order,
  1195.             $order->getOffer(),
  1196.             $order->getCodesCount(),
  1197.             $orderSum + $deliveryCost
  1198.         );
  1200.         $codeCost = 0;
  1201.         if (!$isSubscriber
  1202.             && !$order->getUser()->isBatchCodesAllowed()
  1203.             && !$order->getUser()->isBalanceAllowed($regularCodeCost * $order->getCodesCount())
  1204.         ) {
  1205.             $codeCost = $regularCodeCost;
  1206.         }
  1208.         $orderSum += $codeCost * $order->getCodesCount() + $deliveryCost;
  1209.         if ($discount > 0) {
  1210.             $orderSum -= ($orderSum * ($discount / 100));
  1211.         }
  1213.         if ($order->getUsedPartnerCashbackSum() > 0) {
  1214.             $orderSum -= $order->getUsedPartnerCashbackSum();
  1215.         }
  1217.         $order->setAmount($orderSum);
  1218.     }
  1220.     /**
  1221.      * @Route("/delivery/check-address", name="delivery_check_address")
  1222.      */
  1223.     public function checkAddressAction(
  1224.         Request $request,
  1225.         SubscriptionService $subscriptionService,
  1226.         VisibilityFilterService $visibilityFilterService
  1227.     ): JsonResponse {
  1228.         $entityManager = $this->getDoctrine()->getManager();
  1229.         $orderID = $request->request->getInt('orderID');
  1230.         $addressID = $request->request->getInt('addressID');
  1231.         $deliveryTime = $request->request->get('deliveryTime');
  1232.         $order = $entityManager->find(FoodOrder::class, $orderID);
  1233.         $order->setDeliveryTime($deliveryTime);
  1234.         $order->setPaymentType($request->request->getInt('paymentType', 1));
  1235.         $address = $entityManager->find(UserAddress::class, $addressID);
  1236.         $order->setDeliveryAddress($address);
  1237.         $orderInfo = IikoUtil::instance($order->getOffer())->checkOrder($entityManager, $order, $subscriptionService);
  1238.         if (!$orderInfo) {
  1239.             return new JsonResponse(['error' => true]);
  1240.         }
  1241.         $entityManager->flush();
  1243.         $response = $this->getCheckAddressResponse($orderInfo);
  1245.         try {
  1246.             $visibilityFilterService->assertAllVisibleOrFail(array_map(
  1247.                 static fn (OfferOrderDetails $orderDetail) => $orderDetail->getOfferExtension(),
  1248.                 $order->getOfferOrderDetails()->toArray(),
  1249.             ));
  1250.         } catch (OfferExtensionNotVisibleException $e) {
  1251.             return new JsonResponse([
  1252.                 'status' => 'error',
  1253.                 'error' => true,
  1254.                 'deliveryPrice' => $response['deliveryPrice'],
  1255.                 'message' => $e->getMessage(),
  1256.             ]);
  1257.         }
  1259.         return new JsonResponse($response);
  1260.     }
  1262.     /** @Route("/delivery/reload/offer/{offerId}/type/{typePrice}", name="deliveryReloadDish") */
  1263.     public function reloadDish(
  1264.         Request $request,
  1265.         ImageService $imageService,
  1266.         ProductFastDeliveryService $productFastDeliveryService,
  1267.         CustomProductOfferSorter $productSorter,
  1268.         ContainerInterface $container,
  1269.         FoodFilterCounterRepositoryInterface $foodFilterCounterRepository,
  1270.         CustomProductOfferSorter $customProductOfferSorter,
  1271.         OfferOrderPurchaseCountDaoInterface $offerOrderPurchaseCountDao,
  1272.         OfferCacheService $offerCacheService,
  1273.         FoodOfferExtensionRepositoryInterface $foodOfferExtensionRepository,
  1274.         WeightParserHelper $weightParserHelper,
  1275.         ShippingSchedulerService $shippingSchedulerService,
  1276.         FoodByOnlineCategoriesBuilder $foodByOnlineCategoriesBuilder,
  1277.         VisibilityFilterService $visibilityFilterService,
  1278.         $offerId,
  1279.         $typePrice
  1280.     ) {
  1281.         $offerCached = $offerCacheService->getOffer($offerId, true, true);
  1283.         $data['offer'] = $offerCached;
  1284.         $orderUtil = AbstractDelivery::instance($offerCached);
  1285.         $orderUtil->setContainer($container);
  1286.         $data['filterAction'] = $foodFilterCounterRepository->findByOfferId((int) $offerCached->getID());
  1287.         $isSushiVesla = $orderUtil instanceof SushiVesla;
  1288.         $isDominos = $orderUtil instanceof Dominos;
  1289.         $isSushiHouse = $orderUtil instanceof SushiHouse;
  1290.         $isSushiChefArts = $orderUtil instanceof SushiChefArts;
  1291.         $data['isDominos'] = $isDominos;
  1292.         $data['showSortingIndexOrder'] = $isSushiVesla || $isDominos ? false : true;
  1294.         $allDishes = [];
  1295.         if ($isSushiVesla) {
  1296.             $allDishes = $foodOfferExtensionRepository->findActiveByOfferIdAndShippingType($offerId, $typePrice);
  1297.         }
  1299.         $shippingType = FoodOfferExtension::LABEL_SHIPPING_TYPE[$typePrice];
  1301.         if ($isSushiVesla) {
  1302.             $dishes = $orderUtil->getProductsDBByShippingType(
  1303.                 array_filter($allDishes, static fn (OfferExtension $offerExtension): bool => !is_subclass_of($offerExtension, FoodOfferExtension::class)),
  1304.             );
  1305.         } else {
  1306.             $dishes = $orderUtil->getDishes();
  1307.         }
  1309.         $extensions = $foodOfferExtensionRepository->findActiveByOfferIdAndShippingType($offerId, $typePrice);
  1310.         $extensions = array_combine(
  1311.             array_map(static fn (FoodOfferExtension $e) => $e->getPartnerItemID(), $extensions),
  1312.             $extensions,
  1313.         );
  1315.         $dishPurchaseCount = $offerOrderPurchaseCountDao->getPurchaseCountsForPeriodByOffer((int) $offerId, PurchaseCountPeriod::LAST_MONTH);
  1316.         $dishPurchaseDayCount = $offerOrderPurchaseCountDao->getPurchaseCountsForPeriodByOffer((int) $offerId, PurchaseCountPeriod::LAST_DAY);
  1318.         $data['dishes'] = [];
  1319.         $data['showPricePerKilogram'] = false;
  1321.         foreach ($dishes as $dish) {
  1322.             if (!array_key_exists($dish->id, $extensions)) {
  1323.                 continue;
  1324.             }
  1326.             $offerExtension = $extensions[$dish->id];
  1327.             $dish->productsPerCode = $offerExtension->getProductsPerCode();
  1328.             $dish->offerPrice = $offerExtension->getCurrentPrice(null, $typePrice);
  1329.             $dish->sauceNeed = $offerExtension->isSauceNeed();
  1330.             $dish->rating = (float) $offerCached->getRating();
  1332.             $dish->onlineCategories = array_map(
  1333.                 static fn (OfferExtensionOnlineCategory $category): string => $category->getName(),
  1334.                 $offerExtension->getActiveOnlineCategories()->getValues(),
  1335.             );
  1337.             if (isset($dish->regularPrice) && $dish->regularPrice == 0) {
  1338.                 $dish->regularPrice = $offerExtension->getPrice();
  1339.             }
  1341.             $dishSizeFull = $dish->sizeFull;
  1342.             $dish->sizeFull = '';
  1343.             $dish->pricePerKilogram = null;
  1344.             $dish->itemCount = (int) $offerExtension->getComponentsCount();
  1346.             $dish->offerPrice = (float) PriceDeliveryType::calcDeliveryPickupPrice(
  1347.                 $offerExtension,
  1348.                 $typePrice,
  1349.                 $dish->regularPrice,
  1350.                 $dish->offerPrice,
  1351.             );
  1353.             if ($extensions[$dish->id]->getWeight()) {
  1354.                 $dish->sizeFull = $offerExtension->getWeight() . ' г';
  1355.                 $dish->pricePerKilogram = $this->calcPricePerKilogram(
  1356.                     $dish->offerPrice,
  1357.                     (float) $offerExtension->getWeight(),
  1358.                 );
  1360.                 $data['showPricePerKilogram'] = true;
  1361.             }
  1363.             if ($offerExtension->getComponentsCount()) {
  1364.                 if ($dish->sizeFull != '') {
  1365.                     $dish->sizeFull .= ', ';
  1366.                 }
  1367.                 $dish->sizeFull .= $offerExtension->getComponentsCount() . ' шт';
  1368.             }
  1370.             if ($dish->sizeFull === '') {
  1371.                 $dish->sizeFull = $dishSizeFull;
  1372.             }
  1374.             if (null === $dish->pricePerKilogram && !empty($dish->sizeFull)) {
  1375.                 $dish->pricePerKilogram = $this->calcPricePerKilogram(
  1376.                     $dish->offerPrice,
  1377.                     (float) $weightParserHelper->parse($dish->sizeFull),
  1378.                 );
  1380.                 $data['showPricePerKilogram'] = true;
  1381.             }
  1383.             $dish->originId = $dish->id;
  1384.             $dish->position = $offerExtension->getPosition() ?: CustomProductOfferSorter::DEFAULT_POSITION;
  1385.             $dish->id = $offerExtension->getID();
  1386.             $dish->description = str_replace("\n", '<br/>', $dish->description);
  1387.             $dish->imageURL = null;
  1388.             if (isset($dish->images[count($dish->images) - 1])) {
  1389.                 if ($dish->images[count($dish->images) - 1] instanceof OfferExtensionMedia) {
  1390.                     $dish->imageURL = $imageService->getImageURLCached($dish->images[count($dish->images) - 1], 540, 0);
  1391.                 } else if ($dish->images[count($dish->images) - 1]) {
  1392.                     $dish->imageURL = $dish->images[count($dish->images) - 1]->imageUrl;
  1393.                 }
  1394.             }
  1396.             $key = array_search($dish->id, array_column($dishPurchaseCount, 'id'), true);
  1397.             $dish->purchaseCount = isset($dishPurchaseCount[$key]['cnt']) && $key !== false ? $dishPurchaseCount[$key]['cnt'] : 0;
  1399.             $keyDay = array_search($dish->id, array_column($dishPurchaseDayCount, 'id'), true);
  1400.             $dish->purchaseDayCount = isset($dishPurchaseDayCount[$keyDay]['cnt']) && $keyDay !== false
  1401.                 ? $dishPurchaseDayCount[$keyDay]['cnt']
  1402.                 : 0;
  1404.             $deliveryTime = $productFastDeliveryService->findProductFastDelivery($offerCached, $dish->originId);
  1406.             $dish->fastDeliveryTime = CustomProductOfferSorter::DEFAULT_POSITION;
  1407.             if ($deliveryTime) {
  1408.                 $dish->fastDelivery = $deliveryTime;
  1409.                 $dish->fastDeliveryTime = (int) $deliveryTime['time'];
  1410.             }
  1412.             if (isset($dish->variants) && count($dish->variants) > 0) {
  1413.                 $offerExtensionVariants = array_reduce(
  1414.                     $extensions[$dish->originId]->getVariants()->getValues(),
  1415.                     static function (array $variants, OfferExtensionVariant $variant)
  1416.                     {
  1417.                         $variants[$variant->getPartnerID()] = $variant;
  1419.                         return $variants;
  1420.                     },
  1421.                     [],
  1422.                 );
  1424.                 foreach ($dish->variants as $key => $variant) {
  1425.                     if (!array_key_exists($variant->id, $offerExtensionVariants)) {
  1426.                         unset($dish->variants[$key]);
  1427.                         continue;
  1428.                     }
  1430.                     /**
  1431.                      * @var $offerExtensionVariant OfferExtensionVariant
  1432.                      */
  1433.                     $offerExtensionVariant = $offerExtensionVariants[$dish->variants[$key]->partnerId];
  1435.                     $dish->variants[$key]->id = $offerExtensionVariant->getID();
  1436.                     if (PriceDeliveryType::PERCENT_PRICE === $offerExtension->getPriceDeliveryType()) {
  1437.                         $dish->variants[$key]->offerPrice = (float) PriceDeliveryType::calcDeliveryPickupPrice(
  1438.                             $offerExtension,
  1439.                             $typePrice,
  1440.                             $dish->variants[$key]->regularPrice,
  1441.                             $offerExtension->getCurrentPrice(null, $typePrice),
  1442.                         );
  1443.                     }
  1444.                 }
  1445.             }
  1447.             $data['dishes'][] = $dish;
  1448.         }
  1450.         $data['dishes'] = $visibilityFilterService->filterInvisibleExtensions($data['dishes']);
  1452.         $sortType = $request->query->get('sort', CustomProductOfferSorter::DEFAULT_CUSTOM_PRODUCT_SORT);
  1453.         $data['dishes'] = $productSorter->sort($data['dishes'], $sortType);
  1455.         $dishGroup = $orderUtil->getDishGroups();
  1457.         $foodDishExtensionId = $request->query->get('extension');
  1458.         if (null !== $foodDishExtensionId) {
  1459.             $dishKey = array_search($foodDishExtensionId, \array_column($data['dishes'], 'id'));
  1460.             $foodCourtExtensionDish = $data['dishes'][$dishKey];
  1461.             unset($data['dishes'][$dishKey]);
  1463.             array_unshift($data['dishes'], $foodCourtExtensionDish);
  1465.             if (0 < count($dishGroup)) {
  1466.                 $category = $isSushiHouse ? $foodCourtExtensionDish->parentGroup : $foodCourtExtensionDish->groupName;
  1467.                 $keyDishGroup = array_search($category, $dishGroup);
  1468.                 $group = $dishGroup[$keyDishGroup];
  1469.                 unset($dishGroup[$keyDishGroup]);
  1471.                 array_unshift($dishGroup, $group);
  1472.             }
  1473.         }
  1475.         $data['topDishIDList'] = [];
  1476.         for ($i = 0; $i < 3; $i++) {
  1477.             if (isset($dishPurchaseCount[$i]['id'])) {
  1478.                 $data['topDishIDList'][] = $dishPurchaseCount[$i]['id'];
  1479.             }
  1480.         }
  1482.         if ($orderUtil::DISH_BY_GROUP) {
  1483.             $dishByGroupLabel = [];
  1484.             $dishByGroupContent = [];
  1486.             if ($isSushiHouse || $isSushiChefArts) {
  1487.                 foreach ($data['dishes'] as $dish) {
  1488.                     $dishByGroupContent[$dish->groupName][] = $dish;
  1489.                     if (!in_array($dish->parentGroup, $dishByGroupLabel)) {
  1490.                         $dishByGroupLabel[$dish->groupName] = $dish->parentGroup;
  1491.                     }
  1492.                 }
  1494.                 if ($isSushiHouse) {
  1495.                     $dishByGroupContent = $this->customSortDishByGroup($dishByGroupContent, $dishGroup);
  1496.                 }
  1497.             }
  1499.             if ($isDominos) {
  1500.                 foreach ($data['dishes'] as $dish) {
  1501.                     $dish->parentGroup = $dish->groupName;
  1502.                     $dishByGroupContent[$dish->groupName][] = $dish;
  1503.                     if (!in_array($dish->groupName, $dishByGroupLabel, true)) {
  1504.                         $dishByGroupLabel[$dish->groupName] = $dish->groupName;
  1505.                     }
  1506.                 }
  1507.             }
  1509.             $data['dishByGroup'] = [
  1510.                 'content' => $dishByGroupContent,
  1511.                 'label' => $dishByGroupLabel,
  1512.             ];
  1513.         }
  1515.         $dishGroup = $foodByOnlineCategoriesBuilder->create($offerId,$data['dishes']);
  1516.         if (!empty($dishGroup)) {
  1517.             $data['dishByGroup'] = array_key_exists('dishByGroup', $data)
  1518.                 ? [
  1519.                     'content' => array_merge($dishGroup['content'], $data['dishByGroup']['content']),
  1520.                     'label' => array_merge($dishGroup['label'], $data['dishByGroup']['label']),
  1521.                 ]
  1522.                 : $dishGroup;
  1523.         }
  1525.         $options = $isSushiVesla
  1526.             ? $orderUtil->getOptionsDBByShippingType(
  1527.                 $imageService,
  1528.                 \array_filter($allDishes, static fn (OfferExtension $offerExtension): bool => $offerExtension instanceof FoodOfferOptionExtension)
  1529.             )
  1530.             : $this->getOptions($imageService, $offerCached, $orderUtil, 0, $isDominos ? $shippingType : null);
  1532.         $data['options'] = $customProductOfferSorter->sort(
  1533.             $visibilityFilterService->filterInvisibleExtensions($options),
  1534.             CustomProductOfferSorter::DEFAULT_CUSTOM_PRODUCT_SORT,
  1535.         );
  1537.         $data['sortList'] = CustomProductOfferSorter::SORT_LIST;
  1538.         $data['isAvailableOnFood'] = $offerCached->isAvailableOnFood();
  1540.         $data['isAvailableOrderForToday'] = $shippingSchedulerService->availableOrderForToday($orderUtil, $offerCached, $typePrice);
  1542.         if ($isDominos) {
  1543.             $view = CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/delivery_teaser_reload_pickup.html.twig' : 'Slivki/delivery/delivery_teaser_reload_pickup.html.twig';
  1544.         } else {
  1545.             $view = CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/delivery_teaser_reload.html.twig' : 'Slivki/delivery/delivery_teaser_reload.html.twig';
  1546.         }
  1548.         return $this->render($view, $data);
  1549.     }
  1551.     private function calcPricePerKilogram(float $offerPrice, int $weight): ?float
  1552.     {
  1553.         if (!$weight) {
  1554.             return null;
  1555.         }
  1557.         return \round(self::KILOGRAM * $offerPrice / $weight, 2);
  1558.     }
  1560.     /** @Route("/expresspizza-orders") */
  1561.     public function expressPizzaOrdersAction(Request $request) {
  1562.         $offerID = 282278;
  1563.         $pass = '67380b434f';
  1564.         $objectCode = '0017-4-009';
  1566.         if ($pass != $request->query->get('pass')) {
  1567.             return new Response('ERROR: Wrong password!');
  1568.         }
  1570.         $date = \DateTime::createFromFormat('U', $request->query->get('date'));
  1572.         if (!$date) {
  1573.             return new Response('ERROR: Wrong date format!');
  1574.         }
  1576.         $entityManager = $this->getDoctrine()->getManager();
  1577.         /** @var Connection $connection */
  1578.         $connection = $entityManager->getConnection();
  1580.         $sql = "select"
  1581.                 . " offer_order.id as order_id,"
  1582.                 . " offer_order.paid_at as order_datetime,"
  1583.                 . " offer_order.delivery_time as delivery_datetime,"
  1584.                 . " user_address.name as client_name,"
  1585.                 . " user_address.phone as client_phone,"
  1586.                 . " user_address.pickup as pickup,"
  1587.                 . " street.name as street_name,"
  1588.                 . " user_address.house as house,"
  1589.                 . " user_address.block as block,"
  1590.                 . " user_address.entrance as entrance,"
  1591.                 . " user_address.floor as floor,"
  1592.                 . " user_address.doorphone as doorphone,"
  1593.                 . " user_address.appartment as appartment,"
  1594.                 . " offer_extension.partner_item_id as product_code,"
  1595.                 . " offer_extension.name as product_name,"
  1596.                 . " offer_order_details.items_count as items_count,"
  1597.                 . " offer_extension.dish_delivery_price as delivery_price,"
  1598.                 . " offer_extension.pickup_price as pickup_price,"
  1599.                 . " offer_order.parameter_int_0 as payment_type,"
  1600.                 . " offer_order.comment as comment,"
  1601.                 . " coalesce(geo_location.pickup_point_partner_id, '$objectCode') as object_code"
  1602.             . " from offer_order_details"
  1603.             . " inner join offer_order on offer_order.id = offer_order_details.offer_order_id"
  1604.             . " inner join user_address on offer_order.delivery_address_id = user_address.id"
  1605.             . " left join street on user_address.street_id = street.id"
  1606.             . " left join geo_location on user_address.geo_location_id = geo_location.id"
  1607.             . " inner join offer_extension on offer_extension.id = offer_order_details.offer_extension_id"
  1608.             . " where offer_order.offer_id = $offerID and offer_order.status > 0 and"
  1609.                 . " offer_order.paid_at >= '" . $date->format('Y-m-d H:i') . "'"
  1610.             . " order by offer_order.id";
  1612.         $orderDetails = $connection->executeQuery($sql)->fetchAll(\PDO::FETCH_ASSOC);
  1614.         $result = [];
  1615.         foreach ($orderDetails as $orderDetail) {
  1616.             $orderDateTime = new \DateTime($orderDetail['order_datetime']);
  1617.             $deliveryDateTime = new \DateTime();
  1618.             if ($orderDetail['delivery_datetime'] != 'Ближайшее') {
  1619.                 $deliveryDateTime = new \DateTime($orderDetail['delivery_datetime']);
  1620.             }
  1622.             $comment = '';
  1624.             if (trim($orderDetail['entrance'])) {
  1625.                 $comment .= 'П' . trim($orderDetail['entrance']) . ' ';
  1626.             }
  1628.             if (trim($orderDetail['floor'])) {
  1629.                 $comment .= 'Э' . trim($orderDetail['floor']) . ' ';
  1630.             }
  1632.             if (trim($orderDetail['doorphone'])) {
  1633.                 $comment .= 'Д' . trim($orderDetail['doorphone']) . ' ';
  1634.             }
  1636.             $paymentType = '';
  1637.             switch ($orderDetail['payment_type']) {
  1638.                 case 1:
  1639.                     $paymentType = 'Оплата: онлайн, ';
  1640.                     break;
  1641.                 case 2:
  1642.                     $paymentType = 'Оплата: наличные, ';
  1643.                     break;
  1644.                 case 3:
  1645.                     $paymentType = 'Оплата: терминал, ';
  1646.             }
  1647.             $comment .= $paymentType;
  1649.             $comment .= trim($orderDetail['comment']);
  1651.             $result[] = join(chr(9), [
  1652.                 $orderDetail['object_code'], // Код объекта
  1653.                 $orderDetail['order_id'], // Номер заказа
  1654.                 $orderDateTime->format('d.m.Y'), // Дата заказа
  1655.                 $orderDateTime->format('H:i'), // Время заказа
  1656.                 $deliveryDateTime->format('H:i'), // Изготовить к какому времени
  1657.                 $orderDetail['client_name'], // Имя клиента – Контакт
  1658.                 str_replace('+375', '+375 ', $orderDetail['client_phone']), // Контактный телефон.
  1659.                 $orderDetail['pickup'] ? 0 : 1, // Тип получения: на месте (0) или доставка (1).
  1660.                 trim($orderDetail['street_name']) ?: ' ', // Улица доставки
  1661.                 trim($orderDetail['house']) ?: ' ', // Номер дома
  1662.                 trim($orderDetail['block']) ?: ' ', // Корпус
  1663.                 trim($orderDetail['appartment']) ?: ' ', // Квартира
  1664.                 ' ', // Код группы
  1665.                 $orderDetail['product_code'], // Код товара
  1666.                 ' ', // IDNT Номер выгрузки (оставляйте пустым)
  1667.                 $orderDetail['product_name'], // Название товара
  1668.                 $orderDetail['items_count'], // Количество
  1669.                 $orderDetail['pickup'] ? $orderDetail['pickup_price'] : $orderDetail['delivery_price'], // Цена
  1670.                 str_replace(["\r\n", "\n"],' ', $comment), // Примечание
  1671.             ]);
  1672.         }
  1674.         $result[] = chr(9) . 'OK';
  1676.         return new Response(join("\r\n", $result));
  1677.     }
  1679.     private function customSortDishByGroup(array $dishByGroupContent, array $sort): array
  1680.     {
  1681.         uasort($dishByGroupContent, function ($dishGroup1, $dishGroup2) use ($sort) {
  1682.             if (!count($dishGroup1)) {
  1683.                 return 1;
  1684.             }
  1685.             if (!count($dishGroup2)) {
  1686.                 return -1;
  1687.             }
  1688.             $dishGroup1Key = array_search($dishGroup1[0]->parentGroup, $sort);
  1689.             $dishGroup2Key = array_search($dishGroup2[0]->parentGroup, $sort);
  1690.             return $dishGroup1Key < $dishGroup2Key ? -1 : 1;
  1691.         });
  1693.         return $dishByGroupContent;
  1694.     }
  1695. }