src/Controller/UserController.php line 340

Open in your IDE?
  1. <?php
  3. namespace Slivki\Controller;
  5. use DateTime;
  6. use Doctrine\ORM\Query\ResultSetMapping;
  7. use Imagine\Gd\Imagine;
  8. use Imagine\Image\Box;
  9. use Imagine\Image\Point;
  10. use Slivki\Dao\Bonus\BonusBalanceActivityDaoInterface;
  11. use Slivki\Dto\User\OrderHistory\Factory\TireOrderHistoryDtoFactory;
  12. use Slivki\Entity\City;
  13. use Slivki\Entity\MailingCampaign;
  14. use Slivki\Entity\Subscriber;
  15. use Slivki\Entity\UserEmailHistory;
  16. use Slivki\Enum\Bonus\Bonus;
  17. use Slivki\Enum\Order\PaymentType;
  18. use Slivki\Factory\User\OrderHistory\FoodOrderHistoryDtoFactory;
  19. use Slivki\Handler\User\CreditCard\RemoveCreditCardHandler;
  20. use Slivki\Message\Command\Bonus\AddBonusCommand;
  21. use Slivki\Repository\Offer\DeliveryZoneRepositoryInterface;
  22. use Slivki\Repository\User\UserAddressRepositoryInterface;
  23. use Slivki\Response\Admin\Offer\CoordinatesResponse;
  24. use Slivki\Response\Admin\User\BonusBalanceActivity\GetUserBonusBalanceActivityResponse;
  25. use Slivki\Services\GiftCertificateService;
  26. use Slivki\Services\MapProviders\CoordinatesYandex;
  27. use Slivki\Services\Sms\Security\SmsLimiterService;
  28. use Slivki\Services\User\AccountMerger;
  29. use Slivki\Services\User\AuthorizationCodeSender;
  30. use Slivki\Services\User\UserPhoneService;
  31. use Slivki\Services\UserGetter;
  32. use Doctrine\Persistence\ManagerRegistry;
  33. use Slivki\Util\Iiko\Tokiny;
  34. use Symfony\Component\HttpFoundation\Cookie;
  35. use Symfony\Component\Messenger\MessageBusInterface;
  36. use Symfony\Component\Routing\Annotation\Route;
  37. use Slivki\Entity\Comment;
  38. use Slivki\Entity\DeliveryLocation;
  39. use Slivki\Entity\FoodOrder;
  40. use Slivki\Entity\GiftCertificateOrder;
  41. use Slivki\Entity\MailingCampaignType;
  42. use Slivki\Entity\MailingCampaignUnsubscribe;
  43. use Slivki\Entity\Media;
  44. use Slivki\Entity\Media\OfferExtensionMedia;
  45. use Slivki\Entity\MediaType;
  46. use Slivki\Entity\Offer;
  47. use Slivki\Entity\OfferOrder;
  48. use Slivki\Entity\OfferOrderDetails;
  49. use Slivki\Entity\Referral;
  50. use Slivki\Entity\SocialAccount;
  51. use Slivki\Entity\Street;
  52. use Slivki\Entity\SubscriptionOrder;
  53. use Slivki\Entity\TireOrder;
  54. use Slivki\Entity\User;
  55. use Slivki\Entity\UserActivity;
  56. use Slivki\Entity\UserAddress;
  57. use Slivki\Entity\UserBalanceActivity;
  58. use Slivki\Entity\UserBalanceActivityType;
  59. use Slivki\Entity\UserConfirmation;
  60. use Slivki\Entity\UserGroup;
  61. use Slivki\Entity\UserPhone;
  62. use Slivki\Repository\CityRepository;
  63. use Slivki\Services\Encoder;
  64. use Slivki\Services\ImageService;
  65. use Slivki\Services\Mailer;
  66. use Slivki\Services\Subscription\SubscriptionService;
  67. use Slivki\Util\CommonUtil;
  68. use Slivki\Util\Iiko\IikoUtil;
  69. use Slivki\Util\Logger;
  70. use Slivki\Util\OAuth2Client\AbstractOAuth2Client;
  71. use Slivki\Util\OAuth2Client\UserData;
  72. use Slivki\Util\SoftCache;
  73. use Symfony\Component\Filesystem\Filesystem;
  74. use Symfony\Component\HttpFoundation\JsonResponse;
  75. use Symfony\Component\HttpFoundation\Request;
  76. use Symfony\Component\HttpFoundation\Response;
  77. use Symfony\Component\HttpKernel\KernelInterface;
  78. use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
  79. use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
  80. use Symfony\Component\Validator\Validator\ValidatorInterface;
  82. use function sprintf;
  84. class UserController extends SiteController
  85. {
  86.     private ManagerRegistry $managerRegistry;
  87.     private TireOrderHistoryDtoFactory $tireOrderHistoryDtoFactory;
  88.     private FoodOrderHistoryDtoFactory $foodOrderHistoryDtoFactory;
  89.     private BonusBalanceActivityDaoInterface $bonusBalanceActivityDao;
  91.     public function __construct(
  92.         KernelInterface $kernel,
  93.         ManagerRegistry $managerRegistry,
  94.         TireOrderHistoryDtoFactory $tireOrderHistoryDtoFactory,
  95.         FoodOrderHistoryDtoFactory $foodOrderHistoryDtoFactory,
  96.         BonusBalanceActivityDaoInterface $bonusBalanceActivityDao
  97.     ) {
  98.         parent::__construct($kernel);
  99.         $this->managerRegistry = $managerRegistry;
  100.         $this->tireOrderHistoryDtoFactory = $tireOrderHistoryDtoFactory;
  101.         $this->foodOrderHistoryDtoFactory = $foodOrderHistoryDtoFactory;
  102.         $this->bonusBalanceActivityDao = $bonusBalanceActivityDao;
  103.     }
  105.     /**
  106.      * @Route("/register", name="register")
  107.      */
  108.     public function registerAction(Request $request, Mailer $mailer, ValidatorInterface $validator) {
  109.         $isMobileDevice = CommonUtil::isMobileDevice($request);
  110.         if ($request->getMethod() != "POST") {
  111.             if ($isMobileDevice) {
  112.                 return $this->redirect("/login");
  113.             }
  114.             return $this->redirect("/");
  115.         }
  116.         $utmSource = $this->getUtmSourceCookie($request);
  117.         $user = new User();
  118.         $user->setAcceptNewsletter(true);
  119.         $user->setStatus(User::STATUS_REGISTERED);
  120.         $email = mb_strtolower(trim($request->request->get("email")));
  121.         $userRepository = $this->getDoctrine()->getRepository(User::class);
  122.         if ($userRepository->loadUserByUsername($email, false)) {
  123.             return new JsonResponse(['message' =>"Пользователь с таким e-mail-ом уже зарегистрирован"]);
  124.         }
  125.         $user->setEmail($email);
  126.         /** @var \Symfony\Component\Validator\ConstraintViolationList $errorList */
  127.         $errorList = $validator->validate($user);
  128.         if ($errorList->count() > 0) {
  129.             return new JsonResponse(['message' =>$errorList->get(0)->getMessage()]);
  130.         }
  131.         $password = trim($request->get("password"));
  132.         if (strlen($password) < 6) {
  133.             return new JsonResponse(['message' =>"Пароль не может быть меньше 6 символов"]);
  134.         }
  135.         if ($password != trim($request->get("confirmPassword"))) {
  136.             return new JsonResponse(['message' =>"Пароли не совпадают"]);
  137.         }
  138.         $user->encryptPassword($password);
  139.         $cityName = $request->get("city");
  140.         $cityRepository = $this->getDoctrine()->getRepository(City::class);
  141.         $city = $cityRepository->findOneBy(array("name" => $cityName));
  142.         if (!$city) {
  143.             $city = $cityRepository->findOneBy(array(), array("ID" => "asc"));
  144.         }
  145.         $user->setCity($city);
  146.         if ($utmSource) {
  147.             $user->setRegisteredFromUtmSource($utmSource['utmSource']);
  148.         }
  149.         $entityManager = $this->getDoctrine()->getManager();
  150.         $entityManager->persist($user);
  151.         $userRepository->addDirectorGroupToUserByUser($user);
  152.         $entityManager->flush($user);
  153.         $this->checkUserIsSupplier($user);
  154.         $userConfirmation = new UserConfirmation();
  155.         $userConfirmation->setUserID($user->getID());
  156.         $userConfirmation->setReturnUrl($request->request->get('registerReturnUrl'));
  157.         $entityManager->persist($userConfirmation);
  158.         $this->subscriberRemove($email);
  159.         $entityManager->flush();
  160.         $this->checkReferer($request, $user);
  162.         $this->sendConfirm($mailer, $user);
  163.         $data = [
  164.             'id' => 'modalAccountActivation',
  165.             'email' => $email,
  166.             'link' => Encoder::encodeString($user->getEmail(), $user->getSalt())
  167.         ];
  168.         $view = $isMobileDevice ? 'Slivki/mobile_account_activation.html.twig' : 'Slivki/popups/account_activation_popup.html.twig';
  169.         $popup = $this->get('twig')->render($view, $data);
  171.         return new JsonResponse(['popup' => $popup]);
  172.     }
  174.     /**
  175.      * @Route("/social-login/{socialNetwork}", name="socialLogin")
  176.      */
  177.     public function socialLoginAction(Request $request, $socialNetwork) {
  178.         $redirectUri = $request->query->get('state', CityRepository::$mainPageURL);
  179.         $className = 'Slivki\Util\OAuth2Client\Provider\\' . ucfirst($socialNetwork) . 'Client';
  180.         /** @var AbstractOAuth2Client $oAuthProvider */
  181.         $oAuthProvider = new $className();
  182.         $accessToken = $oAuthProvider->getAccessToken($request);
  183.         if (!$accessToken) {
  184.             return $this->redirect($redirectUri);
  185.         }
  186.         /** @var UserData $userData */
  187.         $userData = $oAuthProvider->getUserData($accessToken);
  188.         if (!$userData->getEmail()) {
  189.             return $this->redirect($redirectUri);
  190.         }
  192.         $entityManager = $this->getDoctrine()->getManager();
  194.         $socialAccount = $entityManager->getRepository(SocialAccount::class)->findOneBy([
  195.             'network' => $userData->getNetwork(),
  196.             'identity' => $userData->getID()
  197.         ]);
  199.         if ($socialAccount) {
  200.             $user = $socialAccount->getUser();
  201.         } else {
  202.             $user = $entityManager->getRepository(User::class)->findOneByEmail($userData->getEmail());
  203.         }
  205.         if (!$user) {
  206.             // Register new user
  207.             $utmSource = $this->getUtmSourceCookie($request);
  208.             $user = new User();
  209.             $user->setAcceptNewsletter(true);
  210.             $user->setStatus(User::STATUS_CONFIRMED);
  211.             $user->setEmail($userData->getEmail());
  212.             $user->setLastName($userData->getLastName());
  213.             $user->setFirstName($userData->getFirstName());
  214.             $password = substr(md5(microtime()), 0, 5);
  215.             $user->encryptPassword($password);
  216.             if ($utmSource != '') {
  217.                 $user->setRegisteredFromUtmSource($utmSource);
  218.             }
  219.             $entityManager->persist($user);
  220.             $mainMailingCampaignType = $entityManager->getRepository(MailingCampaignType::class)->find(MailingCampaignType::MAIN_ID);
  221.             $user->addMailingCampaignTypes($mainMailingCampaignType);
  222.             $userRepository = $this->getUserRepository();
  223.             $userRepository->addDirectorGroupToUserByUser($user);
  224.             $entityManager->flush($user);
  225.             $userRepository->addActivity($user, UserActivity::SUBSCRIBE_ACTION, $mainMailingCampaignType);
  226.             $this->checkReferer($request, $user);
  227.             $this->checkUserIsSupplier($user);
  228.             $this->subscriberRemove($user->getEmail() );
  229.         }
  231.         $linked = false;
  232.         foreach($user->getSocialAccounts()->toArray() as $value) {
  233.             if ($userData->getNetwork() == $value->getNetwork() && $userData->getID() == $value->getIdentity()) {
  234.                 $linked = true;
  235.                 break;
  236.             }
  237.         }
  239.         // Add social account
  240.         if (!$linked) {
  241.             $socialAccount = new SocialAccount();
  242.             $socialAccount->setNetwork($userData->getNetwork());
  243.             $socialAccount->setIdentity($userData->getID());
  244.             $socialAccount->setUser($user);
  245.             $user->addSocialAccount($socialAccount);
  246.         }
  247.         $entityManager->flush();
  248.         $entityManager->clear();
  249.         $user = $this->getUserRepository()->find($user->getID());
  250.         $token = new UsernamePasswordToken($user, null, 'main', $user->getRoles());
  251.         $this->get('security.token_storage')->setToken($token);
  252.         return $this->redirect($redirectUri);
  253.     }
  255.     private function checkUserIsSupplier(User $user) {
  256.         $entityManager = $this->getDoctrine()->getManager();
  257.         $director = $this->getUserRepository()->getDirector($user);
  258.         if ($director) {
  259.             $supplierUserGroup = $entityManager->getRepository(UserGroup::class)->find(UserGroup::ROLE_SUPPLIER_ID);
  260.             $user->addUserGroup($supplierUserGroup);
  261.             $entityManager->flush();
  262.         }
  263.     }
  265.     /**
  266.      * @Route("/sendconfirm", name="sendconfirm")
  267.      */
  268.     public function sendConfirmAction(Request $request, Mailer $mailer) {
  269.         $email = Encoder::decodeString($request->query->get('email'), User::SALT);
  270.         $user = $this->getDoctrine()->getRepository(User::class)->findOneByEmail(pg_escape_string($email));
  271.         if (!$user){
  272.             if (self::getMobileDevice($request)) {
  273.                 return $this->redirect("/login");
  274.             }
  275.             return $this->redirect("/");
  276.         }
  277.         if ($this->sendConfirm($mailer, $user)) {
  278.             $this->addFlash("registeredEmailSent", Encoder::encodeString($user->getEmail(), User::SALT));
  279.             $this->addFlash("registeredEmailSentRaw", $user->getEmail());
  280.         }
  281.         if (self::getMobileDevice($request)) {
  282.             return $this->redirect("/login");
  283.         }
  284.         return $this->redirect("/");
  285.     }
  287.     /**
  288.      * @Route("/lostpassword/{email}", name="lostpassword")
  289.      */
  290.     public function lostPasswordAction(Request $request, Mailer $mailer, $email = null){
  291.         if ($request->getMethod() != "POST") {
  292.             if (self::getMobileDevice($request)) {
  293.                 return $this->render('Slivki/mobile/profile/restore_password.html.twig', ['email' => $email]);
  294.             }
  295.             return $this->redirect("/");
  296.         }
  297.         $result = [
  298.             'type' => 'error',
  299.             'html' => 'Введенный e-mail не найден'
  300.         ];
  301.         if ($this->sendPassword($mailer, $request->request->get('email'))) {
  302.             $result = [
  303.                 'type' => 'success',
  304.                 'html' => '<p>Пароль отправлен на ваш электронный ящик</p>'
  305.                     .'<a href="/login" class="btn btn-success bg-slivki btn-block text-dark border-0">Войти</a>'
  306.             ];
  307.             $this->get('session')->set('restoredEmail', $request->request->get('email'));
  308.             if (!self::getMobileDevice($request)) {
  309.                 $result['html'] = '<p>Пароль отправлен на ваш электронный ящик</p>';
  310.             }
  311.         }
  313.         return new JsonResponse($result);
  314.     }
  316.     /**
  317.      * @Route("/profile/login", name="login")
  318.      */
  319.     public function loginAction(Request $request, AuthenticationUtils $utils) {
  321.         if (self::getMobileDevice($request)) {
  322.             return $this->redirect('/');
  323.         }
  324.         $redirectUri = $request->headers->get('referer', CityRepository::$mainPageURL);
  325.         $authError = $utils->getLastAuthenticationError();
  326.         $this->addFlash("openLoginPopup", "true");
  327.         if ($authError) {
  328.             $this->addFlash("authError", $authError);
  329.         }
  330.         // if the user is disabled, show the link to send a confirmation letter
  331.         if (is_a($authError, "Symfony\Component\Security\Core\Exception\DisabledException")) {
  332.             $this->addFlash("confirmEmail", Encoder::encodeString($authError->getToken()->getUserName(), User::SALT));
  333.         }
  334.         return $this->redirect($redirectUri);
  335.     }
  337.     /**
  338.      * @Route("/profile", name="profile")
  339.      */
  340.     public function profileAction(
  341.         Request $request,
  342.         ImageService $imageService,
  343.         SubscriptionService $subscriptionService,
  344.         UserGetter $userGetter
  345.     ) {
  346.         ini_set('memory_limit', '1G'); // TODO: need refactoring
  347.         $entityManager = $this->getDoctrine()->getManager();
  348.         $user = $userGetter->get();
  349.         $limit = 32;
  351.         // mark offer orders as seen by user
  352.         $notSeenOfferOrders = $user->getNotSeenOfferOrders();
  353.         /** @var OfferOrder $offerOrder */
  354.         foreach($notSeenOfferOrders as $offerOrder) {
  355.             $offerOrder->setSeenByUser(true);
  356.         }
  357.         $entityManager->flush();
  358.         $mobileDevice = CommonUtil::isMobileDevice($request);
  360.         $data['siteSettings'] = $this->getSiteSettings();
  361.         $bonusTypeBalanceActivityList = '(' . implode(',', UserBalanceActivityType::BONUS_ACTIVITIES) . ')';
  362.         $sql = "select coalesce(sum(amount), 0) from user_balance_activity where type in $bonusTypeBalanceActivityList and user_id = " . $this->getUser()->getID();
  363.         $data['totalBonus'] = number_format($entityManager->getConnection()->executeQuery($sql)->fetchColumn(), 2, '.', '');
  364.         $data['totalBonusCodes'] = (int)($data['totalBonus'] / $data['siteSettings']->getCodeCost());
  365.         $data['allOfferOrders'] = $this->getCodesHistory($limit, 0,false);
  366.         $data['deliveryOrders'] = $this->getCodesHistory($limit, 0,false, true);
  368.         $deliveryOrdersHistory = $this->getAllUserHistory($request, $imageService, $data['deliveryOrders'], $limit, 0, false);
  370.         $data['deliveryOrdersHistory'] = $deliveryOrdersHistory['html'];
  371.         $data['deliveryOrdersHistoryShowMoreButton'] = count($data['deliveryOrders']) >= $limit;
  372.         $data['promocodesHistory'] = $this->getCodesHistoryHtml($request, $data['allOfferOrders']);
  373.         $data['promocodesHistoryShowMoreButton'] = count($data['allOfferOrders']) >= $limit;
  374.         $balanceActivity = $this->getBalanceActivity($limit, 0);
  375.         $all = array_merge($data['allOfferOrders'], $balanceActivity);
  376.         $allUserHistory = $this->getAllUserHistory($request, $imageService, $all, $limit);
  377.         $data['allUserHistory'] = $allUserHistory['html'];
  378.         $data['balanceActivityHtml'] = $this->getBalanceActivityHtml($balanceActivity);
  379.         $data['balanceActivityShowMoreButton'] = count($balanceActivity) >= $limit;
  380.         $data['allShowMoreButton'] = $allUserHistory['count'] >= $limit;
  381.         $data['cities'] = $entityManager->getRepository(City::class)->findBy([], ['name' => 'asc']);
  382.         $data['mailingCampaignTypeList'] = $entityManager->getRepository(MailingCampaignType::class)->findBy([], ['ID' => 'ASC']);
  383.         $data['shareUrl'] = $request->getSchemeAndHttpHost() . '?ref=' . $user->getID();
  384.         $data['user'] = $entityManager->merge($user);
  385.         $data['referralBonus'] = $this->getSiteSettings()->getReferralBonus();
  386.         $data['subscribed'] = $subscriptionService->isSubscriber($user);
  387.         $data['subscription'] = $subscriptionService->getSubscription($user);
  388.         $data['currentSubscriptionPlan'] = $subscriptionService->getCurrentSubscriptionPlan($user);
  390.         if ($mobileDevice) {
  391.             return $this->render('Slivki/mobile/profile/index.html.twig', $data);
  392.         }
  394.         return $this->render('Slivki/profile/index.html.twig', $data);
  395.     }
  397.     /**
  398.      * @Route("/profile/ajax_get_more_codes")
  399.      */
  400.     public function ajaxGetMoreCodesAction(
  401.         Request $request,
  402.         ImageService $imageService
  403.     ) {
  404.         if (!$request->isXmlHttpRequest()) {
  405.             return $this->redirect("/profile");
  406.         }
  408.         $offset = $request->query->get('offset');
  409.         $type = $request->query->get('type');
  410.         $limit = $request->query->get('limit');
  412.         $result = [
  413.             'html' => '',
  414.             'hideShowMoreButton' => 0
  415.         ];
  416.         switch($type) {
  417.             case 'all':
  418.                 $balanceActivity = $this->getBalanceActivity(null, 0);
  419.                 $activeCodes = $this->getCodesHistory(null, 0,false);
  420.                 $all = array_merge($balanceActivity, $activeCodes);
  421.                 $allUserHistory = $this->getAllUserHistory($request, $imageService, $all, $limit, $offset);
  422.                 $result = [
  423.                     'html' => $allUserHistory['html'],
  424.                     'hideShowMoreButton' => $allUserHistory['count'] < $limit ? '1' : '0'
  425.                 ];
  426.                 break;
  427.             case 'balanceActivity':
  428.                 $balanceActivity = $this->getBalanceActivity($limit, $offset);
  429.                 $result = [
  430.                     'html' => $this->getBalanceActivityHtml($balanceActivity),
  431.                     'hideShowMoreButton' => count($balanceActivity) < $limit ? '1' : '0'
  432.                 ];
  433.                 break;
  434.             case 'deliveryOrdersHistory':
  435.                 $deliveryOrdersHistory = $this->getCodesHistory($limit, 0,false, true);
  436.                 $deliveryOrdersHistoryHtml = $this->getAllUserHistory($request, $imageService, $deliveryOrdersHistory, $limit, $offset, false);
  438.                 $result = [
  439.                     'html' => $deliveryOrdersHistoryHtml['html'],
  440.                     'hideShowMoreButton' => count($deliveryOrdersHistory) < (int)$offset + (int)$limit ? '1' : '0'
  441.                 ];
  442.                 break;
  443.             case 'promocodesHistory':
  444.                 $promocodesHistory = $this->getCodesHistory($limit, $offset, false);
  445.                 $result = [
  446.                     'html' => $this->getCodesHistoryHtml($request, $promocodesHistory),
  447.                     'hideShowMoreButton' => count($promocodesHistory) < $limit ? '1' : '0'
  448.                 ];
  449.                 break;
  450.         }
  451.         return new Response(json_encode($result));
  452.     }
  454.     private function getCodesHistory($limit, $offset, $onlyActive = true, $onlyFoodOrders = false) {
  455.         $userID = $this->getUser()->getID();
  456.         $onlyActiveCondition = $onlyActive ? "AND offerOrderDetails.codeActiveTill >= CURRENT_TIMESTAMP() + '-1 day'" : "";
  457.         $onlyFoodOrdersCondition = $onlyFoodOrders ? "and (offerOrder instance of " . FoodOrder::class
  458.             . " or offerOrder instance of " . TireOrder::class . " or offerOrder instance of " . GiftCertificateOrder::class . ")" : "";
  459.         $entityManager = $this->getDoctrine()->getManager();
  460.         $dql = "SELECT offerOrder, offer, teaserMedia
  461.           FROM Slivki:OfferOrder offerOrder  
  462.           join offerOrder.offer offer
  463.           left join offer.teaserMedias teaserMedia
  464.           WHERE offerOrder.user = $userID and offerOrder.status > 0
  465.             $onlyActiveCondition
  466.             $onlyFoodOrdersCondition
  467.           ORDER BY offerOrder.ID DESC";
  468.         $query = $entityManager->createQuery($dql);
  469.         if ($limit) {
  470.             $query->setMaxResults($limit);
  471.         }
  472.         $query->setFirstResult($offset);
  473.         return $query->getResult();
  474.     }
  476.     private function getCodesHistoryHtml(Request $request, $codesHistory)
  477.     {
  478.         /** @var User $user */
  479.         $user = $this->getUser();
  480.         $offerRepository = $this->getOfferRepository();
  481.         $codesHistoryHtml = '';
  482.         $mobileDevice = CommonUtil::isMobileDevice($request);
  483.         $view = $mobileDevice ? 'Slivki/mobile/profile/code_item.html.twig' : 'Slivki/profile/codes/codes_item.html.twig';
  484.         foreach($codesHistory as $item) {
  485.             if ($item->getOfferOrderDetails()->count() == 0 || ($item instanceof FoodOrder) || ($item instanceof TireOrder)) {
  486.                 continue;
  487.             }
  488.             $data['isTotalTab'] = false;
  489.             if ($mobileDevice) {
  490.                 $offer = $item->getOffer();
  491.                 $data['offer'] = $offer;
  492.                 $codeCost = $offerRepository->getCodeCost($offer);
  493.                 $offerIsFreeForUser = $this->getOfferRepository()->isOfferFreeForUser($offer, $user);
  494.                 $data['payLink'] = '/oplata-balance/' . $offer->getID();
  495.                 if (!$offerIsFreeForUser && $user->getFullBalance() < $codeCost) {
  496.                     $data['payLink'] = '/oplata/' . $offer->getID();
  497.                 }
  498.                 if ($offer->getID() == Offer::PETROL_OFFER_ID) {
  499.                     $data['payLink'] = '/oplata-promokoda-azs';
  500.                 }
  501.             }
  502.             $data['offerOrder'] = $item;
  503.             $codesHistoryHtml .= $this->renderView($view, $data);
  504.         }
  505.         return $codesHistoryHtml;
  506.     }
  508.     private function getBalanceActivity($limit, $offset) {
  509.         $userID = $this->getUser()->getID();
  510.         $entityManager = $this->getDoctrine()->getManager();
  511.         $user = $this->getUser();
  512.         $userRegistrationBonusCancel = $user->getBalanceActivityByType($entityManager->find(UserBalanceActivityType::class, UserBalanceActivity::TYPE_REGISTRATION_BONUS_CANCEL));
  513.         $userRegistrationBonusCancelCondition = '';
  514.         if ($userRegistrationBonusCancel->count() > 0) {
  515.             $userRegistrationBonusCancelCondition = ' AND UserBalanceActivity.type != ' . UserBalanceActivity::TYPE_REGISTRATION_BONUS
  516.                 . 'AND UserBalanceActivity.type != ' . UserBalanceActivity::TYPE_REGISTRATION_BONUS_CANCEL;
  517.         }
  518.         $dql = "SELECT UserBalanceActivity
  519.           FROM Slivki:UserBalanceActivity UserBalanceActivity
  520.           WHERE UserBalanceActivity.user = $userID $userRegistrationBonusCancelCondition
  521.           AND UserBalanceActivity.type != :resetBalanceForInactiveUserType
  522.           ORDER BY UserBalanceActivity.createdOn DESC";
  523.         $query = $entityManager->createQuery($dql);
  524.         $query->setParameter('resetBalanceForInactiveUserType', UserBalanceActivity::TYPE_RESET_BALANCE_FOR_INACTIVE_USER);
  525.         if ($limit) {
  526.             $query->setMaxResults($limit);
  527.         }
  528.         $query->setFirstResult($offset);
  529.         $balanceActivity = $query->getResult();
  530.         return $balanceActivity;
  531.     }
  533.     // TODO: Remove this shit when all bonuses will be refactored
  534.     private function getBalanceActivityHtml($balanceActivityList): string
  535.     {
  536.         $balanceActivityHtml = '';
  537.         $bonusTypeBalanceActivityList = UserBalanceActivityType::BONUS_ACTIVITIES;
  539.         // Workaround. Sort old and new bonuses
  540.         $bonusBalanceActivities = $this->bonusBalanceActivityDao->findAddActivitiesByUserId($this->getUser()->getID());
  541.         $balanceActivityList = array_merge($balanceActivityList, $bonusBalanceActivities);
  542.         usort(
  543.             $balanceActivityList,
  544.             static function($item1, $item2): int
  545.             {
  546.                 $date1 = $item1 instanceof GetUserBonusBalanceActivityResponse ? $item1->getCreatedAt() : $item1->getCreatedOn();
  547.                 $date2 = $item2 instanceof GetUserBonusBalanceActivityResponse ? $item2->getCreatedAt() : $item2->getCreatedOn();
  548.                 return $date2 <=> $date1;
  549.             }
  550.         );
  552.         /** @var UserBalanceActivity|GetUserBonusBalanceActivityResponse $balanceActivity*/
  553.         foreach ($balanceActivityList as $balanceActivity) {
  554.             if ($balanceActivity instanceof GetUserBonusBalanceActivityResponse) {
  555.                 $balanceActivityHtml .= $this->renderView('Slivki/profile/bonus/activity.html.twig', ['activity' => $balanceActivity]);
  556.             } elseif (in_array($balanceActivity->getType()->getID(), $bonusTypeBalanceActivityList)) {
  557.                 $balanceActivityHtml .= $this->renderView('Slivki/profile/codes/bonus_item.html.twig', ['bonus' => $balanceActivity, 'siteSettings' => $this->getSiteSettings()]);
  558.             } else {
  559.                 $balanceActivityHtml .= $this->renderView('Slivki/profile/codes/payments_item.html.twig', ['payment' => $balanceActivity]);
  560.             }
  561.         }
  563.         return $balanceActivityHtml;
  564.     }
  566.     private function getAllUserHistory(Request $request, ImageService $imageService, $all, $limit, $offset = 0, $isTotalTab = true) {
  567.         $isMobile = self::getMobileDevice($request);
  568.         $siteSettings = $this->getSiteSettings();
  569.         usort($all, function ($item1, $item2) {
  570.             return $item2->getCreatedOn()->format('U') - $item1->getCreatedOn()->format('U');
  571.         });
  572.         $all = array_slice($all, $offset, $limit);
  573.         $bonusTypeBalanceActivityList = UserBalanceActivityType::BONUS_ACTIVITIES;
  574.         $result = [
  575.             'html' => '',
  576.             'count' => count($all)
  577.         ];
  579.         /** @var User $user */
  580.         $user = $this->getUser();
  581.         $offerRepository = $this->getOfferRepository();
  582.         $standardCodeCost = $siteSettings->getCodeCost();
  583.         $seoRepository = $this->getSeoRepository();
  584.         foreach ($all as $item) {
  585.             if ($item instanceof SubscriptionOrder) {
  586.                 continue;
  587.             }
  589.             if ($item instanceof OfferOrder) {
  590.                 $data = [];
  591.                 $data['isTotalTab'] = $isTotalTab;
  592.                 $view = 'Slivki/profile/codes/codes_item.html.twig';
  593.                 if ($item instanceof FoodOrder) {
  594.                     if ($isMobile && $isTotalTab) {
  595.                         continue;
  596.                     }
  598.                     $data['foodOrder'] = $this->foodOrderHistoryDtoFactory->create($item);
  599.                     $view = 'Slivki/profile/codes/food_item.html.twig';
  600.                 } elseif ($item instanceof TireOrder) {
  601.                     $data['tireOrder'] = $this->tireOrderHistoryDtoFactory->create($item);
  602.                     $view = 'Slivki/profile/codes/tire_item.html.twig';
  603.                 } elseif ($item instanceof GiftCertificateOrder) {
  604.                     $view = 'Slivki/profile/codes/gift_certificate_item.html.twig';
  605.                 }
  606.                 if ($isMobile) {
  607.                     if ($item instanceof FoodOrder) {
  608.                         $view = 'Slivki/mobile/profile/food_item.html.twig';
  609.                     } elseif ($item instanceof TireOrder) {
  610.                         $view = 'Slivki/mobile/profile/tire_item.html.twig';
  611.                     } elseif ($item instanceof GiftCertificateOrder) {
  612.                         $view = 'Slivki/mobile/profile/gift_certificate_item.html.twig';
  613.                     } else {
  614.                         $view = 'Slivki/mobile/profile/code_item.html.twig';
  615.                     }
  617.                     $offer = $item->getOffer();
  618.                     $data['offer'] = $offer;
  619.                     $codeCost = $offerRepository->getCodeCost($offer);
  620.                     $offerIsFreeForUser = $this->getOfferRepository()->isOfferFreeForUser($offer, $user);
  621.                     $data['payLink'] = '/oplata-balance/' . $offer->getID();
  622.                     if ($user->getFullBalance() < $codeCost && !$offerIsFreeForUser) {
  623.                         $data['payLink'] = '/oplata/' . $offer->getID();
  624.                     }
  625.                     if ($offer->getID() == Offer::PETROL_OFFER_ID) {
  626.                         $data['payLink'] = '/oplata-promokoda-azs';
  627.                     } else if ($codeCost != $standardCodeCost || ($item->getOfferOrderDetails()->count() > 0 && $item->getOfferOrderDetails()->first()->getOfferExtension())) {
  628.                         $data['payLink'] = $seoRepository->getOfferURL($offer->getID())->getMainAlias();
  629.                     }
  630.                 }
  631.                 $data['offerOrder'] = $item;
  632.                 $result['html'] .= $this->renderView($view, $data);
  633.             } else {
  634.                 if (!$isMobile) {
  635.                     if (in_array($item->getType()->getID(), $bonusTypeBalanceActivityList)) {
  636.                         $result['html'] .= $this->renderView('Slivki/profile/codes/bonus_item.html.twig', ['bonus' => $item, 'siteSettings' => $siteSettings]);
  637.                     } else {
  638.                         $result['html'] .= $this->renderView('Slivki/profile/codes/payments_item.html.twig', ['payment' => $item]);
  639.                     }
  640.                 }
  641.             }
  642.         }
  643.         return $result;
  644.     }
  646.     /**
  647.      * @Route("/profile/ajax_use_code/{codeID}")
  648.      */
  649.     public function ajaxUseCode($codeID) {
  650.         $code = $this->getOfferOrderDetailsRepository()->find($codeID);
  651.         if (!$code) {
  652.             return new Response();
  653.         }
  654.         if ($code->getOfferOrder()->getUser() != $this->getUser()) {
  655.             return new Response();
  656.         }
  657.         $code->setUsed(true);
  658.         $this->getDoctrine()->getManager()->flush();
  659.         return new Response();
  660.     }
  662.     /**
  663.      * @Route("/profile/ajax_unuse_code/{codeID}")
  664.      */
  665.     public function ajaxUnuseCode($codeID) {
  666.         $code = $this->getOfferOrderDetailsRepository()->find($codeID);
  667.         if (!$code) {
  668.             return new Response();
  669.         }
  670.         if ($code->getOfferOrder()->getUser() != $this->getUser()) {
  671.             return new Response();
  672.         }
  673.         $code->setUsed(false);
  674.         $this->getDoctrine()->getManager()->flush();
  675.         return new Response();
  676.     }
  678.     /**
  679.      * @Route("/ajax_get_user_social_accounts")
  680.      */
  681.     public function ajaxGetUserSocialAccounts() {
  682.         $user = $this->getUser();
  683.         $result = '';
  684.         $socialAccounts = $user->getSocialAccounts();
  685.         foreach ($socialAccounts as $socialAccount) {
  686.             $result .= $socialAccount->getNetwork() . ' ';
  687.         }
  688.         return new Response($result);
  689.     }
  691.     /**
  692.      * @Route("/accept_newsletter")
  693.      */
  694.     public function acceptNewsletter(Request $request, SubscriptionService $subscriptionService)
  695.     {
  696.         $entityManager =  $this->getDoctrine()->getManager();
  697.         $user = $this->getUser();
  698.         $requestMailingCampaignTypeIDList = $request->request->get('newsletter', []);
  700.         foreach ($user->getMailingCampaignTypes() as $mailingCampaignType) {
  701.             if (!in_array($mailingCampaignType->getID(), $requestMailingCampaignTypeIDList)) {
  702.                 $user->removeMailingCampaignType($mailingCampaignType);
  703.                 $this->getUserRepository()->addActivity($user, UserActivity::UNSUBSCRIBE_ACTION, $mailingCampaignType);
  704.             }
  705.         }
  706.         $subscribe = false;
  707.         foreach ($requestMailingCampaignTypeIDList as $mailingCampaignTypeID) {
  708.             if (!$user->hasMailingCampaignType($mailingCampaignTypeID)) {
  709.                 $mailingCampaignType = $entityManager->getRepository(MailingCampaignType::class)->find($mailingCampaignTypeID);
  710.                 if ($mailingCampaignType) {
  711.                     $user->addMailingCampaignTypes($mailingCampaignType);
  712.                     $this->getUserRepository()->addActivity($user, UserActivity::SUBSCRIBE_ACTION, $mailingCampaignType);
  713.                     $subscribe = true;
  714.                 }
  715.             }
  716.         }
  717.         if ($subscribe) {
  718.             $limitDate = new DateTime('2017-09-20');
  719.             $activityType = $entityManager->find(UserBalanceActivityType::class, UserBalanceActivity::TYPE_SUBSCRIBE_PROMO_BONUS);
  720.             $activityCount = 0;
  721.             if ($user->getBalanceActivityByType($activityType)->count() == 0) {
  722.                 foreach ($user->getUserActivity() as $activity) {
  723.                     if ($activity->getCreatedOn() > $limitDate) {
  724.                         $activityCount++;
  725.                     }
  726.                 }
  727.                 if ($activityCount < 2) {
  728.                     $entityManager->getRepository(User::class)->addBonus(
  729.                         $subscriptionService,
  730.                         $user,
  731.                         UserBalanceActivity::TYPE_SUBSCRIBE_PROMO_BONUS,
  732.                         1.5
  733.                     );
  734.                 }
  735.             }
  736.         }
  737.         $entityManager->flush($user);
  739.         return $this->redirect("/profile#profile_subscribe");
  740.     }
  742.     /**
  743.      * @Route("/unsubscribe")
  744.      */
  745.     public function unsubscribeNewsletters(Request $request) {
  746.         $entityManager = $this->getDoctrine()->getManager();
  747.         if ($request->isMethod('POST')) {
  748.             $email = $request->request->get('email', '');
  749.             $mailingCampaignID = $request->request->getInt('mailingCampaignID');
  750.             if ($email == '') {
  751.                 return $this->redirect("/");
  752.             }
  753.             $userRepository = $this->getUserRepository();
  754.             $user = $userRepository->findOneByEmail($email);
  755.             if (!$user) {
  756.                 return $this->redirect("/");
  757.             }
  758.             $requestMailingCampaignTypeIDList = $request->request->get('newsletter', []);
  760.             $unsubscribed = false;
  761.             foreach ($user->getMailingCampaignTypes() as $mailingCampaignType) {
  762.                 if (!in_array($mailingCampaignType->getID(), $requestMailingCampaignTypeIDList)) {
  763.                     $user->removeMailingCampaignType($mailingCampaignType);
  764.                     $userRepository->addActivity($user, UserActivity::UNSUBSCRIBE_ACTION, $mailingCampaignType);
  765.                     $unsubscribed = true;
  766.                 }
  767.             }
  769.             if ($unsubscribed) {
  770.                 $mailingCampaign = $entityManager->find(MailingCampaign::class, $mailingCampaignID);
  771.                 if ($mailingCampaign) {
  772.                     $mailingCampaignUnsubscribe = $entityManager->getRepository(MailingCampaignUnsubscribe::class)->findBy(['user' => $user, 'mailingCampaign' => $mailingCampaign]);
  773.                     if (empty($mailingCampaignUnsubscribe)) {
  774.                         $mailingCampaignUnsubscribe = new MailingCampaignUnsubscribe();
  775.                         $mailingCampaignUnsubscribe->setUser($user);
  776.                         $mailingCampaignUnsubscribe->setMailingCampaign($mailingCampaign);
  777.                         $entityManager->persist($mailingCampaignUnsubscribe);
  778.                         $entityManager->flush();
  779.                     }
  780.                 }
  781.             }
  783.             foreach ($requestMailingCampaignTypeIDList as $mailingCampaignTypeID) {
  784.                 if (!$user->hasMailingCampaignType($mailingCampaignTypeID)) {
  785.                     $mailingCampaignType = $entityManager->getRepository(MailingCampaignType::class)->find($mailingCampaignTypeID);
  786.                     if ($mailingCampaignType) {
  787.                         $user->addMailingCampaignTypes($mailingCampaignType);
  788.                         $userRepository->addActivity($user, UserActivity::SUBSCRIBE_ACTION, $mailingCampaignType);
  789.                     }
  790.                 }
  791.             }
  792.             $entityManager->flush($user);
  793.             return $this->render('Slivki/unsubscribe_results.html.twig');
  794.         }
  795.         $email = $request->query->get('email', '');
  796.         $subscriber = $entityManager->getRepository(Subscriber::class)->findOneByEmail($email);
  797.         if ($subscriber) {
  798.             $entityManager->remove($subscriber);
  799.             $entityManager->flush($subscriber);
  801.             return $this->render('Slivki/unsubscribe_results.html.twig');
  802.         }
  803.         $data = [];
  804.         if ($email == '') {
  805.             return $this->redirect("/");
  806.         }
  807.         $userRepository = $this->getUserRepository();
  808.         $user = $userRepository->findOneByEmail($email);
  809.         if (!$user) {
  810.             return $this->redirect("/");
  811.         }
  812.         $mailingCampaignID = $request->query->getInt('mc');
  813.         if ($mailingCampaignID) {
  814.             $data['mailingCampaignID'] = $mailingCampaignID;
  815.         }
  816.         $data['user'] = $user;
  817.         $data['mailingCampaignTypeList'] = $entityManager->getRepository(MailingCampaignType::class)->findBy([], ['ID' => 'ASC']);
  818.         return $this->render('Slivki/unsubscribe.html.twig', $data);
  819.     }
  821.     /**
  822.      * @Route("/profile_image_upload")
  823.      */
  824.     public function profileImageUpload(
  825.         Request $request,
  826.         ImageService $imageService,
  827.         KernelInterface $kernel,
  828.         MessageBusInterface $commandBus
  829.     ) {
  830.         $actionRequest = $request->query->get('actionRequest');
  831.         $error = 'true';
  832.         $result = '';
  833.         $user = $this->getUser();
  834.         $entityManager = $this->getDoctrine()->getManager();
  835.         $media = $user->getProfileImageMedia();
  836.         switch ($actionRequest) {
  837.             case 'uploadFile':
  838.                 $imageFolder = $kernel->getProjectDir() . '/public' . User::MEDIA_PATH;
  839.                 $uploadedFile = $request->files->get('profileImageUpload');
  840.                 if ($uploadedFile) {
  841.                     if (!in_array(mb_strtolower($uploadedFile->getClientOriginalExtension()), ['jpg', 'png', 'gif', 'jpeg'])) {
  842.                         return new Response("error=true;result=Разрешены только .jpg, .jpeg, .png или .gif изображения");
  843.                     };
  844.                     $fs = new Filesystem();
  845.                     $newFileName = time() . '_' . $uploadedFile->getClientOriginalName();
  847.                     while ($fs->exists($imageFolder . $newFileName)) {
  848.                         $newFileName = time() . '_' . $newFileName;
  849.                     }
  851.                     $uploadedFile->move($imageFolder, $newFileName);
  852.                     if (!$media) {
  853.                         $media = new Media\ProfileImageMedia();
  854.                         $media->setMediaType($entityManager->getRepository(MediaType::class)->find(MediaType::TYPE_PROFILE_IMAGE_ID));
  855.                         $media->setPath(MediaType::TYPE_PROFILE_IMAGE_PATH);
  856.                         $entityManager->persist($media);
  857.                     }
  858.                     $media->setName($newFileName);
  859.                     $user->setProfileImageMedia($media);
  860.                     $entityManager->flush();
  862.                     $commandBus->dispatch(new AddBonusCommand($user->getID(), Bonus::AVATAR_UPLOAD));
  864.                     $result = User::MEDIA_PATH . $newFileName;
  865.                     $error = 'false';
  866.                 }
  867.                 break;
  868.             case 'cropImage':
  869.                 $cropCoordinates = $request->request->get('cropCoordinates');
  870.                 $cropCoordinates = json_decode($cropCoordinates);
  871.                 $originalMediaPath = $kernel->getProjectDir() . '/public/znijki-media/initial' . $media->getPath() . $media->getName();
  872.                 $imagine = new Imagine();
  873.                 $image = $imagine->open($originalMediaPath);
  874.                 $image->crop(new Point($cropCoordinates->x, $cropCoordinates->y), new Box($cropCoordinates->w, $cropCoordinates->h));
  875.                 $image->save($originalMediaPath);
  877.                 $softCache = new SoftCache(ImageService::CACHE_NAME);
  878.                 $mediaSizeList = $media->getSizes();
  879.                 foreach ($mediaSizeList->toArray() as $mediaSize) {
  880.                     $cacheKey = $media->getID() . "-url-" . $mediaSize->getWidth() . "x" . $mediaSize->getHeight();
  881.                     $softCache->set($cacheKey, null, 1);
  882.                     $imageService->resizeImage($media, $mediaSize->getWidth(), $mediaSize->getHeight());
  883.                 }
  884.                 $result = $imageService->getImageURL($media, 250, 250);
  885.                 $error = 'false';
  887.                 break;
  888.             case 'deleteImage':
  889.                 $entityManager->remove($media);
  890.                 $entityManager->flush();
  891.                 $error = 'false';
  892.                 break;
  893.         }
  896.         return new Response("error=$error;result=$result");
  897.     }
  899.     /**
  900.      * @Route("/ajax_profile_save")
  901.      */
  902.     public function ajaxProfileSave(Request $request, ValidatorInterface $validator): Response
  903.     {
  904.         $user = $this->getUser();
  905.         $result['error'] = '';
  906.         $entityManager = $this->getDoctrine()->getManager();
  907.         /** @var \Symfony\Component\Validator\ConstraintViolationList $errorList */
  908.         $errorList = $validator->validate($user);
  910.         if ($errorList->count() > 0) {
  911.             $result['error'] .= $errorList->get(0)->getMessage();
  912.         }
  914.         if($request->request->get('user_name') == '') {
  915.             $result['error'] .= 'Поле "Имя" не может быть пустым!<br>';
  916.         }
  918.         $requestPassword = trim($request->request->get('user_new_pass'));
  919.         if(strlen($requestPassword) > 0) {
  920.             if (strlen($requestPassword) < 6) {
  921.                 $result['error'] .= 'Пароль не может быть меньше 6 символов';
  922.             }
  924.             if($requestPassword != $request->request->get('user_confirm_pass')) {
  925.                 $result['error'] .= 'Введенные пароли не совпадают!<br>';
  926.             }
  928.             $user->encryptPassword($requestPassword, $user->getSalt());
  929.         }
  931.         $user->setFirstName($request->request->get('user_name'));
  932.         $user->setLastName($request->request->get('user_last_name'));
  933.         $city = $entityManager->getRepository(City::class)->find($request->request->get('city'));
  934.         $user->setCity($city);
  936.         $dob = $request->request->get('user_dob');
  937.         if (!empty($dob)) {
  938.             $user->setDob(new DateTime($dob));
  939.         }
  941.         if($result['error'] == '') {
  942.             $entityManager->flush($user);
  943.         }
  945.         return new Response(json_encode($result));
  946.     }
  948.     /**
  949.      * @Route("/confirm/{code}", name="confirm")
  950.      */
  951.     public function confirmAction(Request $request, $code) {
  952.         $code = pg_escape_string($code);
  953.         $entityManager = $this->getDoctrine()->getManager();
  954.         $resultMapping = new ResultSetMapping();
  955.         $resultMapping->addEntityResult(UserConfirmation::class, "UserConfirmation");
  956.         $resultMapping->addFieldResult("UserConfirmation", "user_id", "userID");
  957.         $resultMapping->addFieldResult("UserConfirmation", "id", "ID");
  958.         $resultMapping->addFieldResult("UserConfirmation", "return_url", "returnUrl");
  959.         $query = $entityManager->createNativeQuery("select user_id, id, return_url from user_confirmation where md5(id::text || user_id::text)=?", $resultMapping);
  960.         $query->setParameter(1, $code);
  961.         $confirmation = $query->getResult();
  962.         $returnUrl = '/';
  963.         if ($confirmation) {
  964.             $userID = $confirmation[0]->getUserID();
  965.             $user = $entityManager->getRepository(User::class)->find($userID);
  966.             if (!$user) {
  967.                 $data['lastComments'] = $this->getDoctrine()->getRepository(Comment::class)->findBy(["hidden" => false], ["createdOn" => "desc"], 3);
  968.                 return $this->render('Slivki/register_confirm_error.html.twig', $data);
  969.             }
  970.             $user->setStatus(User::STATUS_CONFIRMED);
  971.             $mainMailingCampaignType = $entityManager->getRepository(MailingCampaignType::class)->find(MailingCampaignType::MAIN_ID);
  972.             $user->addMailingCampaignTypes($mainMailingCampaignType);
  973.             foreach ($confirmation as $item) {
  974.                 $entityManager->remove($item);
  975.             }
  976.             $entityManager->flush();
  977.             $userRepository = $this->getUserRepository();
  978.             $userRepository->addActivity($user, UserActivity::SUBSCRIBE_ACTION, $mainMailingCampaignType);
  979.             $returnUrl = $confirmation[0]->getReturnUrl() ? $confirmation[0]->getReturnUrl() : '/';
  980.         } else {
  981.             $data['lastComments'] = $this->getDoctrine()->getRepository(Comment::class)->findBy(["hidden" => false], ["createdOn" => "desc"], 3);
  982.             return $this->render('Slivki/register_confirm_error.html.twig', $data);
  983.         }
  984.         $this->addFlash("openThanksForRegisterPopup", "true");
  985.         // Login user
  986.         $token = new UsernamePasswordToken($user, null, 'main', $user->getRoles());
  987.         $this->get('security.token_storage')->setToken($token);
  989.         return $this->redirect($returnUrl);
  990.     }
  992.     private function checkReferer(Request $request, User $user) {
  993.         $refererID = $request->cookies->get('refID');
  994.         if (!$refererID) {
  995.             return;
  996.         }
  997.         $entityManager = $this->getDoctrine()->getManager();
  998.         $referer = $entityManager->find(User::class, $refererID);
  999.         if (!$referer) {
  1000.             return;
  1001.         }
  1002.         $referral = $entityManager->getRepository(Referral::class)->findBy(['email' => $user->getEmail()]);
  1003.         if (!$referral) {
  1004.             $referral = new Referral();
  1005.             $entityManager->persist($referral);
  1006.         } else {
  1007.             $referral = $referral[0];
  1008.         }
  1009.         $referral->setReferral($user);
  1010.         $referral->setReferer($referer);
  1011.         $referral->setStatus(Referral::STATUS_REGISTERED);
  1012.         $referer->addReferral($referral);
  1013.         $entityManager->flush();
  1014.     }
  1016.     /**
  1017.      * @Route("/ajax_set_favourite")
  1018.      */
  1019.     public function ajaxSetFavourite(Request $request) {
  1020.         if (!$request->isXmlHttpRequest()) {
  1021.             return $this->redirect("/");
  1022.         }
  1023.         $action = $request->query->get('action');
  1024.         $offerID = $request->query->get('offerID');
  1026.         $entityManager = $this->getDoctrine()->getManager();
  1027.         $user = $this->getUser();
  1028.         $offer = $this->getOfferRepository()->find($offerID);
  1030.         switch ($action) {
  1031.             case 'addToFavourites':
  1032.                 $user->addFavouriteOffer($offer);
  1033.                 $entityManager->flush();
  1034.                 break;
  1035.             case 'deleteFromFavourites':
  1036.                 $user->deleteFavouriteOffer($offer);
  1037.                 $entityManager->flush();
  1038.                 break;
  1039.         }
  1041.         return new Response('');
  1042.     }
  1044.     private function subscriberRemove($email) {
  1045.         $entityManager = $this->getDoctrine()->getManager();
  1046.         $subscriber = $entityManager->getRepository(Subscriber::class)->findOneByEmail($email);
  1047.         if ($subscriber) {
  1048.             $entityManager->remove($subscriber);
  1049.             $entityManager->flush($subscriber);
  1050.         }
  1051.     }
  1053.     /**
  1054.      * @Route("/profile/refresh_user_balance")
  1055.      */
  1056.     public function refreshUserBalance() {
  1057.         return new Response($this->getUser()->getBalance());
  1058.     }
  1060.     /** @Route("/user/offer-rate/defer") */
  1061.     public function deferOfferRateAction() {
  1062.         $sql = "update offer_rate_schedule set show_on = show_on + '7 days' where user_id = " . (int)$this->getUser()->getID() . ';';
  1063.         $this->getDoctrine()->getManager()->getConnection()->executeQuery($sql);
  1065.         return new Response();
  1066.     }
  1068.     /** @Route("/user/offer-rate-popup/disable") */
  1069.     public function disableOfferRatePopup() {
  1070.         $entityManager = $this->getDoctrine()->getManager();
  1071.         $user = $entityManager->merge($this->getUser());
  1072.         $user->setNotShowRatePopupTill(new DateTime('+30 days'));
  1073.         $entityManager->flush();
  1075.         return new Response();
  1076.     }
  1078.     /**
  1079.      * @Route("/mobile-logout")
  1080.      */
  1081.     public function mobileLogoutPageAction(Request $request) {
  1082.         if ($this->getUser() and self::getMobileDevice($request)) {
  1083.             return $this->render('Slivki/mobile_logout.html.twig');
  1084.         } else {
  1085.             return $this->redirect("/login");
  1086.         }
  1087.     }
  1089.     /**
  1090.      * @Route("/profile/ajax_get_favorite")
  1091.      */
  1092.     public function ajaxGetFavorite(Request $request) {
  1093.         if (!$request->isXmlHttpRequest()) {
  1094.             return $this->redirect("/profile");
  1095.         }
  1097.         $entityManager = $this->getDoctrine()->getManager();
  1098.         $user = $this->getUser();
  1099.         $data['allFavouriteOffers'] = $user->getFavouriteOffers()->toArray();
  1100.         $data['activeFavouriteOffers'] = [];
  1101.         $data['pastFavouriteOffers'] = [];
  1102.         $mediaRepository = $entityManager->getRepository(Media::class);
  1103.         foreach ($data['allFavouriteOffers'] as $favouriteOffer) {
  1104.             if ($favouriteOffer->getActiveTill()->format('U') > time()) {
  1105.                 $data['activeFavouriteOffers'][] = $favouriteOffer;
  1106.             } else {
  1107.                 $data['pastFavouriteOffers'][] = $favouriteOffer;
  1108.             }
  1109.         }
  1110.         $view = self::getMobileDevice($request) ? 'Slivki/mobile/profile/favorites.html.twig' : 'Slivki/profile/favorites/index.html.twig';
  1111.         return $this->render($view, $data);
  1112.     }
  1114.     /** @Route("/profile/invite/send") */
  1115.     public function sendInviteAction(Request $request, Mailer $mailer, ValidatorInterface $validator) {
  1116.         $emailList = $request->request->get('inviteTo');
  1117.         if (!$emailList) {
  1118.             return new JsonResponse(['message' => 'Введите адрес получателя']);
  1119.         }
  1120.         $emailList = explode(',', $emailList);
  1121.         $entityManager = $this->getDoctrine()->getManager();
  1122.         $sql = "select count(*) from referral where referer_id = " . $this->getUser()->getID() . " and created_on > now() + '-1 day'";
  1123.         $invitesSentCount = $entityManager->getConnection()->executeQuery($sql)->fetchColumn();
  1124.         if ($invitesSentCount + count($emailList) > 10) {
  1125.             return new JsonResponse(['message' => 'Превышен суточный лимит отправки приглашений']);
  1126.         }
  1127.         $emailConstraint = new \Symfony\Component\Validator\Constraints\Email();
  1128.         foreach ($emailList as $email) {
  1129.             $error = $validator->validate($email, $emailConstraint);
  1130.             if ($error->count() > 0) {
  1131.                 return new JsonResponse(['message' => 'Неверный формат адреса электронной почты']);
  1132.             }
  1133.         }
  1134.         $referer = $entityManager->merge($this->getUser());
  1135.         $inviteFrom = $request->request->get('inviteFrom');
  1136.         foreach ($emailList as $email) {
  1137.             $email = mb_strtolower(trim($email));
  1138.             $referral = new Referral();
  1139.             $referral->setEmail($email);
  1140.             $referral->setReferer($referer);
  1141.             $referral->setStatus(Referral::STATUS_WAIT);
  1142.             $entityManager->persist($referral);
  1143.             $referer->addReferral($referral);
  1144.             $entityManager->flush();
  1145.             $message = $mailer->createMessage();
  1146.             $message->setTo($email);
  1147.             $message->setFrom('info@slivki.by', $inviteFrom);
  1148.             $message->returnPath($inviteFrom);
  1149.             $message->replyTo($inviteFrom);
  1150.             $message->setSubject('Рекомендую Slivki.by');
  1151.             $message->setBody($request->request->get('inviteText'));
  1152.             $mailer->send($message);
  1153.         }
  1155.         return new JsonResponse(['result' => true, 'message' => 'Приглашение отправлено']);
  1156.     }
  1158.     /** @Route("/profile/card", name = "profileMobileCardList") */
  1159.     public function creditCardAction(Request $request) {
  1160.         if (!self::getMobileDevice($request)) {
  1161.             return new Response();
  1162.         }
  1163.         return $this->render('Slivki/mobile/profile/card.html.twig');
  1164.     }
  1166.     /** @Route("/profile/card/add-form", name = "profileMobileCardAdd") */
  1167.     public function addCreditCardAction(Request $request) {
  1168.         if (!self::getMobileDevice($request)) {
  1169.             return new Response();
  1170.         }
  1171.         return $this->render('Slivki/mobile/profile/card_add.html.twig');
  1172.     }
  1174.     /**
  1175.      * @Route("/profile/card/remove/{cardID}")
  1176.      * @Route("/profile/delivery/card/remove/{cardID}")
  1177.      */
  1178.     public function cardRemoveAction(
  1179.         RemoveCreditCardHandler $removeCreditCardHandler,
  1180.         int $cardID
  1181.     ) {
  1182.         $removeCreditCardHandler->handle($this->getUser(), $cardID);
  1184.         return new Response();
  1185.     }
  1187.     /**
  1188.      * @Route("/profile/gift_certificates/pdf/{offerOrderDetailsID}")
  1189.      */
  1190.     public function giftCertificatesPdf(Request $request, KernelInterface $kernel, $offerOrderDetailsID) {
  1191.         $action = $request->query->get('action');
  1192.         /** @var OfferOrderDetails $offerOrderDetails */
  1193.         $offerOrderDetails = $this->getOfferOrderDetailsRepository()->find($offerOrderDetailsID);
  1194.         if (!$offerOrderDetails) {
  1195.             return new Response();
  1196.         }
  1197.         if ($offerOrderDetails->getOfferOrder()->getUser() != $this->getUser()) {
  1198.             return new Response();
  1199.         }
  1200.         $mpdf = $this->getGiftCertificateMpdf($kernel, $offerOrderDetails);
  1201.         if (!$mpdf) {
  1202.             return new Response();
  1203.         }
  1204.         if ($action == 'save') {
  1205.             $mpdf->Output('certificate'.$offerOrderDetailsID.'.pdf', 'D');
  1206.         } else {
  1207.             $mpdf->Output();
  1208.         }
  1209.     }
  1211.     /** @Route("/profile/phone/confirm", name="phoneConfirm") */
  1212.     public function phoneConfirmAction(Request $request) {
  1213.         $user = $this->getUser();
  1214.         $userPhone = $user->getCurrentPhone();
  1216.         if ($userPhone && $userPhone->isConfirmed() && $userPhone->isBelorussian()) {
  1217.             return $this->redirectToRoute('homepage');
  1218.         }
  1220.         return $this->render(CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/profile/phone_confirm.html.twig'
  1221.             : 'Slivki/profile/phone_confirm.html.twig');
  1222.     }
  1224.     /**
  1225.      * @Route("/profile/phone/sendsms", name="profile_phone_sendsms")
  1226.      */
  1227.     public function phoneSendSmsAction(
  1228.         Request $request,
  1229.         AuthorizationCodeSender $authorizationCodeSender,
  1230.         UserPhoneService $userPhoneService
  1231.     ): Response {
  1232.         $phoneNumber = $request->request->get('userPhone', '');
  1234.         if (strlen($phoneNumber) != 12) {
  1235.             return new Response('Wrong phone number!');
  1236.         }
  1238.         $entityManager = $this->getDoctrine()->getManager();
  1239.         $user = $this->getUser();
  1240.         $userPhone = $user->getCurrentPhone();
  1241.         if ($userPhone && $userPhone->getPhoneNumber() == $phoneNumber && $userPhone->isConfirmed()) {
  1242.             return new Response('Allready confirmed!');
  1243.         }
  1245.         $existUserPhone = $entityManager->getRepository(UserPhone::class)->findBy([
  1246.             'confirmed' => true,
  1247.             'phoneNumber' => $phoneNumber
  1248.         ]);
  1250.         if ($existUserPhone) {
  1251.             return new Response("Номер телефона $phoneNumber уже зарегистрирован!");
  1252.         }
  1254.         if (!$userPhone || !($userPhone->getPhoneNumber() == $phoneNumber)) {
  1255.             $userPhoneService->addUserPhone($user, $phoneNumber);
  1256.         }
  1258.         $smsCode = random_int(1000, 9999);
  1259.         $this->get('session')->set('confirmPhoneNumber', $phoneNumber);
  1260.         $this->get('session')->set('confirmPhoneSmsCode', $smsCode);
  1262.         $authorizationCodeSender->send($phoneNumber, $smsCode, $request->getHost());
  1264.         return new Response();
  1265.     }
  1267.     /** @Route("/profile/phone/checkcode") */
  1268.     public function phoneCheckCodeAction(
  1269.         Request $request,
  1270.         Mailer $mailer,
  1271.         UserPhoneService $userPhoneService
  1272.     ): Response {
  1273.         $requestCode = $request->request->get('smsCode', '');
  1274.         $code = $this->get('session')->get('confirmPhoneSmsCode');
  1275.         $phoneNumber = $this->get('session')->get('confirmPhoneNumber');
  1276.         if ($requestCode != $code) {
  1277.             return new Response();
  1278.         }
  1279.         $user = $this->getUser();
  1280.         $userPhone = $user->getCurrentPhone();
  1281.         if ($userPhone && $userPhone->getPhoneNumber() == $phoneNumber) {
  1282.             $userPhoneService->confirmUserPhone($userPhone);
  1284.             $comments = $this->getCommentRepository()->findBy(['user' => $user, 'confirmedPhone' => false], ['ID' => 'DESC']);
  1285.             if (isset($comments[0])) {
  1286.                 $comments[0]->setConfirmedPhone(true);
  1287.                 $comments[0]->setPhone($userPhone->getPhoneNumber());
  1288.                 if ($comments[0]->getTypeID() == Comment::TYPE_OFFER_COMMENT) {
  1289.                     $offer = $this->getOfferRepository()->find($comments[0]->getEntityID());
  1290.                     if ($offer) {
  1291.                         $this->sendOfferCommentNotice($mailer, $offer, $comments[0], $comments[0]->getParentComment());
  1292.                     }
  1293.                 }
  1294.             }
  1295.             $this->getDoctrine()->getManager()->flush();
  1296.             if (isset($comments[0])) {
  1297.                 $this->resetCommentsCache($comments[0]->getEntityID(), $comments[0]->getTypeID());
  1298.             }
  1299.             return new Response('1');
  1300.         }
  1301.         return new Response();
  1302.     }
  1304.     /**
  1305.      * @Route("/user/create/from-order", methods={"POST"}, name="user_create_from_order")
  1306.      */
  1307.     public function userCreateFromOrder(Request $request, Mailer $mailer, ValidatorInterface $validator) {
  1308.         $entityManager = $this->getDoctrine()->getManager();
  1309.         $order = $entityManager->find(Offer::class, $request->request->get('orderID'));
  1310.         if (!$order) {
  1311.             return new Response('Произошла ошибка');
  1312.         }
  1313.         $email = mb_strtolower(trim($request->request->get('email')));
  1314.         $user = $entityManager->getRepository(User::class)->findByEmail($email);
  1315.         if ($user) {
  1316.             return new JsonResponse(['error' => true, 'message' => 'Пользователь с таким email уже зарегистрирован']);
  1317.         }
  1318.         $password = rand(11111, 99999);
  1319.         $user = new User();
  1320.         $user->setEmail($email);
  1321.         $user->encryptPassword($password);
  1322.         $order->setUser($user);
  1323.         $user->setStatus(User::STATUS_CONFIRMED);
  1324.         /** @var \Symfony\Component\Validator\ConstraintViolationList $errorList */
  1325.         $errorList = $validator->validate($user);
  1326.         if ($errorList->count() > 0) {
  1327.             return new JsonResponse(['error' => true, 'message' => $errorList->get(0)->getMessage()]);
  1328.         }
  1329.         $order->setUser($user);
  1330.         $entityManager->persist($user);
  1331.         $entityManager->getRepository(User::class)->addDirectorGroupToUserByUser($user);
  1332.         $entityManager->flush();
  1334.         $message = $mailer->createMessage();
  1335.         $message->setTo($email);
  1336.         $message->setFrom('info@slivki.by', 'Slivki.by');
  1337.         $message->setSubject('Мы позаботились о том, чтобы вы не забыли');
  1338.         $message->setBody($this->renderView('Slivki/emails/code.html.twig', ['offerOrder' => $order, 'userCreated' => true]), 'text/html');
  1339.         $mailer->send($message);
  1341.         return new JsonResponse(['error' => false, 'message' => 'Письмо с кодом отправлено на Ваш адрес']);
  1342.     }
  1344.     /**
  1345.      * @Route("/profile/delivery/address/add")
  1346.      */
  1347.     public function addAddressAction(
  1348.         Request $request,
  1349.         CoordinatesYandex $coordinatesYandex,
  1350.         SubscriptionService $subscriptionService,
  1351.         DeliveryZoneRepositoryInterface $deliveryZoneRepository
  1352.     ): JsonResponse {
  1353.         $entityManager = $this->getDoctrine()->getManager();
  1355.         $orderID = $request->request->getInt('orderID');
  1356.         /** @var FoodOrder $order */
  1357.         $order = $entityManager->find(FoodOrder::class, $orderID);
  1359.         $offer = $order->getOffer();
  1360.         $offerID = $offer->getID();
  1361.         $iikoUtil = IikoUtil::instance($offer);
  1362.         $iikoUtil->setContainer($this->kernel->getContainer());
  1364.         if ($request->request->getBoolean('isStreetSelect')) {
  1365.             $street = $entityManager->find(Street::class, $request->request->getInt('streetID'));
  1366.         } else {
  1367.             $streetName = $request->request->get('streetID');
  1368.             $deliveryLocationID = $request->request->getInt('deliveryLocationID');
  1369.             $deliveryLocation = null;
  1370.             $streetFindByParameters = [
  1371.                 'name' => $streetName,
  1372.                 'offerID' => $offerID,
  1373.             ];
  1375.             if (0 !== $deliveryLocationID) {
  1376.                 $deliveryLocation = $entityManager->find(DeliveryLocation::class, $deliveryLocationID);
  1377.                 $city = $deliveryLocation->getName();
  1378.                 $streetFindByParameters['city'] = $city;
  1379.             }
  1381.             $street = $entityManager->getRepository(Street::class)->findOneBy($streetFindByParameters);
  1383.             if (!$street) {
  1384.                 $street = new Street();
  1385.                 $street->setOfferID($offerID);
  1386.                 $street->setName($streetName);
  1387.                 $entityManager->persist($street);
  1388.                 if (null !== $deliveryLocation) {
  1389.                     $street->setDeliveryLocation($deliveryLocation);
  1390.                     $street->setCity($city);
  1391.                 }
  1392.             }
  1393.         }
  1395.         $address = new UserAddress();
  1396.         $address->setName($request->request->get('name'));
  1397.         $address->setStreet($street);
  1398.         $address->setHouse($request->request->get('house'));
  1399.         $address->setBlock($request->request->get('block'));
  1400.         $address->setAppartment($request->request->get('appartment'));
  1401.         $address->setEntrance($request->request->get('entrance'));
  1402.         $address->setFloor($request->request->get('floor'));
  1403.         $address->setDoorphone($request->request->get('doorphone'));
  1404.         $address->setOfferID($order->getOffer()->getID());
  1405.         $address->setActive(true);
  1406.         $address->setIsOnlineGift($request->request->getBoolean('isOnlineGift'));
  1407.         $address->setCompletedPurchase(false);
  1408.         $order->setDeliveryTime($request->request->get('deliveryTime'));
  1409.         $this->getUser()->addDeliveryAddress($address);
  1410.         $phone = $request->request->get('phone');
  1411.         if ($phone) {
  1412.             $address->setPhone($phone);
  1413.         }
  1414.         $order->setDeliveryAddress($address);
  1416.         if (!($iikoUtil instanceof Tokiny)) {
  1417.             $order->setPaymentType($request->request->getInt('paymentType', PaymentType::ONLINE));
  1418.         }
  1420.         $result = $this->getCheckAddressResponse($iikoUtil->checkOrder($entityManager, $order, $subscriptionService));
  1421.         if ($result['status'] === 'error') {
  1422.             return new JsonResponse([
  1423.                 'status' => $result['status'],
  1424.                 'message' => $result['message'],
  1425.             ], Response::HTTP_OK);
  1426.         }
  1428.         $entityManager->flush();
  1430.         $offerDeliveryZone = $order->getOffer()->getOfferDeliveryZone();
  1431.         if (null !== $offerDeliveryZone && $offerDeliveryZone->count() > 0) {
  1432.             $points = $address->getCoordinatesForDeliveryZone() ?? $coordinatesYandex->getGeoCoordinates(
  1433.                 $address->buildFullAddress(),
  1434.                 ['offerId' => (int)$order->getOffer()->getID()]
  1435.             );
  1437.             $deliveryZone = $deliveryZoneRepository->getPolygonByPoint($order->getOffer(), $points);
  1438.             if (null !== $deliveryZone) {
  1439.                 $result['deliveryPrice'] = 0;
  1441.                 $coordinates = explode(' ', $points);
  1442.                 $result['coordinates'] = new CoordinatesResponse(
  1443.                     $coordinates[1],
  1444.                     $coordinates[0],
  1445.                 );
  1447.                 if (null === $address->getCoordinatesForDeliveryZone()) {
  1448.                     $address->setLatitude($coordinates[1]);
  1449.                     $address->setLongitude($coordinates[0]);
  1450.                 }
  1451.             }
  1452.         }
  1454.         if (isset($result['deliveryPrice']) && 0 !== (int) $result['deliveryPrice']) {
  1455.             $order->setDeliveryCost($result['deliveryPrice']);
  1456.         }
  1457.         $result['deliveryPrice'] = $order->getDeliveryCost();
  1459.         $entityManager->flush();
  1461.         $view = CommonUtil::isMobileDevice($request) ? 'Slivki/mobile/delivery/address_block.html.twig' : 'Slivki/delivery/address_block.html.twig';
  1462.         $result['html']['address'] = $this->renderView($view, ['address' => $address, 'checked' => ' checked', 'offerID' => $offerID]);
  1464.         return new JsonResponse($result, Response::HTTP_OK);
  1465.     }
  1467.     /**
  1468.      * @Route("/profile/devivery/address/delete/{addressID}/{offerID}", name="deleteDeliveryAddress", methods={"GET"})
  1469.      */
  1470.     public function deleteAddressAction(UserAddressRepositoryInterface $userAddressRepository, int $addressID, int $offerID): JsonResponse
  1471.     {
  1472.         $userAddress = $userAddressRepository->getByUserIdAndAddressId($this->getUser()->getID(), $addressID);
  1474.         if ($userAddress instanceof UserAddress) {
  1475.             $userAddress->disable();
  1476.             $userAddressRepository->save($userAddress);
  1477.         }
  1479.         return new JsonResponse(
  1480.             ['countDeliveryAddresses' => \count($this->getUser()->getAvailableUserAddresses($offerID))],
  1481.             Response::HTTP_OK,
  1482.         );
  1483.     }
  1485.     /** @Route("/profile/crt/{offerOrderDetailsID}", name="profileGetCrtPdf") */
  1486.     public function profileGetCrtPdfAction($offerOrderDetailsID, KernelInterface $kernel, GiftCertificateService $giftCertificateService) {
  1487.         $entityManager = $this->getDoctrine()->getManager();
  1488.         $dql = "select offerOrderDetails from Slivki:OfferOrderDetails offerOrderDetails
  1489.             join offerOrderDetails.giftCertificate giftCertificate
  1490.             join offerOrderDetails.offerOrder offerOrder
  1491.             join offerOrder.offer offer
  1492.             where offerOrder.status > 0 and offerOrder.user = :user and offerOrderDetails.ID = :offerOrderDetailsID
  1493.         ";
  1494.         $offerOrderDetails = $entityManager->createQuery($dql)
  1495.             ->setParameter('user', $this->getUser())
  1496.             ->setParameter('offerOrderDetailsID', $offerOrderDetailsID)
  1497.             ->getOneOrNullResult();
  1498.         if (!$offerOrderDetails) {
  1499.             die;
  1500.             return new Response();
  1501.         }
  1502.         $giftCertificateService->getCertificatePdf($kernel, $offerOrderDetails);
  1503.         die;
  1504.     }
  1506.     /**
  1507.      * @Route("/profile/logout", name="app_logout", methods={"GET"})
  1508.      */
  1509.     public function logout() {
  1510.         // controller can be blank: it will never be executed!
  1511.         throw new \Exception('Don\'t forget to activate logout in security.yaml');
  1512.     }
  1514.     /**
  1515.      * @Route("/login/check-code/{code}", name="login_check_code")
  1516.      */
  1517.     public function checkCode(
  1518.         Request $request,
  1519.         SmsLimiterService $smsLimiterService,
  1520.         UserPhoneService $userPhoneService,
  1521.         $code
  1522.     )  {
  1523.         $session = $request->getSession();
  1524.         $logger = Logger::instance('PHONEAUTH');
  1525.         $logger->info($code);
  1526.         $logger->info($session->get('loginPhoneCode', 'empty'));
  1527.         if ((string)$session->get('loginPhoneCode', 'empty') != (string)$code) {
  1528.             $atemptsCount = $session->get('loginAtemptsCount', 0);
  1529.             if ($atemptsCount> 10) {
  1530.                 $session->remove('loginPhoneCode');
  1531.             } else {
  1532.                 $session->set('loginAtemptsCount', $atemptsCount++);
  1533.             }
  1534.             $logger->info('ERROR');
  1535.             return new JsonResponse(['error' => true, 'message' => 'Неверный код']);
  1536.         }
  1537.         $phoneNumber = $session->get('loginPhoneNumber');
  1538.         $entityManager = $this->getDoctrine()->getManager();
  1539.         $userPhone = $entityManager->getRepository(UserPhone::class)->findOneBy(['phoneNumber' => $phoneNumber, 'confirmed' => true]);
  1540.         $proposeAccountsMerge = false;
  1541.         if (!$userPhone) {
  1542.             $proposeAccountsMerge = true;
  1543.             $user = new User();
  1544.             $token = uniqid($user->getID(), true);
  1545.             $user->setToken($token);
  1546.             $user->setStatus(User::STATUS_CONFIRMED);
  1547.             $user->setDefaultPassword();
  1548.             $entityManager->persist($user);
  1550.             $userPhone = $userPhoneService->addUserPhone($user, $phoneNumber);
  1551.             $userPhoneService->confirmUserPhone($userPhone);
  1552.             $entityManager->flush();
  1553.         }
  1554.         /** @var User $user */
  1555.         $user = $userPhone->getUser();
  1556.         Logger::instance('DEBUG')->info($user->getPasswordEncoded());
  1557.         if ($user->getPasswordEncoded() == '' || $user->getPasswordEncoded() == null) {
  1558.             $user->encryptPassword('111');
  1559.             $entityManager->flush();
  1560.         }
  1561.         Logger::instance('DEBUG')->info($user->getPassword());
  1563.         $token = $user->getToken();
  1564.         if (!$token) {
  1565.             $token = uniqid($user->getID(), true);
  1566.             $user->setToken($token);
  1567.             $entityManager->flush();
  1568.         }
  1569.         Logger::instance('DEBUG')->info('token');
  1570.         Logger::instance('DEBUG')->info($token);
  1571.         $this->addFlash("openMergeProfilePopup", "true");
  1572.         $cookie = Cookie::create(self::USER_TOKEN_COOKIE, $token, time() + 315360000, '/', $this->getParameter('base_domain'));
  1573.         $response = new JsonResponse(['error' => false, 'proposeAccountsMerge' => $proposeAccountsMerge]);
  1574.         $response->headers->setCookie($cookie);
  1576.         if ($request->getClientIp() !== null) {
  1577.             $smsLimiterService->clearCache($request->getClientIp());
  1578.         }
  1580.         return $response;
  1581.     }
  1583.     /** @Route("/login/send-code-email") */
  1584.     public function sendCodeEmailAction(Request  $request, Mailer  $mailer) {
  1585.         $email = $request->request->get('email');
  1586.         if (!$email) {
  1587.             return new Response('', 500);
  1588.         }
  1589.         $code = rand(1111, 9999);
  1590.         $email = mb_strtolower($email);
  1591.         $entityManager = $this->getDoctrine()->getManager();
  1592.         $this->log($email);
  1593.         $currentUser = $user = $this->getUser();
  1594.         if ($user && $currentUser->getEmail()) {
  1595.             return new Response('', 500);
  1596.         }
  1597.         $alreadyMerged = $entityManager->getRepository(User::class)->findOneByEmail($email . "-merged");
  1598.         if ($alreadyMerged) {
  1599.             return new Response('', 500);
  1600.         }
  1601.         $session = $request->getSession();
  1602.         $session->set('mergeAcccountEmail', $email);
  1603.         $userConfirmation = new UserConfirmation();
  1604.         $userConfirmation->setEmail($email);
  1605.         $userConfirmation->setAuthCode($code);
  1606.         $entityManager->persist($userConfirmation);
  1607.         $entityManager->flush();
  1608.         $body = $this->renderView('Slivki/emails/mail.html.twig', ['content' => $code]);
  1609.         $message = $mailer->createMessage('Код для привязки аккаунта', $body, 'html');
  1610.         $message->setFrom('info@slivki.by', 'Slivki.by');
  1611.         $this->log($email);
  1612.         $message->setTo($email);
  1613.         $mailer->send($message);
  1615.         return new Response();
  1616.     }
  1618.     /**
  1619.      * @Route("/login/check-code-mail/{code}", name="user_login_check_code_mail")
  1620.      */
  1621.     public function checkEmailCodeAction(
  1622.         Request $request,
  1623.         Mailer $mailer,
  1624.         AccountMerger $mergeAccount,
  1625.         $code
  1626.     ) {
  1627.         $entityManager = $this->getDoctrine()->getManager();
  1628.         $session = $request->getSession();
  1629.         if ($request->getSession()->get('mergeAcccountEmail')) {
  1630.             $userConfirmation = $entityManager->getRepository(UserConfirmation::class)->findOneBy([
  1631.                 'authCode' => $code,
  1632.                 'email' => $request->getSession()->get('mergeAcccountEmail')
  1633.             ]);
  1634.             if ($userConfirmation) {
  1635.                 $userRepository = $this->getDoctrine()->getManager('admin')->getRepository(User::class);
  1636.                 $emailUser = $userRepository->findOneByEmail($userConfirmation->getEmail());
  1637.                 if (!$emailUser) {
  1638.                     $this->getUser()->setEmail($request->getSession()->get('mergeAcccountEmail'));
  1639.                     $entityManager->flush();
  1640.                 } else {
  1641.                     $mergeAccount->merge($this->getUser(), $emailUser);
  1642.                 }
  1643.                 $session->set('mergeAcccountEmail', null);
  1644.                 return new JsonResponse(['domain' => $this->getParameter('base_domain')]);
  1645.             }
  1646.         } else if ($request->getSession()->get('changeAcccountEmail')) {
  1647.             $email = $request->getSession()->get('changeAcccountEmail');
  1648.             $userConfirmation = $entityManager->getRepository(UserConfirmation::class)->findOneBy([
  1649.                 'authCode' => $code,
  1650.                 'email' => $email
  1651.             ]);
  1652.             if ($userConfirmation) {
  1653.                 $user = $this->getUser();
  1654.                 if (!$user) {
  1655.                     return new Response('', 404);
  1656.                 }
  1657.                 $oldEmail = $user->getEmail();
  1658.                 $userEmails = new UserEmailHistory();
  1659.                 $userEmails->setEmail($oldEmail);
  1660.                 $userEmails->setCreatedOn(new DateTime());
  1661.                 $userEmails->setUserID($user->getID());
  1662.                 $entityManager->persist($userEmails);
  1663.                 $user->setEmail($email);
  1664.                 $entityManager->flush();
  1665.                 $body = "Добрый день.<br>Уведомляем Вас о том, что почта вашего аккаунта на сайте Slivki.by изменена на $email.<br>С уважением, команда Slivki.by";
  1666.                 $message = $mailer->createMessage('Код для привязки аккаунта', $body, 'html');
  1667.                 $message->setFrom('info@slivki.by', 'Slivki.by');
  1668.                 $this->log($oldEmail);
  1669.                 $message->setTo($oldEmail);
  1670.                 $mailer->send($message);
  1671.                 $session->set('changeAcccountEmail', null);
  1673.                 return new Response('', 200);
  1674.             }
  1675.         }
  1677.         return new Response('', 404);
  1678.     }
  1680.     /** @Route("/change/send-code-email") */
  1681.     public function changeCodeEmailAction(Request  $request, Mailer  $mailer) {
  1682.         $email = $request->request->get('email');
  1683.         if (!$email) {
  1684.             return new Response('', 500);
  1685.         }
  1686.         $code = rand(1111, 9999);
  1687.         $email = mb_strtolower($email);
  1688.         $entityManager = $this->getDoctrine()->getManager();
  1689.         $user = $entityManager->getRepository(User::class)->findOneByEmail($email);
  1690.         $this->log($email);
  1691.         if ($user) {
  1692.             return new Response('', 500);
  1693.         }
  1694.         $session = $request->getSession();
  1695.         $session->set('changeAcccountEmail', $email);
  1696.         $userConfirmation = new UserConfirmation();
  1697.         $userConfirmation->setEmail($email);
  1698.         $userConfirmation->setAuthCode($code);
  1699.         $entityManager->persist($userConfirmation);
  1700.         $entityManager->flush();
  1701.         $body = $this->renderView('Slivki/emails/mail.html.twig', ['content' => $code]);
  1702.         $message = $mailer->createMessage('Код для привязки аккаунта', $body, 'html');
  1703.         $message->setFrom('info@slivki.by', 'Slivki.by');
  1704.         $this->log($email);
  1705.         $message->setTo($email);
  1706.         $mailer->send($message);
  1708.         return new Response();
  1709.     }
  1710. }