src/Controller/Website/LoginController.php line 47

Open in your IDE?
  1. <?php
  3. namespace EADPlataforma\Controller\Website;
  5. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Cache;
  6. use Symfony\Component\HttpFoundation\Request;
  7. use Symfony\Component\HttpFoundation\Cookie;
  8. use Symfony\Component\HttpFoundation\Response;
  9. use Symfony\Component\Routing\Annotation\Route;
  10. use EADPlataforma\Entity\User;
  11. use EADPlataforma\Entity\Session;
  12. use EADPlataforma\Entity\Cart;
  13. use EADPlataforma\Entity\Enrollment;
  14. use EADPlataforma\Entity\ConfigurationIp;
  15. use EADPlataforma\Enum\UserEnum;
  16. use EADPlataforma\Enum\ClientEnum;
  17. use EADPlataforma\Enum\SessionEnum;
  18. use EADPlataforma\Enum\ServicesEnum;
  19. use EADPlataforma\Enum\ConfigurationEnum;
  20. use EADPlataforma\Enum\ConfigurationIpEnum;
  21. use EADPlataforma\Enum\ErrorEnum;
  22. use EADPlataforma\Enum\WebhookQueueEnum;
  23. use EADPlataforma\Enum\WebhookEnum;
  24. use EADPlataforma\Enum\TagsMarketingEnum;
  26. /**
  27.  * @Route(
  28.  *      schemes         = {"http|https"}
  29.  * )
  30.  * @Cache(
  31.  *      maxage          = "0",
  32.  *      smaxage         = "0",
  33.  *      expires         = "now",
  34.  *      public          = false
  35.  * )
  36.  */
  37. class LoginController extends AbstractWebsiteController {
  39.     /**
  40.      * @Route(
  41.      *      path          = "/login/{hash}",
  42.      *      name          = "login",
  43.      *      methods       = {"GET"},
  44.      *      defaults      = { "hash": null }
  45.      * )
  46.      */
  47.     public function loginPage(Request $request) {
  49.         if($this->user){
  51.             $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  52.             $enrollmentNumber = $enrollmentRepository->countUserEnrollment(
  53.                 $this->user->getId()
  54.             );
  55.             
  56.             $platformType = $this->client->getPlatformType();
  58.             if(
  59.                 !empty($enrollmentNumber) || 
  60.                 $platformType == ClientEnum::PLATFORM_TYPE_RESTRICTED
  61.             ){
  62.                 return $this->redirectToRoute('resume');
  63.             }
  65.             return $this->redirectToRoute('home');
  66.         }
  68.         $this->data['hash'] = $request->get('hash');
  70.         if(!empty($this->generalService->getCookie('remember'))){
  71.             $this->data['remember'] = true;
  72.         }else{
  73.             $this->data['remember'] = false;
  74.         }
  76.         return $this->renderEAD('login/login.html.twig');
  77.     }
  79.     /**
  80.      * @Route(
  81.      *      path          = "/login/post",
  82.      *      name          = "loginPost",
  83.      *      methods       = {"POST"},
  84.      * )
  85.      */
  86.     public function loginPost(Request $request) {
  88.         $this->requestUtil->setRequest($request)->setData();
  90.         $email = $this->requestUtil->getField('email');
  91.         $password = $this->requestUtil->getField('password');
  92.         $remember = $this->requestUtil->getField('remember');
  93.         $hash = $this->requestUtil->getField('hash');
  95.         $fieldsEmpty = [];
  96.         if(empty($email)){
  97.             $fieldsEmpty[] = 'email';
  98.         }
  100.         if(empty($password)){
  101.             $fieldsEmpty[] = 'password';
  102.         }
  103.         
  104.         if(!empty($fieldsEmpty)){
  105.             return $this->eadResponse($fieldsEmpty, ErrorEnum::FIELD_EMPTY);
  106.         }
  108.         if($password){
  109.             $password = md5($password);
  110.         }
  112.         $domain = explode('@', $email);
  113.         $domain = end($domain);
  115.         $info = $this->generalService->getServiceAccess(ServicesEnum::LOGIN);
  117.         $user = null;
  118.         $isAdmin = false;
  119.         $userRepository = $this->em->getRepository(User::class);
  121.         if(in_array($domain, $info->domains)){
  122.             /*if(
  123.                 in_array($request->getClientIp(), $info->validIps) ||
  124.                 in_array($email, $info->masterEmails)
  125.             ){*/
  127.                 $userInfo = $this->generalService->getUserFromEADAdmin(
  128.                     $email,
  129.                     $this->clientConfig->getId()
  130.                 );
  132.                 if (isset($userInfo['usuario_id']) && $password == $userInfo['senha']){
  133.                     $isAdmin = true;
  134.                     $user = $userRepository->findOneBy([
  135.                         "email" => $info->emailUser
  136.                     ]);
  137.                 }
  138.             //}
  139.         }else{
  140.             if($this->configuration->checkModuleIsAbleOnPlan('ipFunction')){
  141.                 $configurationIpRepository = $this->em->getRepository(ConfigurationIp::class);
  142.                 $configurationIp = $configurationIpRepository->findOneBy([
  143.                     "ip" => $request->getClientIp(),
  144.                     "deleted" => ConfigurationIpEnum::ITEM_NO_DELETED 
  145.                 ]);
  147.                 $countWhitelist = $configurationIpRepository->count([
  148.                     "type" => ConfigurationIpEnum::WHITE_LIST,
  149.                     "deleted" => ConfigurationIpEnum::ITEM_NO_DELETED 
  150.                 ]);;
  152.                 if($configurationIp){
  153.                     if($configurationIp->getType() == ConfigurationIpEnum::BLACK_LIST){
  154.                         return $this->eadResponse([ 
  155.                             "message" => $this->configuration->getLanguage('login_invalid', 'login')
  156.                         ], ErrorEnum::ACTION_INVALID);
  157.                     }
  158.                 }elseif(!empty($countWhitelist)){
  159.                     return $this->eadResponse([ 
  160.                         "message" => $this->configuration->getLanguage('login_invalid', 'login')
  161.                     ], ErrorEnum::ACTION_INVALID);
  162.                 }
  163.             }
  165.             $user = $userRepository->findOneBy([
  166.                 "email" => $email,
  167.                 "deleted" => UserEnum::ITEM_NO_DELETED 
  168.             ]);
  169.         }
  171.         if(!$user){
  172.             return $this->eadResponse([ 
  173.                 "message" => $this->configuration->getLanguage('login_invalid', 'login')
  174.             ], ErrorEnum::ACTION_INVALID);
  175.         }
  177.         if(!$isAdmin){
  178.             if($user->getPassword() != $password){
  179.                 return $this->eadResponse([ 
  180.                     "message" => $this->configuration->getLanguage('login_invalid', 'login') 
  181.                 ], ErrorEnum::ACTION_INVALID);
  182.             }
  184.             if($user->getStatus() == UserEnum::WAITING){
  185.                 return $this->eadResponse([ 
  186.                     "message" => $this->configuration->getLanguage('login_invalid', 'login')
  187.                 ], ErrorEnum::ACTION_INVALID);
  188.             }
  190.             if($user->getStatus() == UserEnum::BLOCK){
  191.                 return $this->eadResponse([ 
  192.                     "message" => $this->configuration->getLanguage('login_invalid', 'login')
  193.                 ], ErrorEnum::ACTION_INVALID);
  194.             }
  195.         }
  197.         $this->userPermissionUtil->setUser($user);
  199.         $platformStatus = $this->clientConfig->getPlatformStatus();
  200.         if($platformStatus == ClientEnum::PLATFORM_STATUS_FREEZED){
  201.             if(!$this->userPermissionUtil->canAccessAdm()){
  202.                 return $this->eadResponse([ 
  203.                     "message" => $this->configuration->getLanguage('login_invalid', 'login')
  204.                 ], ErrorEnum::ACTION_INVALID);
  205.             }
  206.         }
  208.         if($user->getAuthenticationAllow()){
  209.             return $this->eadResponse([ 
  210.                 "userId" => $user->getId(),
  211.                 "authenticationActivated" => $user->getAuthenticationAllow(),
  212.             ]);
  213.         }
  215.         $sessionOn = $this->em->getRepository(Session::class)->findOneBy([ 
  216.             "user" => $user->getId(),
  217.             "deleted" => UserEnum::ITEM_NO_DELETED
  218.         ]);
  220.         $session = new Session();
  222.         $ipApi = $this->generalService->getService('IpApiService');
  223.         $ipApi->setRequest($request);
  225.         $session->setUser($user);
  226.         $session->setIp($ipApi->getIp());
  227.         $session->setIspName($ipApi->getIsp());
  228.         $session->setCoordinate($ipApi->getCoordinate());
  229.         $session->setTimeZone($ipApi->getTimeZone());
  230.         $session->setCity($ipApi->getCity());
  231.         $session->setState($ipApi->getState());
  232.         $session->setCountry($ipApi->getCountry());
  233.     
  234.         if($remember == 'true'){
  235.             $session->setDateExpire(date('Y-m-d H:i:s', strtotime(' + 30 day ')));
  236.         }
  238.         if($this->userPermissionUtil->canAccessAdm()){
  239.             $session->setIsAdmin(SessionEnum::YES);
  240.         }else{
  241.             if($sessionOn){
  242.                 $sessionOn->delete();
  243.                 $this->generalService->logoffWS(
  244.                     $sessionOn,
  245.                     $this->clientConfig->getId()
  246.                 );
  247.             }
  248.         }
  250.         $errors = $this->validateEntity($session);
  251.         if($errors){
  252.             return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
  253.         }
  255.         $this->em->persist($session);
  256.         $this->em->flush();
  258.         $crmService = $this->generalService->getService('CRM\\CrmService');
  259.         $crmService->savePerson($user);
  261.         $urlRedirectCart = $this->requestUtil->getField('url');
  262.         $emptyCart = $this->em->getRepository(Cart::class)->updateCartHashToUser($user);
  264.         $time = 'Session';
  265.        
  266.         if($remember == 'true'){
  267.             $time = null;
  269.             $time = time() + (24 * 60 * 60) * 30;
  270.             $this->generalService->setCookie('remember', SessionEnum::YES);
  271.         }else{
  272.             $this->generalService->deleteCookie('remember');
  273.         }
  275.         $this->generalService->setCookie('sessiontoken', $session->getToken(), $time);
  277.         $url = ( $hash ? base64_decode($hash) : null );
  279.         if(!empty($urlRedirectCart)){
  280.             $url = $urlRedirectCart;
  281.         }
  283.         if($emptyCart && (empty($url) || stristr($url,'/cart'))){
  284.             $url = null;
  285.         }
  287.         return $this->eadResponse([ 
  288.             "token" => $session->getToken(), 
  289.             "userId" => $user->getId(),
  290.             "url" => $url,
  291.             "emptyCart" => $emptyCart
  292.         ]);
  293.     }
  295.     /**
  296.      * @Route(
  297.      *      path          = "/login/authentication",
  298.      *      name          = "loginAuthentication",
  299.      *      methods       = {"POST"},
  300.      * )
  301.      */
  302.     public function loginAuthentication(Request $request) {
  304.         $this->requestUtil->setRequest($request)->setData();
  306.         $userId = $this->requestUtil->getField('userId');
  307.         $userRepository = $this->em->getRepository(User::class);
  308.         $user = $userRepository->findOneBy([
  309.             "id" => $userId,
  310.             "deleted" => UserEnum::ITEM_NO_DELETED 
  311.         ]);
  313.         if(!$user){
  314.             return $this->eadResponse([ 
  315.                 "message" => $this->configuration->getLanguage('user_not_found', 'login') 
  316.             ], ErrorEnum::ACTION_INVALID);
  317.         }
  319.         if($user->getAuthenticationAllow()){
  320.             $code = $this->requestUtil->getField('code');
  322.             $userRepository = $this->em->getRepository(User::class);
  323.             $data = $userRepository->getCheckAuthentication($user, $code);
  325.             if(!$data['checkCodeApp'] && !$data['checkCodeEmail']){
  326.                 return $this->eadResponse([ 
  327.                     "message" => $this->configuration->getLanguage('authentication_invalid', 'login')
  328.                 ], ErrorEnum::AUTH_INVALID);
  329.             }
  331.             $hash = $this->requestUtil->getField('hash');
  332.             $remember = $this->requestUtil->getField('remember');
  334.             $sessionOn = $this->em->getRepository(Session::class)->findOneBy([ 
  335.                 "user" => $user->getId(),
  336.                 "deleted" => UserEnum::ITEM_NO_DELETED
  337.             ]);
  338.     
  339.             $session = new Session();
  340.     
  341.             $ipApi = $this->generalService->getService('IpApiService');
  342.             $ipApi->setRequest($request);
  343.     
  344.             $session->setUser($user);
  345.             $session->setIp($ipApi->getIp());
  346.             $session->setIspName($ipApi->getIsp());
  347.             $session->setCoordinate($ipApi->getCoordinate());
  348.             $session->setTimeZone($ipApi->getTimeZone());
  349.             $session->setCity($ipApi->getCity());
  350.             $session->setState($ipApi->getState());
  351.             $session->setCountry($ipApi->getCountry());
  352.         
  353.             if($remember == 'true'){
  354.                 $session->setDateExpire(date('Y-m-d H:i:s', strtotime(' + 30 day ')));
  355.             }
  356.     
  357.             if($this->userPermissionUtil->canAccessAdm()){
  358.                 $session->setIsAdmin(SessionEnum::YES);
  359.             }else{
  360.                 if($sessionOn){
  361.                     $sessionOn->delete();
  362.                     $this->generalService->logoffWS(
  363.                         $sessionOn,
  364.                         $this->clientConfig->getId()
  365.                     );
  366.                 }
  367.             }
  368.     
  369.             $errors = $this->validateEntity($session);
  370.             if($errors){
  371.                 return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
  372.             }
  373.     
  374.             $this->em->persist($session);
  375.             $this->em->flush();
  376.     
  377.             $crmService = $this->generalService->getService('CRM\\CrmService');
  378.             $crmService->savePerson($user);
  379.     
  380.             $urlRedirectCart = $this->requestUtil->getField('url');
  381.             $emptyCart = $this->em->getRepository(Cart::class)->updateCartHashToUser($user);
  382.     
  383.             $time = 'Session';
  384.            
  385.             if($remember == 'true'){
  386.                 $time = null;
  387.     
  388.                 $time = time() + (24 * 60 * 60) * 30;
  389.                 $this->generalService->setCookie('remember', SessionEnum::YES);
  390.             }else{
  391.                 $this->generalService->deleteCookie('remember');
  392.             }
  393.     
  394.             $this->generalService->setCookie('sessiontoken', $session->getToken(), $time);
  395.     
  396.             $url = ( $hash ? base64_decode($hash) : null );
  397.     
  398.             if(!empty($urlRedirectCart)){
  399.                 $url = $urlRedirectCart;
  400.             }
  401.     
  402.             if($emptyCart && (empty($url) || stristr($url,'/cart'))){
  403.                 $url = null;
  404.             }
  405.     
  406.             return $this->eadResponse([ 
  407.                 "token" => $session->getToken(), 
  408.                 "userId" => $user->getId(),
  409.                 "url" => $url,
  410.                 "emptyCart" => $emptyCart
  411.             ]);
  412.         }
  414.         return $this->redirectToRoute('notFound');
  415.     }
  417.     /**
  418.      * @Route(
  419.      *      path          = "/send/authentication/email/{id}",
  420.      *      name          = "sendAuthenticationEmail",
  421.      *      methods       = {"PUT"},
  422.      *      requirements  = { "id" = "\d+" }
  423.      * )
  424.      */
  425.     public function sendAuthenticationEmail(Request $request) {
  427.         $emailService = $this->generalService->getService('EmailService');
  429.         $userId = $request->get('id');
  430.         $userRepository = $this->em->getRepository(User::class);
  431.         $user = $userRepository->findOneBy([
  432.             "id" => $userId,
  433.             "deleted" => UserEnum::ITEM_NO_DELETED 
  434.         ]);
  436.         if(!$user){
  437.             return $this->eadResponse([ 
  438.                 "message" => $this->configuration->getLanguage('user_not_found', 'login') 
  439.             ], ErrorEnum::ACTION_INVALID);
  440.         }
  441.         
  442.         if($emailService->checkUserToSend($user)){
  444.             $generateCode = $this->stringUtil->randomText(6);
  446.             $emailService->setToEmail($user->getEmail());
  447.             $emailService->setToName($user->getName());
  449.             $subText = $this->configuration->getLanguage('login_authentication.subject', 'email');
  450.             $subject = "{$subText} - {$this->client->getBrand()}";
  451.             $emailService->setSubject($subject);
  452.             
  453.             $domain = $this->client->getDomainPrimary();
  454.             $emailService->setData([
  455.                 "userName" => $user->getName(),
  456.                 "code" => $generateCode
  457.             ]);
  459.             $emailService->setTemplateBody("login_authentication");
  460.             $send = $emailService->send();
  462.             $dateExpireAuthentication = date('Y-m-d H:i:s', strtotime(' + 5 minute '));
  464.             $user->setAuthenticationCodeEmail($generateCode);
  465.             $user->setAuthenticationEmailDateExpire($dateExpireAuthentication);
  466.             
  467.             $errors = $this->validateEntity($user);
  468.             if($errors){
  469.                 return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
  470.             }
  472.             $this->em->flush();
  474.             return $this->eadResponse([ "success" => 1 ]);
  475.         }
  477.         return $this->eadResponse([ 
  478.             "message" => $this->configuration->getLanguage('authentication_email_not_found', 'login') 
  479.         ], ErrorEnum::ACTION_INVALID);
  480.     }
  482.     /**
  483.      * @Route(
  484.      *      path          = "/confirm/{hash}",
  485.      *      name          = "loginConfirm",
  486.      *      methods       = {"GET"},
  487.      *      requirements  = { "hash" = "([a-zA-Z0-9_-]+)" }
  488.      * )
  489.      */
  490.     public function loginConfirm(Request $request) {
  491.         if($this->user){
  492.             
  493.             $sessionOn = $this->user->getSession();
  494.             $sessionOn->delete();
  495.             $this->configuration->getSessionSym()->set('session', null);
  497.             $this->em->flush();
  499.             $this->generalService->deleteCookie('remember');
  500.             $this->generalService->deleteCookie('sessiontoken');
  501.             $this->generalService->logoffWS(
  502.                 $sessionOn,
  503.                 $this->clientConfig->getId()
  504.             );
  505.         }
  507.         $this->requestUtil->setRequest($request)->setData();
  509.         $hash = $request->get('hash');
  511.         $user = $this->em->getRepository(User::class)->findOneBy([ 
  512.             "hashIdentify" => $hash,
  513.             "deleted" => UserEnum::ITEM_NO_DELETED
  514.         ]);
  516.         $this->data["hash"] = base64_encode($this->domain);
  517.         $this->data['remember'] = $this->generalService->getCookie('remember');
  518.          
  519.         if(!$user){
  520.             $this->data["confirmMsg"] = $this->configuration->getLanguage(
  521.                 'user_not_found', 'login'
  522.             );
  523.             $this->data["confirmStatus"] = UserEnum::NO;
  524.         
  525.             return $this->renderEAD('login/login.html.twig');
  526.         }
  528.         if($user->getStatus() != UserEnum::WAITING){
  529.             $this->data["confirmMsg"] = $this->configuration->getLanguage(
  530.                 'invalid_action', 'login'
  531.             );
  532.             $this->data["confirmStatus"] = UserEnum::NO;
  534.             return $this->renderEAD('login/login.html.twig');
  535.         }
  537.         $user->setStatus(UserEnum::ACTIVE);
  538.         $user->setConfirmationDate(date('Y-m-d H:i:s'));
  539.         $user->setValidEmail(UserEnum::DELIVERABLE);
  541.         $pixelService = $this->generalService->getService('Marketing\\PixelService');
  542.         $pixelService->sendConversion('CompleteRegistration');
  544.         $marketingService = $this->generalService->getService('Marketing\\MarketingService');
  546.         $marketingService->setTag(TagsMarketingEnum::TAG_CONFIRM_REGISTER);
  547.         $marketingService->setUser($user);
  548.         $marketingService->send();
  550.         $this->em->flush();
  552.         $dataObj= (object)[
  553.             "user" => (object)[        
  554.                 "id" => (string)$user->getId(),
  555.                 "name" => $user->getName(),
  556.                 "email" => $user->getEmail(),
  557.                 "phone" => $user->getPhone(),
  558.                 "status" => $user->getStatus(),
  559.                 "dates" => (object)[
  560.                     "signup" => $user->getDateRegister(),
  561.                     "confirmation" => $user->getConfirmationDate(),
  562.                 ],
  563.             ], 
  564.         ];
  565.         $webhookService = $this->generalService->getService('WebhookService');
  566.         $webhookService->addItemList(WebhookEnum::USER, $dataObj);
  568.         $this->data["confirmMsg"] = $this->configuration->getLanguage(
  569.             'user_confirmed', 
  570.             'login'
  571.         );
  572.         $this->data["confirmStatus"] = UserEnum::YES;
  573.         
  574.         return $this->renderEAD('login/login.html.twig');
  575.     }
  577.     /**
  578.      * @Route(
  579.      *      path          = "/stopEmail/{hash}",
  580.      *      name          = "stopEmail",
  581.      *      methods       = {"GET"},
  582.      *      requirements  = { "hash" = "([a-zA-Z0-9_-]+)" }
  583.      * )
  584.      */
  585.     public function stopEmail(Request $request) {
  587.         $this->requestUtil->setRequest($request)->setData();
  589.         $hash = $request->get('hash');
  590.         
  591.         $user = $this->em->getRepository(User::class)->findOneBy([ 
  592.             "hashIdentify" => $hash,
  593.             "deleted" => UserEnum::ITEM_NO_DELETED
  594.         ]);
  595.        
  596.         if(!$user){
  597.             $this->data["confirmMsg"] = $this->configuration->getLanguage('user_not_found', 'login');
  598.             $this->data["confirmStatus"] = UserEnum::NO;
  599.             $this->data["hash"] = null;
  600.         
  601.             return $this->renderEAD('login/login.html.twig');
  602.         }
  604.         $this->data["hash"] = $hash;
  606.         $sessionOn = $user->getSession();
  607.         if($sessionOn){
  608.             $sessionOn->delete();
  609.             $this->configuration->getSessionSym()->set('session', null);
  611.             $this->em->flush();
  613.             $this->generalService->deleteCookie('remember');
  614.             $this->generalService->deleteCookie('sessiontoken');
  615.             $this->generalService->logoffWS(
  616.                 $sessionOn,
  617.                 $this->clientConfig->getId()
  618.             );
  619.         }
  620.         
  621.         $user->delete();
  622.         $this->em->flush();
  623.         
  624.         $this->data["confirmMsg"] = $this->configuration->getLanguage('user_deleted', 'login');
  625.         $this->data["confirmStatus"] = UserEnum::YES;
  627.         return $this->renderEAD('login/login.html.twig');
  628.     }
  630.     /**
  631.      * @Route(
  632.      *      path          = "/stopNotification/{hash}",
  633.      *      name          = "stopNotification",
  634.      *      methods       = {"GET"},
  635.      *      requirements  = { "hash" = "([a-zA-Z0-9_-]+)" }
  636.      * )
  637.      */
  638.     public function stopNotification(Request $request) {
  640.         $this->requestUtil->setRequest($request)->setData();
  642.         $hash = $request->get('hash');
  643.         $user = $this->em->getRepository(User::class)->findOneBy([ 
  644.             "hashIdentify" => $hash,
  645.             "deleted" => UserEnum::ITEM_NO_DELETED
  646.         ]);
  647.         
  648.         if(!$user){
  649.             $this->data["confirmMsg"] = $this->configuration->getLanguage(
  650.                 'user_not_found', 'login'
  651.             );
  652.             
  653.             $this->data["hash"] = null;
  654.         
  655.             return $this->renderEAD('login/login.html.twig');
  656.         }
  657.         
  658.         $this->data['user'] = $user;
  660.         return $this->renderEAD('login/stop-notification.html.twig');
  661.     }
  663.     /**
  664.      * @Route(
  665.      *      path          = "user/notification/{hash}",
  666.      *      name          = "updateUserNotification",
  667.      *      methods       = {"PUT"},
  668.      *      requirements  = { "hash" = "([a-zA-Z0-9_-]+)" }
  669.      * )
  670.      */
  671.     public function updateUserNotification(Request $request) {
  673.         $this->requestUtil->setRequest($request)->setData();
  675.         $hash = $request->get('hash');
  676.         $user = $this->em->getRepository(User::class)->findOneBy([ 
  677.             "hashIdentify" => $hash,
  678.             "deleted" => UserEnum::ITEM_NO_DELETED
  679.         ]);
  681.         $data = [];
  682.         
  683.         if(!$user){
  684.             $this->data["confirmMsg"] = $this->configuration->getLanguage(
  685.                 'user_not_found', 
  686.                 'login'
  687.             );
  688.             $this->data["hash"] = null;
  689.         
  690.             return $this->renderEAD('login/login.html.twig');
  691.         }
  693.         if($this->requestUtil->issetField('allowNotifyNewLesson')){
  694.             $user->setAllowNotifyNewLesson(
  695.                 $this->requestUtil->getField('allowNotifyNewLesson')
  696.             );
  697.         }
  699.         if($this->requestUtil->issetField('allowNotifyNewExam')){
  700.             $user->setAllowNotifyNewExam(
  701.                 $this->requestUtil->getField('allowNotifyNewExam')
  702.             );
  703.         }
  705.         if($this->requestUtil->issetField('allowNotifyNewSupportMessage')){
  706.             $user->setAllowNotifyNewSupportMessage(
  707.                 $this->requestUtil->getField('allowNotifyNewSupportMessage')
  708.             );
  709.         }
  711.         if($this->requestUtil->issetField('allowNotifyNewSupportAnswer')){
  712.             $user->setAllowNotifyNewSupportAnswer(
  713.                 $this->requestUtil->getField('allowNotifyNewSupportAnswer')
  714.             );
  715.         }
  717.         if($this->requestUtil->issetField('allowNotifyNewMessage')){
  718.             $user->setAllowNotifyNewMessage(
  719.                 $this->requestUtil->getField('allowNotifyNewMessage')
  720.             );
  721.         }
  723.         if($this->requestUtil->issetField('allowNotifyNewGroupMessage')){
  724.             $user->setAllowNotifyNewGroupMessage(
  725.                 $this->requestUtil->getField('allowNotifyNewGroupMessage')
  726.             );
  727.         }
  729.         if($this->requestUtil->issetField('allowNotifyCart')){
  730.             $user->setAllowNotifyCart($this->requestUtil->getField('allowNotifyCart'));
  731.         }
  733.         $this->em->flush();
  735.         $data = $user->toReturn();
  736.         $this->userLogService->logUpdate("user", $user->getId(), $data);
  738.         return $this->eadResponse([ "message" => "Success" ]);
  739.     }
  741.     /**
  742.      * @Route(
  743.      *      path          = "/login/fast/{pass}",
  744.      *      name          = "loginFast",
  745.      *      methods       = {"GET"}
  746.      * )
  747.     */
  748.     public function loginFast(Request $request) {
  749.        
  750.         $this->requestUtil->setRequest($request)->setData();
  752.         $session = new Session();
  754.         $pass = $request->get('pass');
  755.         $pass = $this->stringUtil->decryptArray($pass);
  756.         
  757.         if(empty($pass)){
  758.             return $this->redirectToRoute('notFound');
  759.         }
  760.         
  761.         $userId = $pass['userId'];
  762.         $time = $pass['time'];
  763.         $urlRedirect = null;
  764.             
  765.         if(!empty($pass['urlRedirect'])){
  766.             $urlRedirect = $pass['urlRedirect'];
  767.         }
  769.         $urlRedirectCart = $this->requestUtil->getField('url');
  770.         if(!empty($urlRedirectCart)){
  771.             $urlRedirect = $urlRedirectCart;
  772.         }
  773.         
  774.         $user = $this->em->getRepository(User::class)->findOneBy([
  775.             "id" => $userId,
  776.             "deleted" => UserEnum::ITEM_NO_DELETED ,
  777.         ]);
  778.            
  779.         if(!$user){
  780.             return $this->redirectToRoute('notFound');
  781.         }
  782.         
  783.         if($user->getStatus() == UserEnum::BLOCK){
  784.             return $this->redirectToRoute('notFound');
  785.         }
  787.         $this->userPermissionUtil->setUser($user);
  788.         
  789.         $platformStatus = $this->clientConfig->getPlatformStatus();
  790.         if($platformStatus == ClientEnum::PLATFORM_STATUS_FREEZED){
  791.             if(!$this->userPermissionUtil->canAccessAdm()){
  792.                 return $this->redirectToRoute('notFound');
  793.             }
  794.         }
  796.         $ipApi = $this->generalService->getService('IpApiService');
  797.         
  798.         $ipApi->setRequest($request);
  800.         $session->setUser($user);
  801.         $session->setIp($ipApi->getIp());
  802.         $session->setIspName($ipApi->getIsp());
  803.         $session->setCoordinate($ipApi->getCoordinate());
  804.         $session->setTimeZone($ipApi->getTimeZone());
  805.         $session->setCity($ipApi->getCity());
  806.         $session->setState($ipApi->getState());
  807.         $session->setCountry($ipApi->getCountry());
  809.         $sessionOn = $this->em->getRepository(Session::class)->findOneBy([ 
  810.             "user" => $user->getId(),
  811.             "deleted" => UserEnum::ITEM_NO_DELETED
  812.         ]);
  814.         if($user->getType() != UserEnum::STUDENT){
  815.             $session->setIsAdmin(SessionEnum::YES);
  816.         }else{
  817.             if($sessionOn){
  818.                 $sessionOn->delete();
  819.                 $this->generalService->logoffWS(
  820.                     $sessionOn,
  821.                     $this->clientConfig->getId()
  822.                 );
  823.             }
  824.         }
  826.         $errors = $this->validateEntity($session);
  827.         if($errors){
  828.             return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
  829.         }
  831.         $this->em->persist($session);
  832.         $this->em->flush();
  834.         $crmService = $this->generalService->getService('CRM\\CrmService');
  835.         $crmService->savePerson($user);
  837.         $emptyCart = $this->em->getRepository(Cart::class)->updateCartHashToUser($user);
  839.         $time = 'Session';
  841.         $this->generalService->setCookie('sessiontoken', $session->getToken(), $time);
  843.         if(is_null($urlRedirect)){
  844.             return $this->redirectToRoute('resume');
  845.         }
  847.         if(
  848.             $emptyCart &&
  849.             (empty($urlRedirect) || stristr($urlRedirect,'/cart'))
  850.             && !stristr($urlRedirect,'/indvidual')
  851.         ){
  852.             return $this->redirectToRoute('resume');
  853.         }
  854.         
  855.         return $this->redirect($urlRedirect, 301);
  856.     }
  858.     /**
  859.      * @Route(
  860.      *      path          = "/login/api/{pass}",
  861.      *      name          = "loginApi",
  862.      *      methods       = {"GET"}
  863.      * )
  864.     */
  865.     public function loginApi(Request $request) {
  866.        
  867.         $this->requestUtil->setRequest($request)->setData();
  869.         $ipApi = $this->generalService->getService('IpApiService');
  870.         $session = new Session();
  872.         $pass = $request->get('pass');
  873.         $pass = $this->stringUtil->decryptArray($pass);
  874.         
  875.         if(empty($pass)){
  876.             return $this->eadResponse([ 
  877.                 "message" => $this->configuration->getLanguage('login_invalid', 'login')
  878.             ], ErrorEnum::ACTION_INVALID);
  879.         }
  880.         
  881.         $userId = $pass['userId'];
  882.         $time = $pass['time'];
  883.         $urlRedirect = null;
  884.         
  885.         if(!empty($pass['urlRedirect'])){
  886.             $urlRedirect = $pass['urlRedirect'];
  887.         }
  888.         
  889.         $user = $this->em->getRepository(User::class)->findOneBy([
  890.             "id" => $userId,
  891.             "status" => UserEnum::ACTIVE,
  892.             "deleted" => UserEnum::ITEM_NO_DELETED 
  893.         ]);
  894.            
  895.         if(!$user){
  896.             return $this->eadResponse([ 
  897.                 "message" => $this->configuration->getLanguage('login_invalid', 'login') 
  898.             ], ErrorEnum::ACTION_INVALID);
  899.         }
  901.         if($user->getStatus() == UserEnum::BLOCK){
  902.             return $this->eadResponse([ 
  903.                 "message" => $this->configuration->getLanguage('login_invalid', 'login') 
  904.             ], ErrorEnum::ACTION_INVALID);
  905.         }
  907.         $platformStatus = $this->clientConfig->getPlatformStatus();
  908.         if($platformStatus == ClientEnum::PLATFORM_STATUS_FREEZED){
  909.             if(!$this->userPermissionUtil->canAccessAdm()){
  910.                 return $this->eadResponse([ 
  911.                     "message" => $this->configuration->getLanguage('login_invalid', 'login') 
  912.                 ], ErrorEnum::ACTION_INVALID);
  913.             }
  914.         }
  916.         $ipApi->setRequest($request);
  918.         $session->setUser($user);
  919.         $session->setIp($ipApi->getIp());
  920.         $session->setIspName($ipApi->getIsp());
  921.         $session->setCoordinate($ipApi->getCoordinate());
  922.         $session->setTimeZone($ipApi->getTimeZone());
  923.         $session->setCity($ipApi->getCity());
  924.         $session->setState($ipApi->getState());
  925.         $session->setCountry($ipApi->getCountry());
  927.         $sessionOn = $this->em->getRepository(Session::class)->findOneBy([ 
  928.             "user" => $user->getId(),
  929.             "deleted" => UserEnum::ITEM_NO_DELETED
  930.         ]);
  932.         if($user->getType() != UserEnum::STUDENT){
  933.             $session->setIsAdmin(SessionEnum::YES);
  934.         }else{
  935.             if($sessionOn){
  936.                 $sessionOn->delete();
  937.                 $this->generalService->logoffWS(
  938.                     $sessionOn,
  939.                     $this->clientConfig->getId()
  940.                 );
  941.             }
  942.         }
  944.         $errors = $this->validateEntity($session);
  945.         if($errors){
  946.             return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
  947.         }
  949.         $this->em->persist($session);
  950.         $this->em->flush();
  952.         $this->generalService->setCookie('sessiontoken', $session->getToken());
  954.         if(is_null($urlRedirect)){
  955.             return $this->redirectToRoute('resume');
  956.         }
  957.     
  958.         return $this->redirect($urlRedirect, 301);
  959.     }
  961.     /**
  962.      * @Route(
  963.      *      path          = "/recover/password",
  964.      *      name          = "recoverPassword",
  965.      *      methods       = {"POST"},
  966.      * )
  967.      */
  968.     public function recoverPassword(Request $request) {
  969.         $this->requestUtil->setRequest($request)->setData();
  970.         
  971.         $email = $this->requestUtil->getField('email');
  972.        
  973.         $user = $this->em->getRepository(User::class)->findOneBy([ 
  974.             "email" => $email,
  975.             "deleted" => UserEnum::ITEM_NO_DELETED
  976.         ]);
  977.         
  978.         if(!$user){
  979.             return $this->eadResponse([
  980.                 "message" => "Success"
  981.             ]);
  982.         }
  984.         $emailService = $this->generalService->getService('EmailService');
  986.         $hashData = [
  987.             "today" => date('Ymd'),
  988.             "userId" => $user->getId()
  989.         ];
  991.         $hash = $this->stringUtil->encodeHex(base64_encode(json_encode($hashData)));
  993.         $domain = $this->client->getDomainPrimary();
  994.         if(
  995.             $emailService->checkUserToSend($user) ||
  996.             $this->configuration->get("allow_send_email_user") == UserEnum::YES
  997.         ){
  998.             $emailService->setToEmail($user->getEmail());
  999.             $emailService->setToName($user->getName());
  1001.             $subText = $this->configuration->getLanguage('recover_password.subject', 'email');
  1002.             $subject = "{$subText} - {$this->client->getBrand()}";
  1003.             $emailService->setSubject($subject);
  1004.             
  1005.             $emailService->setData([
  1006.                 "userName" => $user->getName(),
  1007.                 "btnLink" => "https://{$domain}/change/password/{$hash}"
  1008.             ]);
  1010.             $emailService->setTemplateBody("recover_password");
  1011.             $emailService->send();
  1012.         }
  1014.         return $this->eadResponse([ "message" => "Success" ]);
  1015.     }
  1017.     /**
  1018.      * @Route(
  1019.      *      path          = "/change/password/{hash}",
  1020.      *      name          = "changePasswordPost",
  1021.      *      methods       = {"GET"},
  1022.      *      requirements  = { "hash" = "([a-zA-Z0-9_-]+)" }
  1023.      * )
  1024.     */
  1025.     public function changePassword(Request $request) {
  1026.         $hash = $request->get("hash");
  1027.         $hashData = json_decode(base64_decode($this->stringUtil->decodeHex($hash)));
  1029.         $this->data['hash'] = $hash;
  1030.         $this->data['remember'] = $this->generalService->getCookie('remember');
  1032.         if($hashData->today != date("Ymd")){
  1033.             $this->data["confirmMsg"] = $this->configuration->getLanguage('invalid_hash', 'login');
  1034.             $this->data["confirmStatus"] = UserEnum::NO;
  1035.         
  1036.             return $this->renderEAD('login/login.html.twig');
  1037.         }
  1038.         
  1039.         return $this->renderEAD('login/recover-password.html.twig');
  1040.     }
  1042.     /**
  1043.      * @Route(
  1044.      *      path          = "/reset/password",
  1045.      *      name          = "resetPasswordPost",
  1046.      *      methods       = {"POST"}
  1047.      * )
  1048.      */
  1049.     public function resetPasswordPost(Request $request) {
  1050.         $this->requestUtil->setRequest($request)->setData();
  1052.         $hash = $this->requestUtil->getField("hash");
  1053.         $hashData = json_decode(base64_decode($this->stringUtil->decodeHex($hash)));
  1055.         
  1056.         if($hashData->today != date("Ymd")){
  1057.             return $this->eadResponse([ 
  1058.                 "message" => $this->configuration->getLanguage('invalid_hash', 'login') 
  1059.             ], ErrorEnum::ACTION_INVALID);
  1060.         }
  1062.         $user = $this->em->getRepository(User::class)->findOneBy([
  1063.             "id" => $hashData->userId,
  1064.             "deleted" => UserEnum::ITEM_NO_DELETED
  1065.         ]);
  1067.         if(!$user){
  1068.             return $this->eadResponse([ 
  1069.                 "message" => $this->configuration->getLanguage('user_not_found', 'login') 
  1070.             ], ErrorEnum::ACTION_INVALID);
  1071.         }
  1073.         $password = $this->requestUtil->getField('password');
  1074.         $confirmPassword = $this->requestUtil->getField('confirmPassword');
  1075.         
  1076.         if($password != $confirmPassword){
  1077.             return $this->eadResponse([ 
  1078.                 "message" => $this->configuration->getLanguage('passwords_must_be_the_same', 'login')
  1079.             ], ErrorEnum::ACTION_INVALID);
  1080.         }
  1081.         
  1082.         $user->setPassword($password);
  1083.         $this->em->flush();
  1085.         $this->data["confirmMsg"] = $this->configuration->getLanguage('updated_password', 'login');
  1086.         $this->data["confirmStatus"] = UserEnum::YES;
  1087.         
  1088.         return $this->eadResponse([ 
  1089.             "message" => $this->configuration->getLanguage('updated_password', 'login'),
  1090.             "url" => 'https://'.$this->client->getDomainPrimary()."/login"
  1091.         ]);
  1092.     }
  1094.     /**
  1095.      * @Route(
  1096.      *      path          = "/logoff/user",
  1097.      *      name          = "userLogoff",
  1098.      *      methods       = {"GET"}
  1099.      * )
  1100.      */
  1101.     public function logoffUser(Request $request) {
  1102.         $sessionOn = $this->user->getSession();
  1103.         $userOrigin = $sessionOn->getUserOrigin();
  1104.         $sessionOn->delete();
  1105.         
  1106.         $this->generalService->logoffWS(
  1107.             $sessionOn,
  1108.             $this->clientConfig->getId()
  1109.         );
  1111.         if($userOrigin){
  1113.             $sessionOld = $this->em->getRepository(Session::class)->findOneBy([ 
  1114.                 "user" => $userOrigin->getId(),
  1115.                 "deleted" => UserEnum::ITEM_NO_DELETED
  1116.             ]);
  1118.             $ipApi = $this->generalService->getService('IpApiService');
  1120.             $ipApi->setRequest($request);
  1121.             
  1122.             $session = new Session();
  1123.             $session->setUser($userOrigin);
  1124.             $session->setIp($ipApi->getIp());
  1125.             $session->setIspName($ipApi->getIsp());
  1126.             $session->setCoordinate($ipApi->getCoordinate());
  1127.             $session->setTimeZone($ipApi->getTimeZone());
  1128.             $session->setCity($ipApi->getCity());
  1129.             $session->setState($ipApi->getState());
  1130.             $session->setCountry($ipApi->getCountry());
  1131.             $session->setIsAdmin(UserEnum::YES);
  1133.             $errors = $this->validateEntity($session);
  1134.             if($errors){
  1135.                 return $this->eadResponse($errors, ErrorEnum::FIELD_EMPTY);
  1136.             }
  1137.             
  1138.             if($sessionOld){
  1139.                 $session->setToken($sessionOld->getToken());
  1140.                 $sessionOld->delete();
  1142.                 $time = time() + (24 * 60 * 60);
  1143.                 if($this->generalService->getCookie('remember') == SessionEnum::YES){
  1144.                     $time = null;
  1145.                 }
  1146.                 
  1147.                 $this->generalService->setCookie(
  1148.                     'sessiontoken', 
  1149.                     $session->getToken(), 
  1150.                     $time
  1151.                 );
  1152.             }
  1154.             $this->em->persist($session);
  1155.             $this->em->flush();
  1157.             /*return $this->eadResponse([ 
  1158.                 "token" => $session->getToken(), 
  1159.                 "userId" => $userOrigin->getId() 
  1160.             ]);*/
  1161.         }
  1163.         $this->em->flush();
  1165.         return $this->redirectToRoute('home');
  1166.     }
  1168.     /**
  1169.      * @Route(
  1170.      *      path          = "/logoff",
  1171.      *      name          = "logoff",
  1172.      *      methods       = {"GET"},
  1173.      * )
  1174.      */
  1175.     public function logoff(Request $request) {
  1176.         if($this->user){
  1177.             $sessionOn = $this->user->getSession();
  1178.             if($sessionOn){
  1179.                 $sessionOn->delete();
  1180.                 $this->configuration->getSessionSym()->set('session', null);
  1182.                 $this->em->flush();
  1184.                 $this->generalService->deleteCookie('remember');
  1185.                 $this->generalService->deleteCookie('sessiontoken');
  1186.                 $this->generalService->logoffWS(
  1187.                     $sessionOn,
  1188.                     $this->clientConfig->getId()
  1189.                 );
  1190.             }
  1191.         }
  1193.         return $this->redirectToRoute('home');
  1194.     }
  1195. }