Symfony Profiler

<?php
/**
* Pimcore
*
* This source file is available under two different licenses:
* - GNU General Public License version 3 (GPLv3)
* - Pimcore Enterprise License (PEL)
* Full copyright and license information is available in
* LICENSE.md which is distributed with this source code.
*
* @copyright Copyright (c) Pimcore GmbH (http://www.pimcore.org)
* @license http://www.pimcore.org/license GPLv3 and PEL
*/
namespace App\Controller;
use App\EventListener\AuthenticationLoginListener;
use App\Form\LoginFormType;
use App\Form\RegistrationFormHandler;
use App\Form\RegistrationFormType;
use App\Model\Customer;
use App\Model\PreOrderItem;
use App\Model\PurchaseOrder;
use App\Services\CurlService;
use App\Services\NewsletterDoubleOptInService;
use App\Services\PasswordRecoveryService;
use CustomerManagementFrameworkBundle\CustomerProvider\CustomerProviderInterface;
use CustomerManagementFrameworkBundle\CustomerSaveValidator\Exception\DuplicateCustomerException;
use CustomerManagementFrameworkBundle\Model\CustomerInterface;
use CustomerManagementFrameworkBundle\Security\Authentication\LoginManagerInterface;
use CustomerManagementFrameworkBundle\Security\OAuth\Exception\AccountNotLinkedException;
use CustomerManagementFrameworkBundle\Security\OAuth\OAuthRegistrationHandler;
use CustomerManagementFrameworkBundle\Security\SsoIdentity\SsoIdentityServiceInterface;
use HWI\Bundle\OAuthBundle\OAuth\Response\UserResponseInterface;
use HWI\Bundle\OAuthBundle\Security\Core\Authentication\Token\OAuthToken;
use Pimcore\Bundle\EcommerceFrameworkBundle\Factory;
use Pimcore\Bundle\EcommerceFrameworkBundle\OrderManager\Order\Listing\Filter\CustomerObject;
use Pimcore\DataObject\Consent\Service;
use Pimcore\Translation\Translator;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
use Symfony\Component\Uid\Uuid;
use App\Model\Order;
use Knp\Component\Pager\Pagination\SlidingPagination;
use Knp\Component\Pager\PaginatorInterface;
use Pimcore\Model\DataObject;
use Box\Spout\Writer\Common\Creator\WriterEntityFactory;
use Box\Spout\Common\Entity\Row;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use FrontendPermissionToolkitBundle\Service as FrontenKitService;
use Symfony\Component\Security\Core\Security as SymfonySecurity;
use Doctrine\ORM\EntityManagerInterface;
use App\Model\Utility;
/**
* Class AccountController
*
* Controller that handles all account functionality, including register, login and connect to SSO profiles
*/
class AccountController extends BaseController
{
const LIMIT_PER_PAGE = 10;
protected $service;
public $security;
public function __construct(EventDispatcherInterface $eventDispatcher,SymfonySecurity $security)
{
$this->service = new FrontenKitService($eventDispatcher);
if($security->getUser() && $security->getUser()->getUserRoles() == 'customer'){
return $this->redirectToRoute('b2c-account-index');
}
}
/**
* @Route("/account/login", name="account-login")
*
* @param AuthenticationUtils $authenticationUtils
* @param OAuthRegistrationHandler $oAuthHandler
* @param SessionInterface $session
* @param Request $request
* @param UserInterface|null $user
*
* @return Response|RedirectResponse
*/
public function loginAction(
AuthenticationUtils $authenticationUtils,
OAuthRegistrationHandler $oAuthHandler,
SessionInterface $session,
Request $request,
UserInterface $user = null
) {
\Pimcore\Cache::disable();
//redirect user to index page if logged in
if ($user && $this->isGranted('ROLE_USER')) {
return $this->redirectToRoute('account-index');
}
// get the login error if there is one
$error = $authenticationUtils->getLastAuthenticationError();
// OAuth handling - the OAuth authenticator is configured to return to the login page on errors
// (see failure_path configuration) - therefore we can fetch the last authentication error
// here. If the error is an AccountNotLinkedException (as thrown by our user provider) save the
// OAuth token to the session and redirect to registration with a special key which can be used
// to load the token to prepopulate the registration form with account data.
if ($error instanceof AccountNotLinkedException) {
// this can be anything - for simplicity we just use an UUID as it is unique and random
$registrationKey = (string) Uuid::v4()->toRfc4122();
$oAuthHandler->saveToken($registrationKey, $error->getToken());
return $this->redirectToRoute('account-register', [
'registrationKey' => $registrationKey
]);
}
// last username entered by the user
$lastUsername = $authenticationUtils->getLastUsername();
$formData = [
'_username' => $lastUsername
];
$form = $this->createForm(LoginFormType::class, $formData, [
'action' => $this->generateUrl('account-login'),
]);
// p_r($request->headers->get('referer'));exit;
//store referer in session to get redirected after login
if (!$request->get('no-referer-redirect')) {
$session->set('_security.demo_frontend.target_path', $request->headers->get('referer'));
}
if($this->document->getKey() == "b2c" || $this->document->getKey() == "en"){
return $this->render('account/b2c_login.html.twig', [
'form' => $form->createView(),
'error' => $error,
'hideBreadcrumbs' => true,
'_target_path'=>$request->headers->get('referer')
]);
}else{
return $this->render('account/login.html.twig', [
'form' => $form->createView(),
'error' => $error,
'hideBreadcrumbs' => true,
'_target_path'=>$request->headers->get('referer')
]);
}
}
/**
* If registration is called with a registration key, the key will be used to look for an existing OAuth token in
* the session. This OAuth token will be used to fetch user info which can be used to pre-populate the form and to
* link a SSO identity to the created customer object.
*
* This could be further separated into services, but was kept as single method for demonstration purposes as the
* registration process is different on every project.
*
* @Route("/account/register", name="account-register")
*
* @param Request $request
* @param CustomerProviderInterface $customerProvider
* @param OAuthRegistrationHandler $oAuthHandler
* @param LoginManagerInterface $loginManager
* @param RegistrationFormHandler $registrationFormHandler
* @param SessionInterface $session
* @param AuthenticationLoginListener $authenticationLoginListener
* @param Translator $translator
* @param Service $consentService
* @param UrlGeneratorInterface $urlGenerator
* @param NewsletterDoubleOptInService $newsletterDoubleOptInService
* @param UserInterface|null $user
*
* @return Response|RedirectResponse
*/
public function registerAction(
Request $request,
CustomerProviderInterface $customerProvider,
OAuthRegistrationHandler $oAuthHandler,
LoginManagerInterface $loginManager,
RegistrationFormHandler $registrationFormHandler,
SessionInterface $session,
AuthenticationLoginListener $authenticationLoginListener,
Translator $translator,
Service $consentService,
UrlGeneratorInterface $urlGenerator,
NewsletterDoubleOptInService $newsletterDoubleOptInService,
UserInterface $user = null
) {
//redirect user to index page if logged in
if ($user && $this->isGranted('ROLE_USER')) {
return $this->redirectToRoute('account-index');
}
$registrationKey = $request->get('registrationKey');
// create a new, empty customer instance
/** @var CustomerInterface|\Pimcore\Model\DataObject\Customer $customer */
$customer = $customerProvider->create();
/** @var OAuthToken $oAuthToken */
$oAuthToken = null;
/** @var UserResponseInterface $oAuthUserInfo */
$oAuthUserInfo = null;
// load previously stored token from the session and try to load user profile
// from provider
if (null !== $registrationKey) {
$oAuthToken = $oAuthHandler->loadToken($registrationKey);
$oAuthUserInfo = $oAuthHandler->loadUserInformation($oAuthToken);
}
if (null !== $oAuthUserInfo) {
// try to load a customer with the given identity from our storage. if this succeeds, we can't register
// the customer and should either log in the existing identity or show an error. for simplicity, we just
// throw an exception here.
// this shouldn't happen as the login would log in the user if found
if ($oAuthHandler->getCustomerFromUserResponse($oAuthUserInfo)) {
throw new \RuntimeException('Customer is already registered');
}
}
// the registration form handler is just a utility class to map pimcore object data to form
// and vice versa.
$formData = $registrationFormHandler->buildFormData($customer);
$hidePassword = false;
if (null !== $oAuthToken) {
$formData = $this->mergeOAuthFormData($formData, $oAuthUserInfo);
$hidePassword = true;
}
// build the registration form and pre-fill it with customer data
$form = $this->createForm(RegistrationFormType::class, $formData, ['hidePassword' => $hidePassword]);
$form->handleRequest($request);
$errors = [];
if ($form->isSubmitted() && $form->isValid()) {
$registrationFormHandler->updateCustomerFromForm($customer, $form);
$customer->setCustomerLanguage($request->getLocale());
$customer->setActive(true);
try {
$customer->save();
if ($form->getData()['newsletter']) {
$consentService->giveConsent($customer, 'newsletter', $translator->trans('general.newsletter'));
$newsletterDoubleOptInService->sendDoubleOptInMail($customer, $this->document->getProperty('newsletter_confirm_mail'));
}
if ($form->getData()['profiling']) {
$consentService->giveConsent($customer, 'profiling', $translator->trans('general.profiling'));
}
// add SSO identity from OAuth data
if (null !== $oAuthUserInfo) {
$oAuthHandler->connectSsoIdentity($customer, $oAuthUserInfo);
}
//check if special redirect is necessary
if ($session->get('referrer')) {
$response = $this->redirect($session->get('referrer'));
$session->remove('referrer');
} else {
$response = $this->redirectToRoute('account-index');
}
// log user in manually
// pass response to login manager as it adds potential remember me cookies
$loginManager->login($customer, $request, $response);
//do ecommerce framework login
$authenticationLoginListener->doEcommerceFrameworkLogin($customer);
return $response;
} catch (DuplicateCustomerException $e) {
$errors[] = $translator->trans(
'account.customer-already-exists',
[
$customer->getEmail(),
$urlGenerator->generate('account-password-send-recovery', ['email' => $customer->getEmail()])
]
);
} catch (\Exception $e) {
$errors[] = $e->getMessage();
}
}
if ($form->isSubmitted() && !$form->isValid()) {
foreach ($form->getErrors() as $error) {
$errors[] = $error->getMessage();
}
}
// re-save user info to session as we need it in subsequent requests (e.g. after form errors) or
// when form is rendered for the first time
if (null !== $registrationKey && null !== $oAuthToken) {
$oAuthHandler->saveToken($registrationKey, $oAuthToken);
}
return $this->render('account/register.html.twig', [
'customer' => $customer,
'form' => $form->createView(),
'errors' => $errors,
'hideBreadcrumbs' => true,
'hidePassword' => $hidePassword
]);
}
/**
* Special route for connecting to social profiles that saves referrer in session for later
* redirect to that referrer
*
* @param Request $request
* @param SessionInterface $session
* @param $service
*
* @return Response
* @Route("/auth/oauth/referrerLogin/{service}", name="app_auth_oauth_login_referrer")
*/
public function connectAction(Request $request, SessionInterface $session, $service)
{
// we overwrite this route to store user's referrer in the session
$session->set('referrer', $request->headers->get('referer'));
return $this->forward('HWIOAuthBundle:Connect:redirectToService', ['service' => $service]);
}
/**
* Connects an already logged in user to an auth provider
*
* @Route("/oauth/connect/{service}", name="app_auth_oauth_connect")
* @Security("is_granted('ROLE_USER')")
*
* @param Request $request
* @param OAuthRegistrationHandler $oAuthHandler
* @param UserInterface $user
* @param string $service
*
* @return RedirectResponse
*/
public function oAuthConnectAction(
Request $request,
OAuthRegistrationHandler $oAuthHandler,
UserInterface $user,
string $service
) {
$resourceOwner = $oAuthHandler->getResourceOwner($service);
$redirectUrl = $this->generateUrl('app_auth_oauth_connect', [
'service' => $service
], UrlGeneratorInterface::ABSOLUTE_URL);
// redirect to authorization
if (!$resourceOwner->handles($request)) {
$authorizationUrl = $oAuthHandler->getAuthorizationUrl($request, $service, $redirectUrl);
return $this->redirect($authorizationUrl);
}
// get access token from URL
$accessToken = $resourceOwner->getAccessToken($request, $redirectUrl);
// e.g. user cancelled auth on provider side
if (null === $accessToken) {
return $this->redirectToRoute('account-index');
}
$oAuthUserInfo = $resourceOwner->getUserInformation($accessToken);
// we don't want to allow linking an OAuth account to multiple customers
if ($oAuthHandler->getCustomerFromUserResponse($oAuthUserInfo)) {
throw new \RuntimeException('There\'s already a customer registered with this provider identity');
}
// create a SSO identity object and save it to the user
$oAuthHandler->connectSsoIdentity($user, $oAuthUserInfo);
// redirect to secure page which should now list the newly linked profile
return $this->redirectToRoute('account-index');
}
/**
*
* @param array $formData
* @param UserResponseInterface $userInformation
*
* @return array
*/
private function mergeOAuthFormData(
array $formData,
UserResponseInterface $userInformation
): array {
return array_replace([
'firstname' => $userInformation->getFirstName(),
'lastname' => $userInformation->getLastName(),
'email' => $userInformation->getEmail()
], $formData);
}
/**
* Index page for account - it is restricted to ROLE_USER via security annotation
*
* @Route("/account/index", name="account-index")
* @Security("is_granted('ROLE_USER')")
*
* @param SsoIdentityServiceInterface $identityService
* @param UserInterface|null $user
*
* @return Response
*/
public function indexAction(SsoIdentityServiceInterface $identityService, UserInterface $user = null,PaginatorInterface $paginator, SessionInterface $session)
{
if($this->checkPermission() != true)
{
throw new \Exception("Permission denied");
}
if($user->getPartner()->getIsMecstoreHQ()){
return $this->redirectToRoute("account-order-list",["type"=>"ordini"]);
}
$blacklist = [];
foreach ($identityService->getSsoIdentities($user) as $identity) {
$blacklist[] = $identity->getProvider();
}
$branches = $this->getBranches($session,$user);
if(empty($branches))
{
throw new \Exception("Permission denied");
}
$order = new Order();
$draftOrder = $order->getOrderByStatus('Draft',$branches,$paginator);
$bookedOrder = $order->getOrderByStatus('Booked',$branches,$paginator);
$sentOrder = $order->getOrderByStatus('Sent',$branches,$paginator);
$orderManager = Factory::getInstance()->getOrderManager();
$orderList = $orderManager->createOrderList();
$orderList->addFilter(new CustomerObject($user));
$orderList->setOrder('orderDate DESC');
return $this->render('account/index.html.twig', [
'blacklist' => $blacklist,
'orderList' => $orderList,
'hideBreadcrumbs' => true,
'draftOrder'=> $draftOrder,
'bookedOrder'=> $bookedOrder,
'sentOrder'=> $sentOrder
]);
}
/**
* @Route("/account/update-marketing", name="account-update-marketing-permission")
* @Security("is_granted('ROLE_USER')")
*
* @param Request $request
* @param Service $consentService
* @param Translator $translator
* @param NewsletterDoubleOptInService $newsletterDoubleOptInService
* @param UserInterface|null $user
*
* @return RedirectResponse
*
* @throws \Exception
*/
public function updateMarketingPermissionAction(Request $request, Service $consentService, Translator $translator, NewsletterDoubleOptInService $newsletterDoubleOptInService, UserInterface $user = null)
{
if ($user instanceof Customer) {
$currentNewsletterPermission = $user->getNewsletter()->getConsent();
if (!$currentNewsletterPermission && $request->get('newsletter')) {
$consentService->giveConsent($user, 'newsletter', $translator->trans('general.newsletter'));
$newsletterDoubleOptInService->sendDoubleOptInMail($user, $this->document->getProperty('newsletter_confirm_mail'));
} elseif ($currentNewsletterPermission && !$request->get('newsletter')) {
$user->setNewsletterConfirmed(false);
$consentService->revokeConsent($user, 'newsletter');
}
$currentProfilingPermission = $user->getProfiling()->getConsent();
if (!$currentProfilingPermission && $request->get('profiling')) {
$consentService->giveConsent($user, 'profiling', $translator->trans('general.profiling'));
} elseif ($currentProfilingPermission && !$request->get('profiling')) {
$consentService->revokeConsent($user, 'profiling');
}
$user->save();
$this->addFlash('success', $translator->trans('account.marketing-permissions-updated'));
}
return $this->redirectToRoute('account-index');
}
/**
* @Route("/account/confirm-newsletter", name="account-confirm-newsletter")
*
* @param Request $request
* @param NewsletterDoubleOptInService $newsletterDoubleOptInService
* @param Translator $translator
*
* @return RedirectResponse
*/
public function confirmNewsletterAction(Request $request, NewsletterDoubleOptInService $newsletterDoubleOptInService, Translator $translator)
{
$token = $request->get('token');
$customer = $newsletterDoubleOptInService->handleDoubleOptInConfirmation($token);
if ($customer) {
$this->addFlash('success', $translator->trans('account.marketing-permissions-confirmed-newsletter'));
return $this->redirectToRoute('account-index');
} else {
throw new NotFoundHttpException('Invalid token');
}
}
/**
* @Route("/account/send-password-recovery", name="account-password-send-recovery")
*
* @param Request $request
* @param PasswordRecoveryService $service
* @param Translator $translator
*
* @return Response
*
* @throws \Exception
*/
public function sendPasswordRecoveryMailAction(Request $request, PasswordRecoveryService $service, Translator $translator)
{
if ($request->isMethod(Request::METHOD_POST)) {
try {
$emailDocument = \Pimcore\Model\Document::getByPath('/b2c/email/password-recovery');
$customer = $service->sendRecoveryMail($request->get('email', ''), $emailDocument);
if (!$customer instanceof CustomerInterface) {
throw new \Exception('Cliente non valido');
}
$this->addFlash('success', "Il link per la reimpostazione della password viene inviato all'indirizzo e-mail registrato");
} catch (\Exception $e) {
$this->addFlash('danger', $e->getMessage());
}
return $this->redirectToRoute('account-password-send-recovery', ['no-referer-redirect' => true]);
}
return $this->render('account/send_password_recovery_mail.html.twig', [
'hideBreadcrumbs' => true,
'emailPrefill' => $request->get('email')
]);
}
/**
* @Route("/account/reset-password", name="account-reset-password")
*
* @param Request $request
* @param PasswordRecoveryService $service
* @param Translator $translator
*
* @return Response|RedirectResponse
*/
public function resetPasswordAction(Request $request, PasswordRecoveryService $service, Translator $translator)
{
$token = $request->get('token');
$customer = $service->getCustomerByToken($token);
if (!$customer) {
//TODO render error page
throw new NotFoundHttpException('Token non valido');
}
if ($request->isMethod(Request::METHOD_POST)) {
$newPassword = $request->get('password');
$service->setPassword($token, $newPassword);
$this->addFlash('success',"La password è stata aggiornata con successo ");
return $this->redirectToRoute('account-password-send-recovery', ['no-referer-redirect' => true]);
}
return $this->render('account/reset_password.html.twig', [
'hideBreadcrumbs' => true,
'token' => $token,
'email' => $customer->getEmail()
]);
}
/**
* Index page for account - it is restricted to ROLE_USER via security annotation
*
* @Route("/account/order/list/{type}", name="account-order-list")
* @Security("is_granted('ROLE_USER')")
*
* @param SsoIdentityServiceInterface $identityService
* @param UserInterface|null $user
*
* @return Response
*/
public function orderListAction(Request $request, SsoIdentityServiceInterface $identityService, SessionInterface $session = null ,UserInterface $user = null,PaginatorInterface $paginator, Factory $ecommerceFactory)
{
if ($this->checkPermission() != true) {
return $this->redirectToRoute('account-index');
}
$type = strtolower($request->get('type', 'all'));
$page = $request->get('page', 1);
$limit = ($request->get('limit', 12)) ? $request->get('limit', 12) : 12;
$type = $request->get('type', 'confirm');
$startDate = $request->get('startDate', null);
$endDate = $request->get('endDate', null);
$orderType = $request->get('order_type', null);
$term = $request->get('term', null);
$blacklist = [];
foreach ($identityService->getSsoIdentities($user) as $identity) {
$blacklist[] = $identity->getProvider();
}
$branches = $this->getBranches($session, $user);
if (empty($branches)) {
throw new \Exception("Permission denied");
}
$order = new Order();
if($type == 'draft')
{
$params['heading'] = "BOZZE";
$result = $order->getOrderByStatus('Draft',$branches,$paginator,$page,$limit,$orderType,$startDate,$endDate,$term);
}else if($type == 'booked'){
$params['heading'] = "PRENOTAZIONI";
$result = $order->getOrderByStatus('Booked',$branches,$paginator,$page,$limit,$orderType,$startDate,$endDate,$term);
}
else if($type == 'impegnati'){
$params['heading'] = "IMPEGNATI";
$searchBy = $request->get('filter_by',null);
$result = $order->getImpegnati($paginator,$page,$limit,$searchBy,$term);
$params['result'] = $result;
$params['type'] = $type;
$params['paginationVariables'] = $result->getPaginationData();
$params['totalCount'] = $result->getTotalItemCount();
$params['offset'] = $result->getCurrentPageNumber();
$params['limit'] = $result->getItemNumberPerPage();
$params['order_type'] = $orderType;
$params['start_date'] = $startDate;
$params['end_date'] = $endDate;
$params['term'] = $term;
$params['filterBy'] = $searchBy;
$this->deleteOrdersDeleted($result);
return $this->render('account/mecstore/order_engaged_list.html.twig', $params);
}
else if($type == 'riepilogo'){
$params['heading'] = "RIEPILOGO";
$result = $order->getRiepligo($paginator,$page,$limit,$term);
$params['result'] = $result;
$params['type'] = $type;
$params['paginationVariables'] = $result->getPaginationData();
$params['totalCount'] = $result->getTotalItemCount();
$params['offset'] = $result->getCurrentPageNumber();
$params['limit'] = $result->getItemNumberPerPage();
$params['order_type'] = $orderType;
$params['start_date'] = $startDate;
$params['end_date'] = $endDate;
$params['term'] = $term;
$this->deleteOrdersDeleted($result);
return $this->render('account/mecstore/order_summary_list_HQ.html.twig', $params);
}
else if($type == 'ordini'){
$params['heading'] = "ORDINI";
$result = $order->getOrderByStatus('confirm',$branches,$paginator,$page,$limit,$orderType,$startDate,$endDate,$term,'o_id','desc',true);
$params['result'] = $result;
$params['type'] = $type;
$params['paginationVariables'] = $result->getPaginationData();
$params['totalCount'] = $result->getTotalItemCount();
$params['offset'] = $result->getCurrentPageNumber();
$params['limit'] = $result->getItemNumberPerPage();
$params['order_type'] = $orderType;
$params['start_date'] = $startDate;
$params['end_date'] = $endDate;
$params['term'] = $term;
$this->deleteOrdersDeleted($result);
return $this->render('account/mecstore/ordini_list.html.twig', $params);
}
else if($type == 'bozze-ordini'){
$params['heading'] = "BOZZE ORDINI";
$result = $order->getOrderByStatus('Draft',$branches,$paginator,$page,$limit,$orderType,$startDate,$endDate,$term,'o_id','desc',true);
$params['result'] = $result;
$params['type'] = $type;
$params['paginationVariables'] = $result->getPaginationData();
$params['totalCount'] = $result->getTotalItemCount();
$params['offset'] = $result->getCurrentPageNumber();
$params['limit'] = $result->getItemNumberPerPage();
$params['order_type'] = $orderType;
$params['start_date'] = $startDate;
$params['end_date'] = $endDate;
$params['term'] = $term;
$this->deleteOrdersDeleted($result);
return $this->render('account/mecstore/bozze_list.html.twig', $params);
}
else if($type == 'pre-ordini'){
$availableStock = [];
$preOrderStock = [];
$itemsForRecalculation = [];
$partner = $user->getPartner();
$params['heading'] = "PREORDINE";
$preOrderItem = new DataObject\PreOrderItem\Listing();
//$preOrderItem->filterByProduct($product);
$preOrderItem->filterByPartner($partner);
$preOrderItems = $preOrderItem->load();
// Recalculating available qty
if($preOrderItems){
foreach($preOrderItems as $item){
$itemsForRecalculation[] = $item->getProduct()->getItem();
}
//$recalculatedCart = Utility::getOrders($itemsForRecalculation,$user->getPartner()->getCustSupp());
}
$cartManager = $ecommerceFactory->getCartManager();
$preOrderCart = $cartManager->getOrCreateCartByName('cart_pre_order_available');
$preOrderCart->clear();
if($preOrderItems){
foreach($preOrderItems as $item){
$availInStock = $item->getAvailableInStock(true);
if(is_array($availInStock) && !empty($availInStock)){
$product = $item->getProduct();
if($availInStock['adjusted_qty']>0){
// p_r($item->getProduct()->getItem());
// p_r($availInStock);
// exit;
$preOrderCart->addItem($product,$availInStock['adjusted_qty']);
$preOrderCart->save();
}
if($availInStock['carry_forwared'] > 0){
$preOrderStock[] = ['product'=>$item->getProduct(),'totalPrice'=>($availInStock['carry_forwared']*$product->getCONSORZ()),'qty'=>$availInStock['carry_forwared'],'notes'=>'','modified_date'=>$item->getModificationDate()];
}
}
}
}
$hqBranch = \Pimcore\Model\DataObject\Partners::getByIsMecstoreHQ(1,true);
// Branches
// Branches
$availableBranches = $this->getBranches($session,$user);
if(empty($availableBranches))
{
throw new \Exception("Permission denied");
}
$branches = new DataObject\Partners\Listing();
$branches->setCondition('oo_id IN ('.implode(",",$availableBranches).')');
$branches = $branches->load();
$customerAddresses = new DataObject\CustomerAddress\Listing();
$customerAddresses->setCondition('user__id = ?',[$user->getId()]);
$customerAddresses = $customerAddresses->load();
$params['products'] = $preOrderItems;
$params['order_type'] = $orderType;
$params['term'] = $term;
$params['type'] = $type;
$params['cart'] = $preOrderCart;
$params['pre_order_stock'] = $preOrderStock;
$params['branches'] = $branches;
$params['addresses'] = $customerAddresses;
$params['hqBranch'] = $hqBranch;
$params['orderType'] = $orderType;
$params['start_date'] = $startDate;
$params['end_date'] = $endDate;
return $this->render('account/pre-order-list.html.twig', $params);
}
else
{
$params['heading'] = "ORDINI";
$result = $order->getOrderByStatus('confirm',$branches,$paginator,$page,$limit,$orderType,$startDate,$endDate,$term);
}
//p_r($result);exit;
//p_r(get_class_methods($result[0]));exit;
//p_r($result[count($result)-1]);
$params['result'] = $result;
$params['type'] = $type;
$params['paginationVariables'] = $result->getPaginationData();
$params['totalCount'] = $result->getTotalItemCount();
$params['offset'] = $result->getCurrentPageNumber();
$params['limit'] = $result->getItemNumberPerPage();
$params['order_type'] = $orderType;
$params['term'] = $term;
$params['start_date'] = $startDate;
$params['end_date'] = $endDate;
if($type != 'booked' && $type != 'draft'){
$this->deleteOrdersDeleted($result);
}
return $this->render('account/order_list.html.twig', $params);
}
public function deleteOrdersDeleted($listaOrdini){
$salesOrdersIds = [];
foreach($listaOrdini as $ordine){
if(!is_array($ordine)) {
$salesOrdersIds[] = $ordine->getSalesOrderId();
}
}
$salesOrdersIds = implode(",", $salesOrdersIds);
//echo $salesOrdersIds;
$responseArr = [];
$curl = new CurlService();
try {
$request = '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/">
<soapenv:Header/>
<soapenv:Body>
<tem:getNumOrdNoMatch>
<tem:Token_Client>' . SOAP_TOKEN . '</tem:Token_Client>
<tem:ListSaleOrdId>' . $salesOrdersIds . '</tem:ListSaleOrdId>
</tem:getNumOrdNoMatch>
</soapenv:Body>
</soapenv:Envelope>';
\Pimcore\Log\Simple::log('erp_order_request', $request);
$xml = sprintf($request, SOAP_TOKEN);
$response = $curl->getCurlResponseNew($request, $xml);
$ordersToDelete = $response->xpath('//ListaOrdiniRichiesti/SaleOrdId');
} catch (Exception $e) {
//\Pimcore\Log\Simple::log('soap', $e->getMessage());
echo "ERRORE";
}
//echo $xml; //die();
//print_r($response);
//print_r($ordersToDelete);
foreach($ordersToDelete as $orderToDelete){
$otd = \Pimcore\Model\DataObject\OnlineShopOrder::getBySalesOrderId($orderToDelete, true);
if($otd){
//echo $otd->getOrdernumber();
$otd->delete();
}
}
}
public function deleteOrdersNoMatch($branches,$paginator,$page,$limit,$orderType,$startDate,$endDate,$term){
$order = new Order();
$result = $order->getOrderByStatus('confirm',$branches,$paginator,$page,$limit,$orderType,$startDate,$endDate,$term,'o_id','desc',true);
}
/**
* Index page for account - it is restricted to ROLE_USER via security annotation
*
* @Route("/account/order/detail/impegnati/{id}", name="account-impagniti-detail")
* @Security("is_granted('ROLE_USER')")
*
* @param SsoIdentityServiceInterface $identityService
* @param UserInterface|null $user
*
* @return Response
*/
public function orderImpagnitiRieplogoAction(Request $request, SsoIdentityServiceInterface $identityService, UserInterface $user = null, SessionInterface $session=null)
{
$userObject = \Pimcore::getContainer()->get('security.token_storage')->getToken()->getUser();
if(!$this->service->isAllowed($userObject, "order_create")) {
throw new \Exception("Permission denied");
}
$blacklist = [];
foreach ($identityService->getSsoIdentities($user) as $identity) {
$blacklist[] = $identity->getProvider();
}
$productId = $request->get('id',null);
if(!$productId){
throw new \Exception("Product not found");
}
$product = \Pimcore\Model\DataObject::getById($productId);
$order = new Order();
// Booking statistics
$db = \Pimcore\Db::get();
$response['booking'] = $order->getBookingStatistics($db,$productId);
// Pre Order statistics
$response['pre_order'] = $order->getPreOrderStatistics($db,$productId);
return $this->render('account/mecstore/order_engaged_detail.html.twig', [
'response' => $response,
'product'=>$product,
'hideBreadcrumbs' => true
]);
}
/**
* Index page for account - it is restricted to ROLE_USER via security annotation
*
* @Route("/account/order/detail/{type}/{id}", name="account-order-detail")
* @Security("is_granted('ROLE_USER')")
*
* @param SsoIdentityServiceInterface $identityService
* @param UserInterface|null $user
*
* @return Response
*/
public function orderDetailAction(Request $request, SsoIdentityServiceInterface $identityService, UserInterface $user = null, SessionInterface $session=null)
{
$userObject = \Pimcore::getContainer()->get('security.token_storage')->getToken()->getUser();
if(!$this->service->isAllowed($userObject, "order_create")) {
throw new \Exception("Permission denied");
}
$blacklist = [];
foreach ($identityService->getSsoIdentities($user) as $identity) {
$blacklist[] = $identity->getProvider();
}
$branches = [];
if(!$userObject->getPartner()->getIsMecstoreHQ() && !$userObject->getUserRoles() != "Customer"){
$branches = $this->getBranches($session,$user);
if(empty($branches))
{
throw new \Exception("Permission denied");
}
}
$orderId = $request->get('id');
$type = strtolower($request->get('type','all'));
$order = new Order();
$order = $order->getOrderById($orderId,$branches);
if(empty($order)){
throw new \Exception("Permission denied");
}
$deliveredQty = $this->getProductsDeliveredQty($order[0]->getSalesOrderId());
//print_r($deliveredQty);
// p_r(get_class_methods($order[0]));exit;
$order = is_array($order)?$order[0]:[];
if($order)
{
$orderDetail = $order->getOrderDetail();
if($orderDetail)
{
$orderDetail = $orderDetail->getItems();
$orderDetail = isset($orderDetail)?$orderDetail[0]:[];
}
}
// Get DDT
if($type == "ordini"){
return $this->render('account/mecstore/ordini_detail.html.twig', [
'blacklist' => $blacklist,
'hideBreadcrumbs' => true,
'order'=> $order,
'type'=>$type,
'orderBrick'=>$orderDetail,
'deliveredQty'=>$deliveredQty,
]);
}
else if($type == "invoice"){
return $this->render('account/order_invoice.html.twig', [
'blacklist' => $blacklist,
'hideBreadcrumbs' => true,
'order'=> $order,
'type'=>$type,
'orderBrick'=>$orderDetail
]);
}
else if($type == "future_invoice"){
return $this->render('account/order_future_invoice.html.twig', [
'blacklist' => $blacklist,
'hideBreadcrumbs' => true,
'order'=> $order,
'type'=>$type,
'orderBrick'=>$orderDetail
]);
}
else{
return $this->render('account/order_detail.html.twig', [
'blacklist' => $blacklist,
'hideBreadcrumbs' => true,
'order'=> $order,
'type'=>$type,
'orderBrick'=>$orderDetail,
'deliveredQty'=>$deliveredQty,
]);
}
}
private function getProductsDeliveredQty($salesOrderId){
$return = [];
if($salesOrderId) {
$curl = new CurlService();
$request = '<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/">
<soapenv:Header/>
<soapenv:Body>
<tem:getMembersSaleOrdersDetails_Parameters>

<tem:Token_Client>%s</tem:Token_Client>

<tem:ToDate></tem:ToDate>

<tem:Customer/>
<tem:FromSaleOrdId>%s</tem:FromSaleOrdId>

<tem:LimitRecords>1</tem:LimitRecords>

<tem:FromDate></tem:FromDate>
</tem:getMembersSaleOrdersDetails_Parameters>
</soapenv:Body>
</soapenv:Envelope>';
$xml = sprintf($request, SOAP_TOKEN, $salesOrderId);
$response = $curl->getCurlResponseNew($request, $xml);
//print_r($response);
$membersOrdersDetails = $response->xpath('//MembersOrdersDetailsParameters');
if (count($membersOrdersDetails)) {
foreach ($membersOrdersDetails as $membersOrderDetails) {
if($membersOrderDetails->Item != '') {
$return[(string)$membersOrderDetails->Item] = (float)$membersOrderDetails->DeliveredQty;
}
}
}
}
return $return;
}
/**
* Index page for account - it is restricted to ROLE_USER via security annotation
*
* @Route("/account/order-booked/{id}", name="account-order-detail-booking")
* @Security("is_granted('ROLE_USER')")
*
* @param SsoIdentityServiceInterface $identityService
* @param UserInterface|null $user
*
* @return Response
*/
public function orderBookingAction(Request $request, SsoIdentityServiceInterface $identityService, UserInterface $user = null, SessionInterface $session=null)
{
$userObject = \Pimcore::getContainer()->get('security.token_storage')->getToken()->getUser();
if(!$this->service->isAllowed($userObject, "booking_create")) {
throw new \Exception("Permission denied");
}
$blacklist = [];
foreach ($identityService->getSsoIdentities($user) as $identity) {
$blacklist[] = $identity->getProvider();
}
$availbaleBranches = $this->getBranches($session,$user);
if(empty($availbaleBranches))
{
throw new \Exception("Permission denied");
}
$orderType=$request->get('order_type',null);
$term=$request->get('term',null);
$customerAddresses = new DataObject\CustomerAddress\Listing();
$customerAddresses->setCondition('user__id = ?',[$userObject->getId()]);
$customerAddresses = $customerAddresses->load();
$orderId = $request->get('id');
$order = new Order();
$order = \Pimcore\Model\DataObject::getById($orderId);
if(!$order instanceof \Pimcore\Model\DataObject\PurchaseOrder)
{
$this->addFlash('error', "Order does not exists");
return $this->redirectToRoute('account-index');
}
$orderBranch = $order->getBranch();
if($orderBranch){
$branchID = $orderBranch->getID();
if(!in_array($branchID,$availbaleBranches))
{
throw new \Exception("Permission denied");
}
}
// Branches
$branches = new DataObject\Partners\Listing();
$branches->setCondition('oo_id IN ('.implode(",",$availbaleBranches).')');
$branches = $branches->load();
$hqBranch = \Pimcore\Model\DataObject\Partners::getByIsMecstoreHQ(1,true);
if($order)
{
$orderDetail = $order->getOrderDetail();
$items = $order->getChildren();
}
return $this->render('account/order_booking.html.twig', [
'blacklist' => $blacklist,
'hideBreadcrumbs' => true,
'order'=> $order,
'items'=> $items,
'type'=>'booked',
'orderBrick'=>$orderDetail,
'branches'=>$branches,
'hqBranch'=>$hqBranch,
'addresses'=>$customerAddresses,
'order_type'=>$orderType,
'term'=>$term
]);
}
/**
* Index page for account - it is restricted to ROLE_USER via security annotation
*
* @Route("/account/order-draft/{id}", name="account-order-detail-draft")
* @Security("is_granted('ROLE_USER')")
*
* @param SsoIdentityServiceInterface $identityService
* @param UserInterface|null $user
*
* @return Response
*/
public function orderDraftAction(Request $request, SsoIdentityServiceInterface $identityService, UserInterface $user = null, SessionInterface $session=null)
{
$userObject = \Pimcore::getContainer()->get('security.token_storage')->getToken()->getUser();
if(!$this->service->isAllowed($userObject, "draft_create")) {
throw new \Exception("Permission denied");
}
$blacklist = [];
foreach ($identityService->getSsoIdentities($user) as $identity) {
$blacklist[] = $identity->getProvider();
}
$orderId = $request->get('id');
$term=$request->get('term',null);
$order = new Order();
$order = \Pimcore\Model\DataObject::getById($orderId);
if(!$order instanceof \Pimcore\Model\DataObject\PurchaseOrder)
{
$this->addFlash('error', "Order does not exists");
return $this->redirectToRoute('account-index');
}
$availableBranches = $this->getBranches($session,$user);
if(empty($availableBranches))
{
throw new \Exception("Permission denied");
}
$orderBranch = $order->getBranch();
if($orderBranch){
$branchID = $orderBranch->getID();
if(!in_array($branchID,$availableBranches))
{
throw new \Exception("Permission denied");
}
}
// Branches
$branches = new DataObject\Partners\Listing();
$branches->setCondition('oo_id IN ('.implode(",",$availableBranches).')');
$branches = $branches->load();
// Customer Addresses
$customerAddresses = new DataObject\CustomerAddress\Listing();
$customerAddresses->setCondition('user__id = ?',[$userObject->getId()]);
$customerAddresses = $customerAddresses->load();
$hqBranch = \Pimcore\Model\DataObject\Partners::getByIsMecstoreHQ(1,true);
if($order)
{
$orderDetail = $order->getOrderDetail();
$items = $order->getChildren();
}
if($userObject->getPartner()->getIsMecstoreHQ() && $userObject->getUserRoles() != "Customer"){
return $this->render('account/mecstore/order_draft.html.twig', [
'blacklist' => $blacklist,
'hideBreadcrumbs' => true,
'order'=> $order,
'items'=> $items,
'type'=>'booking',
'orderBrick'=>$orderDetail,
'branches'=>$branches,
'hqBranch'=>$hqBranch,
'addresses'=>$customerAddresses,
'term'=>$term
]);
}else{
return $this->render('account/order_draft.html.twig', [
'blacklist' => $blacklist,
'hideBreadcrumbs' => true,
'order'=> $order,
'items'=> $items,
'type'=>'booking',
'orderBrick'=>$orderDetail,
'branches'=>$branches,
'hqBranch'=>$hqBranch,
'addresses'=>$customerAddresses,
'term'=>$term
]);
}
}
/**
* Index page for account - it is restricted to ROLE_USER via security annotation
*
* @Route("/account/pre-order-checkout", name="shop-checkout-confirm-order-pre-order")
* @Security("is_granted('ROLE_USER')")
*
* @param Factory $ecommerceFactory
* @param UserInterface|null $user
*
* @return Response
*/
public function preOrderCheckoutAction(Request $request, Factory $ecommerceFactory, UserInterface $user = null, SessionInterface $session=null)
{
$userObject = \Pimcore::getContainer()->get('security.token_storage')->getToken()->getUser();
$deliveryBranch = $userObject->getPartner();
//$formData = $request->query->all();
$note = $request->get('order_reference_pre_order');
$additionalNote = $request->get('additional_note_pre_order');
$params = $request->get('accordion-notes');//('accordion-notes');
if($params){
$session->set('accordion-notes',$request->get('accordion-notes'));
$session->set('order_reference_pre_order',$request->get('order_reference_pre_order'));
$session->set('additional_note_pre_order',$request->get('additional_note_pre_order'));
}else{
$params = $session->get('accordion-notes');
$note = $session->get('order_reference_pre_order');
$additionalNote = $session->get('additional_note_pre_order');
}
$cartManager = $ecommerceFactory->getCartManager();
$cart = $cartManager->getOrCreateCartByName('cart_pre_order_available');
$preOrderCart = $cartManager->getOrCreateCartByName('cart_pre_order');
$reviewCart = $cartManager->getOrCreateCartByName('cart_review');
$preOrderCart->clear();
$reviewCart->clear();
if($params){
foreach($params as $key=>$value){
$additionalNotes[$key] = $value[0];
}
}
$items = $cart->getItems();
if(!$items){
throw new \Exception("Prodotti non disponibili nel carrello");
}
//p_r($params);exit;
foreach($items as $item){
$prod = $item->getProduct();
$itemsForRecalculation[] = $prod->getItem();
}
// p_r($cart);exit;
$partner = $user->getPartner();
if(!empty($itemsForRecalculation) && $partner){
$recalculatedCart = Utility::getOrders($itemsForRecalculation,$partner->getCustSupp());
}
// p_r($recalculatedCart);exit;
if(!$recalculatedCart){
throw new \Exception("Impossibile ricalcolare il carrello");
}
$oldMetadata = [];
$preOrder = [];
foreach($items as $item){
$prod = $item->getProduct();
$preorderitems = new DataObject\PreOrderItem\Listing();
$preorderitems->filterByUser($user);
$preorderitems->filterByProduct($prod);
$preorderitems->filterByIsAvailable(true);
$preorderitems->setLimit(1);
$updatedPrice = 0;
$updateStock = 0;
// Price fetched from old product
// p_r($item);
$requiredQty = $item->getCount();
$currentPrice = $prod->getCONSORZ();
$recalculatedItem = $recalculatedCart[$prod->getItem()];
if(!empty($recalculatedItem) && $preorderitems->getCount()>0){
$updatedPrice = $recalculatedItem['Price'];
$updateStock = $recalculatedItem['Disponibilita'] + $preorderitems->load()[0]->getQty() ;
// Checking if required qty in cart is more than recent qty fetched by API
//p_r($requiredQty.'----'.$updateStock); exit;
if($requiredQty >= $updateStock){
$reviewCart->addItem($prod,$requiredQty);
// Update cart
/*$preOrderStock = $requiredQty-$updateStock;
$prod->setDisponibilita($updateStock);
$prod->setCONSORZ($updatedPrice);
$prod->save();
if($preOrderStock > 0){
$preOrderCart->addItem($prod,$preOrderStock);
$preOrder[$prod->getId()]['new_price'] = (float) $updatedPrice;
$preOrder[$prod->getId()]['old_price'] = (float) $currentPrice;
$preOrder[$prod->getId()]['new_stock'] = (float) $preOrderStock;
$preOrder[$prod->getId()]['old_stock'] = (float) $requiredQty;
$preOrder[$prod->getId()]['inStock'] = false;
}
$calReqQty = $requiredQty-$preOrderStock;
$prod->setDisponibilita($updateStock);
$prod->setCONSORZ($updatedPrice);
$prod->save();
if($calReqQty > 0){
$reviewCart->addItem($prod,$calReqQty);
$oldMetadata[$prod->getId()]['new_price'] = (float) $updatedPrice;
$oldMetadata[$prod->getId()]['old_price'] = (float) $currentPrice;
$oldMetadata[$prod->getId()]['new_stock'] = (float) $calReqQty;
$oldMetadata[$prod->getId()]['old_stock'] = (float) $calReqQty;
$oldMetadata[$prod->getId()]['inStock'] = ($updateStock)?true:false;
}else{
$preOrderCart->addItem($prod,$requiredQty);
}*/
}else{
$preOrderCart->addItem($prod,$requiredQty);
/*$prod->setDisponibilita($updateStock);
$prod->setCONSORZ($updatedPrice);
$prod->save();
if($requiredQty>0){
$reviewCart->addItem($prod,$requiredQty);
}else{
$preOrderCart->addItem($prod,$requiredQty);
}
$oldMetadata[$prod->getId()]['new_price'] = (float) $updatedPrice;
$oldMetadata[$prod->getId()]['old_price'] = (float) $currentPrice;
$oldMetadata[$prod->getId()]['new_stock'] = (float) $requiredQty;
$oldMetadata[$prod->getId()]['old_stock'] = (float) $requiredQty;
$oldMetadata[$prod->getId()]['inStock'] = ($updateStock)?true:false;*/
}
}else{
$preOrder[$prod->getId()]['new_price'] = 0;
$preOrder[$prod->getId()]['old_price'] = 0;
$preOrder[$prod->getId()]['new_stock'] = 0;
$preOrder[$prod->getId()]['old_stock'] = 0;
$preOrder[$prod->getId()]['inStock'] = false;
$preOrder[$prod->getId()]['message'] = "Esaurito";
// Updating available qty of product to 0 if product is not present in API
$prod->setDisponibilita(0);
$prod->save();
$preOrderCart->addItem($prod,$requiredQty);
}
$reviewCart->save();
$preOrderCart->save();
}
$reviewCart->setCheckoutData('oldMetadata',$oldMetadata);
$reviewCart->save();
$preOrderCart->setCheckoutData('oldMetadata',$preOrder);
$preOrderCart->save();
$availableBranches = $this->getBranches($session,$user);
if(empty($availableBranches))
{
throw new \Exception("Permission denied");
}
$hqBranch = \Pimcore\Model\DataObject\Partners::getByIsMecstoreHQ(1,true);
$branches = new DataObject\Partners\Listing();
$branches->setCondition('oo_id IN ('.implode(",",$availableBranches).')');
$branches = $branches->load();
$customerAddresses = new DataObject\CustomerAddress\Listing();
$customerAddresses->setCondition('user__id = ?',[$user->getId()]);
$customerAddresses = $customerAddresses->load();
//p_r($branches);exit;
return $this->render('account/order_summary.html.twig', [
'cart' => $reviewCart,
'pre_order_cart' => $preOrderCart,
'hideBreadcrumbs' => true,
'deliveryBranch'=>$deliveryBranch,
'params'=>$params,
'additionalNotes'=>$additionalNotes,
'checkoutData'=>$oldMetadata,
'checkoutDataPreOrder'=>$preOrder,
'additionalNote' => $additionalNote,
'note' => $note,
'branches'=>$branches,
'hqBranch'=>$hqBranch,
'addresses'=>$customerAddresses
]);
}
/**
* Index page for account - it is restricted to ROLE_USER via security annotation
*
* @Route("/account/download-order/{id}", name="account-order-download-order")
* @Security("is_granted('ROLE_USER')")
*
* @param SsoIdentityServiceInterface $identityService
* @param UserInterface|null $user
*
* @return Response
*/
public function downloadOrder(Request $request, SsoIdentityServiceInterface $identityService, UserInterface $user = null)
{
$writer = WriterEntityFactory::createXLSXWriter();
$writer->openToFile($filePath); // write data to a file or to a PHP stream
//$writer->openToBrowser($fileName); // stream data directly to the browser
$cells = [
WriterEntityFactory::createCell('Carl'),
WriterEntityFactory::createCell('is'),
WriterEntityFactory::createCell('great!'),
];
/** add a row at a time */
$singleRow = WriterEntityFactory::createRow($cells);
$writer->addRow($singleRow);
/** add multiple rows at a time */
$multipleRows = [
WriterEntityFactory::createRow($cells),
WriterEntityFactory::createRow($cells),
];
$writer->addRows($multipleRows);
/** Shortcut: add a row from an array of values */
$values = ['Carl', 'is', 'great!'];
$rowFromValues = WriterEntityFactory::createRowFromArray($values);
$writer->addRow($rowFromValues);
$writer->close();
}
private function checkPermission(){
$allow = false;
$userObject = \Pimcore::getContainer()->get('security.token_storage')->getToken()->getUser();
if($this->service->isAllowed($userObject, "draft_create") || $this->service->isAllowed($userObject, "booking_create") || $this->service->isAllowed($userObject, "order_create") || $this->service->isAllowed($userObject, "order_view")) {
$allow = true;
}
//Whitelist admin route for mecstore
if(in_array($_SERVER['REQUEST_URI'],MECSTORE_WHITELIST_URLS)){
if($userObject->getPartner()->getIsMecstoreHQ() && $userObject->getUserRoles() != "Customer"){
$allow = true;
}else{
$allow = false;
}
}
return $allow;
}
}

src/Controller/AccountController.php line 93