Symfony Profiler

<?php
namespace App\Controller;
use App\Controller\Api\ApiCheckoutController;
use App\Entity\EndUser;
use App\Entity\FunnelVisitor;
use App\Entity\Order;
use App\Entity\Product;
use App\Entity\Tracker;
use App\Form\Type\OrderType;
use App\Form\Type\PostUpsellOrderType;
use App\Helper\Order\OrderHelper;
use App\Service\EndUserManager;
use App\Service\EventProvider\EventProvider;
use App\Service\EventProviderManager;
use App\Service\FunnelVisitorManager;
use App\Service\OrderHolderManager;
use App\Service\OrderManager;
use App\Service\OrderReminderManager;
use App\Service\OrderSubscriptionManager;
use App\Service\ProductManager;
use App\Service\ProductPostUpsellManager;
use App\Service\TrackerManager;
use App\Service\UpsellCheckoutManager;
use App\Service\VisitorsTracker;
use App\Service\VoucherService;
use Detection\MobileDetect;
use GeoIp2\Database\Reader;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Response;
use App\Service\ReplacerTextManager;
use App\Service\ProductVariantManager;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
final class CheckoutPageController extends CustomAbstractController
{
private $productManager;
private $orderManager;
private $session;
private $endUserManager;
private $replacerTextManager;
private $orderReminderManager;
private $trackerManager;
private $productVariantManager;
private $productPostUpsellManager;
private $eventProviderManager;
private $orderHolderManager;
private $orderSubscriptionManager;
private $visitorsTracker;
private UpsellCheckoutManager $upsellCheckoutManager;
private FunnelVisitorManager $funnelVisitorManager;
private VoucherService $voucherService;
public function __construct(
ProductManager $productManager,
SessionInterface $session,
OrderManager $orderManager,
EndUserManager $endUserManager,
ReplacerTextManager $replacerTextManager,
OrderReminderManager $orderReminderManager,
TrackerManager $trackerManager,
ProductVariantManager $productVariantManager,
ProductPostUpsellManager $productPostUpsellManager,
EventProviderManager $eventProviderManager,
OrderHolderManager $orderHolderManager,
OrderSubscriptionManager $orderSubscriptionManager,
VisitorsTracker $visitorsTracker,
FunnelVisitorManager $funnelVisitorManager,
UpsellCheckoutManager $upsellCheckoutManager,
VoucherService $voucherService
)
{
$this->productManager = $productManager;
$this->orderManager = $orderManager;
$this->session = $session;
$this->endUserManager = $endUserManager;
$this->replacerTextManager = $replacerTextManager;
$this->orderReminderManager = $orderReminderManager;
$this->trackerManager = $trackerManager;
$this->productVariantManager = $productVariantManager;
$this->productPostUpsellManager = $productPostUpsellManager;
$this->eventProviderManager = $eventProviderManager;
$this->orderHolderManager = $orderHolderManager;
$this->orderSubscriptionManager = $orderSubscriptionManager;
$this->visitorsTracker = $visitorsTracker;
$this->funnelVisitorManager = $funnelVisitorManager;
$this->upsellCheckoutManager = $upsellCheckoutManager;
$this->voucherService = $voucherService;
}
/**
* @Route("/{_locale}/product1/{urlTitle}", name="product_page1")
* @param Request $request
* @param string $url_title
* @return Response
*/
public function checkoutPage(Request $request, string $url_title): Response
{
$order = new Order();
$this->defineCountry($request);
$product = $this->productManager->getProduct($url_title, $request->server->get('HTTP_HOST'));
$productVariant = $this->productVariantManager->getPreselectedProductVariant($product);
$this->initiateCart($product, $product->getUpsells());
$cartKey = OrderHelper::cartKey($product, ApiCheckoutController::SESSION_UPSELL_KEY);
$upsells = $this->session->has($cartKey) ? $this->session->get($cartKey) : [];
// $this->checkOrderReminder($request, $order, $url_title);
$isStepTwo = $this->session->has('order') && isset($this->session->get('order')[$url_title]);
if ($isStepTwo) {
$productVariant = $this->productManager->getProductVariant($product, $this->session->get('variantId'));
$this->handleStepTwo($request, $order, $url_title, $product, $productVariant);
} else {
$this->handleStepOne($request, $productVariant, $product);
}
$form = $this->createOrderForm($order, $product, $isStepTwo, $request);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
return $this->handleFormSubmission($form, $request, $url_title, $product, $productVariant, $upsells, $isStepTwo);
}
return $this->renderCheckoutPage($request, $isStepTwo, $product, $productVariant, $form, $upsells);
}
private function handleStepTwo(Request $request, Order $order, string $url_title, Product $product, $productVariant)
{
$stepOneOrder = $this->session->get('order')[$url_title];
$formEndUser = $stepOneOrder->getEndUser();
$endUser = $this->endUserManager->findUserByEmail($formEndUser->getEmail()) ?? $formEndUser;
$endUser
->setLocale($request->getLocale())
->setSubscribed($formEndUser->isSubscribed());
$order->setEndUser($endUser)
->setTermsAndConditions($stepOneOrder->isTermsAndConditions())
->setEventId($this->session->get('eventID'))
->setEventAdditionalParams($this->eventProviderManager->processRequestEventParams())
->setType($stepOneOrder->getType())
->setSubscriptionId($stepOneOrder->getSubscriptionId());
if (!$this->session->has('orderReminder')) {
$orderReminder = $this->orderReminderManager->save($product, $productVariant, $endUser);
$this->session->set('orderReminder', $orderReminder);
}
$this->funnelVisitorManager->internalTrack(
FunnelVisitor::INTERNAL_PAGE_ADD_PAYMENT_INFO,
$request,
$product
);
}
private function handleStepOne(Request $request, $productVariant, $product)
{
if ($request->isMethod($request::METHOD_GET)) {
// $this->eventProviderManager->sendEvent(
// EventProvider::EVENT_ADD_TO_CART,
// $productVariant
// );
$this->visitorsTracker->tracking($request, $product);
$this->funnelVisitorManager->internalTrack(
FunnelVisitor::INTERNAL_PAGE_ADD_TO_CART,
$request,
$product
);
}
}
private function createOrderForm(Order $order, $product, bool $isStepTwo, Request $request)
{
return $this->createForm(OrderType::class, $order, [
'action' => $this->generateUrlWithParams('product_page', ['urlTitle' => $product->getUrlTitle()], UrlGeneratorInterface::ABSOLUTE_PATH, $request),
'method' => 'POST',
'step2' => $isStepTwo,
'product' => $product,
'endUser' => $order->getEndUser(),
]);
}
private function handleFormSubmission(FormInterface $form, Request $request, string $url_title, $product, $productVariant, $upsells, bool $isStepTwo)
{
$order = $form->getData();
$vouchers = $form->has('endUserVouchers') ? $form->get('endUserVouchers')->getData() : [];
if (!$isStepTwo) {
$this->session->set('order', [$url_title => $order]);
$this->session->set('variantId', $form->get('variantId')->getData());
$this->eventProviderManager->sendEvent(
EventProvider::EVENT_INITIATE_CHECKOUT,
$this->productManager->getProductVariant($product, $this->session->get('variantId')),
$this->endUserManager->findUserByEmail($order->getEndUser()->getEmail()) ?? $order->getEndUser(),
null,
$order->getEndUser()->isSubscribed()
);
return $this->json(['redirectUrl' => $this->generateUrlWithParams(
'product_page', ['urlTitle' => $product->getUrlTitle()], UrlGeneratorInterface::ABSOLUTE_PATH, $request)
]);
}
$trackingParams = json_decode($request->cookies->get('tracking', ''), true);
if ($trackingParams) {
if (isset($trackingParams[Tracker::TRACKER_PARAM])) {
$tracker = $this->trackerManager->findTracker($trackingParams[Tracker::TRACKER_PARAM]);
$order->setTracker($tracker);
}
$order->setTrackingParams($trackingParams);
}
$order->setFunnel($this->funnelVisitorManager->detectCheckoutFunnel($request, $product));
$order->setIp($request->getClientIp());
// $this->funnelVisitorManager->assignTrackerInfoFromFunnelFirstStep($order, $product, $request->server->get('REMOTE_ADDR'));
if ($this->orderManager->saveOrder($order, $product, $productVariant, $upsells, $vouchers)) {
$orderReminder = $this->session->get('orderReminder');
$this->orderReminderManager->update($orderReminder, ['orderSaved' => true]);
$this->session->remove('orderReminder');
$this->session->remove(OrderHelper::cartKey($product, ApiCheckoutController::SESSION_UPSELL_KEY));
$this->session->remove('order');
$this->orderSubscriptionManager->isSubscriptionRequired($order);
return $this->processPayment($order, $product, $request);
}
return $this->json(['error' => 'Unable to save order']);
}
private function processPayment(Order $order, $product, Request $request)
{
$response = $this->orderManager->processPayment($order);
if (isset($response['redirectUrl'])) {
$this->eventProviderManager->sendEvent(
EventProvider::EVENT_ADD_PAYMENT_INFO,
$this->orderManager->getMainProductVariant($order),
$order->getUserSnapshot(),
$order
);
$this->orderManager->updateOrderPaymentWithResponse($order, $response);
return $this->json(['redirectUrl' => $response['redirectUrl']]);
} elseif (isset($response['client_token'])) {
return $this->json(['redirectUrl' => $this->generateUrl('klarna_checkout', [
'_locale' => $request->getLocale(),
'url_title' => $product->getUrlTitle(),
'order_number' => $order->getOrderNumber(),
'client_token' => $response['client_token']
])]);
} else {
$this->session->remove('order');
$this->session->set('orderFailed', true);
$this->orderManager->updateOrderPaymentWithResponse($order, ['status' => Order::STATUS_FAILED]);
return $this->json(['redirectUrl' => $this->generateUrlWithParams('product_page', [
'_locale' => $request->getLocale(),
'urlTitle' => $product->getUrlTitle()
],UrlGeneratorInterface::ABSOLUTE_PATH, $request)]);
}
}
private function renderCheckoutPage(Request $request, bool $isStepTwo, $product, $productVariant, $form, $upsells)
{
$locale = substr($request->headers->get('accept-language', 'en'), 0, 2);
$orderFailed = $this->session->has('orderFailed') ? $this->session->get('orderFailed') : false;
$this->session->remove('orderFailed');
foreach ($product->getUpsells() as $upsell) {
$upsell->setDescription($this->replacerTextManager->replaceText(
['product' => $upsell],
$upsell->getDescription())
);
}
return $this->render(sprintf('App/checkout/step%s.html.twig', ($isStepTwo ? '2' : '1')), [
'product' => $product,
'productVariant' => $productVariant,
'form' => $form->createView(),
'shippingCosts' => $this->orderManager->getProductShippingCosts($product, $productVariant->getId(), $productVariant->getTotalPrice()),
'orderFailed' => $orderFailed,
'upsells' => $upsells,
'browserLocale' => $locale,
'hasVoucher' => $this->hasVoucher($product, $upsells),
'isMobile' => (new MobileDetect())->isMobile()
]);
}
private function hasVoucher(Product $product, ?array $upsells = []): bool
{
$hasVoucher = false;
if ($product->getProductDetail()->isVoucher()) {
$hasVoucher = true;
}
foreach ($upsells as $upsell) {
$productUpsell = $this->productManager->findProductById($upsell['productId']);
if ($productUpsell && $productUpsell->getProductDetail()->isVoucher()) {
$hasVoucher = true;
}
}
return $hasVoucher;
}
// /**
// * @Route("/{_locale}/checkout/{url_title}", name="checkout_step3")
// */
// public function checkoutPageStepThree(Request $request, $url_title): Response
// {
// $product = $this->productManager->getProduct($url_title, $request->server->get('HTTP_HOST'));
//
// return $this->render('App/checkout/step3.html.twig', [
// 'product' => $product
// ]);
// }
/**
* @Route("/{_locale}/thank-you/{order_id}", name="thank_you_page")
* @param Request $request
* @param $order_id
* @return Response
*/
public function thankYou(Request $request, $order_id): Response
{
$order = $this->orderManager->getOrderById(base64_decode($order_id));
if (!$order) {
throw new NotFoundHttpException('Order not found');
}
$product = $order->getFirstProduct();
$product->setActiveDomain($order->getDomain());
$defaultResponse = $this->render('App/checkout/pending_page.html.twig', [
'product' => $product,
'order' => $order
]);
if ($request->query->has('status')) {
$this->session->set('refreshEventID', true);
switch ($request->query->get('status')) {
case Order::STATUS_PENDING:
if ($order->getPaymentStatus() !== Order::STATUS_PENDING ) {
break;
}
$response = $this->renderSuccessPage($request, $order, $product);
break;
case OrderHelper::isSuccessfulOrder($order):
if ($order->getPaymentStatus() !== Order::STATUS_PAID && $order->getPaymentStatus() !== Order::STATUS_IN_PROCESS) {
break;
}
$response = $this->renderSuccessPage($request, $order, $product);
break;
case Order::STATUS_FAILED:
if ($order->getParent()) {
$order = $order->getParent();
$product = $this->orderManager->getMainProduct($order);
$product->setActiveDomain($order->getDomain());
}
$product->setErrorPage($this->replacerTextManager->replaceText(
['order' => $order],
$product->getErrorPage()
));
$response = $this->render('App/checkout/error_page.html.twig', [
'order' => $order,
'product' => $product
]);
break;
default:
$response = $defaultResponse;
break;
}
}
return $response ?? $defaultResponse;
}
private function renderSuccessPage($request, Order $order, Product $product)
{
if ($this->upsellCheckoutManager->isNeedRenderCheckout($request, $order)) {
return $this->redirectToRouteWithParams('upsell_checkout_page',
[
'_locale' => $order->getUserSnapshot()->getLocale(),
'url_title' => $product->getUrlTitle(),
'order_id' => base64_encode($order->getId())
],
);
}
$postUpsellCheckoutUrl = $this->productPostUpsellManager->processPostUpsellCheckout($order);
if ($postUpsellCheckoutUrl && !$request->query->has('skip')) {
return $this->redirect($postUpsellCheckoutUrl);
} else {
if ($order->getParent()) {
$order = $order->getParent();
$product = $this->orderManager->getMainProduct($order);
$product->setActiveDomain($order->getDomain());
}
}
$product->setImagePath($this->productManager->getMainProductImageByOrder($order));
$product->setThanksPage($this->replacerTextManager->replaceText(
[
'order' => $order,
'product' => $product
],
$product->getThanksPage())
);
$this->funnelVisitorManager->internalTrack(
FunnelVisitor::INTERNAL_PAGE_THANK_YOU,
$request,
$product,
true
);
return $this->render('App/checkout/success_page.html.twig', [
'order' => $order,
'product' => $product,
'custom_code' => $this->showTrackerCustomerCode($request, $order),
'lastPaidOrder' => $this->orderManager->getLastPaidOrderByUser($order->getEndUser())
]);
}
/**
* @Route("/{_locale}/cart/add", name="add_cart", condition="request.isXmlHttpRequest()")
* @param Request $request
* @return Response
*/
public function addToCart(Request $request): Response
{
$productId = $request->get('productId');
$quantity = $request->get('quantity');
$product = $this->productManager->findProductById($productId);
return $this->render('App/checkout/partials/cart_add.html.twig', [
'product' => $product,
'quantity' => $quantity
]);
}
/**
* @Route("{_locale}/cart/shipping", name="calculate_shipping", condition="request.isXmlHttpRequest()")
* @param Request $request
* @return Response
*/
public function ajaxCalculateShipping(Request $request): Response
{
$productId = $request->get('productId');
$price = $request->get('price');
$variantId = $request->get('variantId');
$product = $this->productManager->findProductById($productId);
return $this->render('App/checkout/partials/shipping_cost.html.twig', [
'product' => $product,
'shippingCosts' => $this->orderManager->getProductShippingCosts($product, $variantId, $price),
'variantId' => $variantId
]);
}
public function checkOrderReminder(Request $request, Order $order, string $urlTitle): void
{
if (!$request->query->has('order')) {
return;
}
$hash = $request->query->get('order');
$orderReminder = $this->orderReminderManager->findByHash($hash);
if ($orderReminder) {
$endUser = $this->endUserManager->findUserByEmail($orderReminder->getEmail());
if (!$endUser) {
$endUser = new EndUser();
$endUser->setEmail($orderReminder->getEmail());
$endUser->setFirstName($orderReminder->getFirstName());
}
$order->setEndUser($endUser);
$order->setTermsAndConditions(true);
if ($orderReminder->getProductVariant()) {
$this->session->set('variantId', $orderReminder->getProductVariant()->getId());
}
$this->session->set('order', [$urlTitle => $order]);
$this->session->set('orderReminder', $orderReminder);
}
}
/**
* @Route("{_locale}/cart/changeCountry", name="change_country")
* @param Request $request
* @return Response
*/
public function ajaxChangeCountry(Request $request): Response
{
$productId = $request->get('productId');
$countryId = $request->get('countryId');
$orderType = $request->get('type');
$hasVoucher = (bool)$request->get('hasVoucher');
$paymentMethods = $this->orderManager->getPaymentMethodsOnStepTwo($productId, $countryId, $orderType, $hasVoucher);
return $this->render('App/checkout/partials/payment_methods.html.twig', [
'paymentMethods' => $paymentMethods,
]);
}
/**
* @Route("/{_locale}/product/{url_title}/{order_id}/{position}", name="post_upsell_page")
*/
public function postUpsellPage(Request $request, $url_title, $order_id, $position): Response
{
$parentOrder = $this->orderManager->getOrderById(base64_decode($order_id));
$mainProduct = $this->productManager->getProduct($url_title, $request->server->get('HTTP_HOST'));
$postUpsell = $this->productPostUpsellManager
->getProductPostUpsellByProductAndPosition($mainProduct, $position);
$orderHold = $this->orderHolderManager->getByOrder($parentOrder);
if (!$postUpsell || !$parentOrder || is_null($postUpsell->getProductPostUpsell()) || ($orderHold && $orderHold->isSent())) {
return $this->redirectToRouteWithParams('product_page', [
'_locale' => $request->getLocale(),
'urlTitle' => $url_title
],
302,
$request);
}
$productPostUpsell = $this->productManager
->getProduct($postUpsell->getProductPostUpsell()->getUrlTitle(), $request->server->get('HTTP_HOST'), true);
$form = $this->createForm(PostUpsellOrderType::class, null, [
'action' => $this->generateUrlWithParams('post_upsell_page', [
'url_title' => $url_title,
'order_id' => $order_id,
'position' => $position
],UrlGeneratorInterface::ABSOLUTE_PATH, $request),
'order' => $parentOrder,
'method' => 'POST'
]);
$form->handleRequest($request);
$existOrder = $this->orderManager
->getOrderByOrderNumber(sprintf('%s_%s', $parentOrder->getOrderNumber(), $position));
if ($existOrder) {
return $this->redirectToRouteWithParams('thank_you_page', [
'_locale' => $request->getLocale(),
'order_id' => base64_encode($existOrder->getId())
],
302,
$request
);
}
if ($form->isSubmitted() && $form->isValid()) {
$order = new Order();
$formData = $form->getData();
$productVariant = $this->productManager->getProductVariant($productPostUpsell, $formData['variantId']);
$order
->setEndUser($parentOrder->getEndUser())
->setTermsAndConditions(true)
->setPaymentMethod([
'id' => $parentOrder->getPaymentMethod(),
'provider' => $parentOrder->getPaymentProvider()->getName()
])
->setParent($parentOrder)
->setType(Order::TYPE_ONE_OFF)
->setEventAdditionalParams($parentOrder->getEventAdditionalParams())
->setEventId($parentOrder->getEventId());
if ($parentOrder->getTracker()) {
$order->setTracker($parentOrder->getTracker());
if ($parentOrder->getTrackingParams()) {
$order->setTrackingParams($parentOrder->getTrackingParams());
}
}
$order->setFunnel($this->funnelVisitorManager->detectCheckoutFunnel($request, $productPostUpsell));
$order->setIp($request->getClientIp());
if ($this->orderManager->saveOrder($order, $productPostUpsell, $productVariant)) {
$response = $this->orderManager->processPayment($order);
if (isset($response['redirectUrl'])) {
$this->orderManager->updateOrderPaymentWithResponse($order, $response);
return $this->json(['redirectUrl' => $response['redirectUrl']]);
} else {
$this->session->remove('order');
$this->session->set('orderFailed', true);
$this->orderManager->updateOrderPaymentWithResponse($order, ['status' => Order::STATUS_FAILED]);
return $this->json(['redirectUrl' => $this->generateUrlWithParams('product_page', [
'_locale' => $request->getLocale(),
'urlTitle' => $mainProduct->getUrlTitle()
],UrlGeneratorInterface::ABSOLUTE_PATH, $request)
]);
}
}
}
$locale = substr($request->headers->get('accept-language', 'en'), 0, 2);
$this->funnelVisitorManager->internalTrack(
sprintf(FunnelVisitor::INTERNAL_PAGE_POST_UPSELL, $position),
$request,
$productPostUpsell
);
return $this->render('App/checkout/post_upsell.html.twig', [
'product' => $productPostUpsell,
'shippingCosts' => $this->orderManager->getProductShippingCosts($productPostUpsell),
'form' => $form->createView(),
'productInfo' => $postUpsell->getProductInfo(),
'skipUrl' => $this->productPostUpsellManager->getNextPosition($parentOrder, $postUpsell),
'browserLocale' => $locale,
'mainProduct' => $mainProduct,
'position' => $position,
'custom_code' => $position == 1
? $this->showTrackerCustomerCode($request, $parentOrder)
: [],
'lastPaidOrder' => $this->orderManager->getLastPaidOrderByUser($parentOrder->getEndUser())
]);
}
/**
* @Route("/{_locale}/upsell-checkout/{url_title}/{order_id}", name="upsell_checkout_page")
*/
public function upsellCheckoutPage(Request $request, $url_title, $order_id): Response
{
$parentOrder = $this->orderManager->getOrderById(base64_decode($order_id));
$mainProduct = $this->productManager->getProduct($url_title, $request->server->get('HTTP_HOST'));
$upsells = $this->upsellCheckoutManager->upsellsForCheckout($mainProduct, $parentOrder);
$cartKey = OrderHelper::cartKey($mainProduct, ApiCheckoutController::SESSION_UPSELL_PAGE_KEY);
$choosedUpsells = $this->session->has($cartKey) ? $this->session->get($cartKey) : [];
$skipUrl = $this->generateUrlWithParams('thank_you_page', [
'_locale' => $request->getLocale(),
'order_id' => $order_id,
UpsellCheckoutManager::SKIP_PARAM => 'true'
],
UrlGeneratorInterface::ABSOLUTE_PATH,
$request,
);
$form = $this->createForm(PostUpsellOrderType::class, null, [
'action' => $this->generateUrlWithParams('upsell_checkout_page', [
'url_title' => $url_title,
'order_id' => $order_id,
],UrlGeneratorInterface::ABSOLUTE_PATH, $request),
'order' => $parentOrder,
'method' => 'POST'
]);
$form->handleRequest($request);
$existOrder = $this->orderManager
->getOrderByOrderNumber(sprintf('%s_%s', $parentOrder->getOrderNumber(), 0));
if ($existOrder) {
return $this->redirectToRouteWithParams('thank_you_page', [
'_locale' => $request->getLocale(),
'order_id' => base64_encode($existOrder->getId())
],
302,
$request
);
}
if ($form->isSubmitted() && $form->isValid()) {
$order = new Order();
$formData = $form->getData();
$order
->setEndUser($parentOrder->getEndUser())
->setTermsAndConditions(true)
->setPaymentMethod([
'id' => $parentOrder->getPaymentMethod(),
'provider' => $parentOrder->getPaymentProvider()->getName()
])
->setParent($parentOrder)
->setType(Order::TYPE_ONE_OFF)
->setIp($request->getClientIp())
->setEventAdditionalParams($parentOrder->getEventAdditionalParams())
->setEventId($parentOrder->getEventId());
if ($parentOrder->getTracker()) {
$order->setTracker($parentOrder->getTracker());
if ($parentOrder->getTrackingParams()) {
$order->setTrackingParams($parentOrder->getTrackingParams());
}
}
$order->setFunnel($parentOrder->getFunnel())
->setDomainVat($parentOrder->getDomainVat())
->setCurrency($parentOrder->getCurrency())
->setDomain($parentOrder->getDomain())
->setWarehouse($parentOrder->getWarehouse())
->setShippingProvider($parentOrder->getShippingProvider());
$discountPercentage = $mainProduct->getUpsellPageDiscountPercentage() && $mainProduct->getUpsellPageDiscountPercentage() > 0 && $parentOrder->isFirstOrder()
? $mainProduct->getUpsellPageDiscountPercentage()
: null;
if ($this->orderManager->saveUpsellOrder($order, $choosedUpsells, $discountPercentage)) {
$response = $this->orderManager->processPayment($order);
$this->session->remove($cartKey);
if (isset($response['redirectUrl'])) {
$this->orderManager->updateOrderPaymentWithResponse($order, $response);
return $this->json(['redirectUrl' => $response['redirectUrl']]);
} else {
$this->session->remove('order');
$this->session->set('orderFailed', true);
$this->orderManager->updateOrderPaymentWithResponse($order, ['status' => Order::STATUS_FAILED]);
return $this->json(['redirectUrl' => $this->generateUrlWithParams('product_page', [
'_locale' => $request->getLocale(),
'urlTitle' => $mainProduct->getUrlTitle()
],UrlGeneratorInterface::ABSOLUTE_PATH, $request)
]);
}
}
}
//
$locale = substr($request->headers->get('accept-language', 'en'), 0, 2);
$mainProduct->clearUpsells();
$discountPercentage = $mainProduct->getUpsellPageDiscountPercentage() && $mainProduct->getUpsellPageDiscountPercentage() > 0 && $parentOrder->isFirstOrder()
? $mainProduct->getUpsellPageDiscountPercentage()
: null;
foreach ($upsells as $upsell) {
if ($discountPercentage) {
$productVariant = $upsell->getVariants()->first();
$totalPrice = $productVariant->getTotalPrice();
$discountAmount = ($totalPrice * $discountPercentage) / 100;
$discountedPrice = round($totalPrice - $discountAmount, 2);
$productVariant->setTotalPrice($discountedPrice)
->setUnitPrice($discountedPrice);
}
$mainProduct->addUpsell($upsell);
}
return $this->render('App/checkout/upsell_checkout_page.html.twig', [
'product' => $mainProduct,
'choosedUpsells' => $choosedUpsells,
// 'shippingCosts' => $this->orderManager->getProductShippingCosts($productPostUpsell),
'form' => $form->createView(),
// 'productInfo' => $postUpsell->getProductInfo(),
'browserLocale' => $locale,
'mainProduct' => $mainProduct,
'skipUrl' => $skipUrl,
'lastPaidOrder' => $this->orderManager->getLastPaidOrderByUser($parentOrder->getEndUser()),
'discountPercentage' => $discountPercentage,
'isFirstOrder' => $parentOrder->isFirstOrder() ? "1" : "0",
]);
}
private function showTrackerCustomerCode($request, $order)
{
$pageKey = md5('purchase-' . $order->getOrderNumber());
$tracker = $order->getTracker();
return [
'show' => !$request->cookies->has($pageKey),
'content' => $tracker && $tracker->getThankYouPageCustomCode()
? $tracker->getThankYouPageCustomCode()
: null,
'page_key' => $pageKey
];
}
private function defineCountry(Request $request)
{
$filePath = '/var/www/ADMIN/GeoIP/GeoLite2-Country.mmdb';
if (file_exists($filePath)) {
$reader = new Reader($filePath);
$ip = $request->server->get('REMOTE_ADDR');
try {
$country = $reader->country($ip);
$countryCode = $country->country->isoCode;
$this->session->set('country_code', $countryCode);
} catch (\Exception $exception) {
$this->session->set('country_code', 'NL');
}
} else {
$this->session->set('country_code', 'NL');
}
}
private function initiateCart(Product $product, $upsells): void
{
$sessionUpsells = [];
$sessionKey = OrderHelper::cartKey($product, ApiCheckoutController::SESSION_UPSELL_KEY);
/**
* @var Product $upsell
*/
if (!$this->session->has($sessionKey)) {
foreach ($upsells as $upsell) {
if (!$upsell->getProductDetail()->isOutOfStock() && $upsell->isAutoCartAdd()) {
$sessionUpsells[$upsell->getId()] = [
'productId' => $upsell->getId(),
'quantity' => 1
];
}
}
if (!empty($sessionUpsells)) {
$this->session->set($sessionKey, $sessionUpsells);
}
}
}
}

src/Controller/CheckoutPageController.php line 710