src/Controller/masteradminController/SecurityController.php line 42

Open in your IDE?
  1. <?php
  3. namespace App\Controller\masteradminController;
  5. use App\Controller\oAuthLoginController\LoginController;
  6. use App\Entity\User;
  7. use App\Entity\UserProfil;
  8. use App\Repository\FirebaseNotificationRepository;
  9. use App\Repository\UserRepository;
  10. use Doctrine\ORM\EntityManagerInterface;
  11. use Psr\Log\LoggerInterface;
  12. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  13. use Symfony\Component\HttpFoundation\Cookie;
  14. use Symfony\Component\HttpFoundation\JsonResponse;
  15. use Symfony\Component\HttpFoundation\RedirectResponse;
  16. use Symfony\Component\HttpFoundation\Request;
  17. use Symfony\Component\HttpFoundation\Response;
  18. use Symfony\Component\Mailer\MailerInterface;
  19. use Symfony\Component\Mime\Email;
  20. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  21. use Symfony\Component\Routing\Annotation\Route;
  22. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  23. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  24. use Symfony\Component\Security\Core\Security;
  25. use Symfony\Component\Security\Http\Authentication\AuthenticationUtils;
  26. use Symfony\Component\Uid\Uuid;
  27. use Symfony\Contracts\HttpClient\HttpClientInterface;
  29. class SecurityController extends AbstractController
  30. {
  31.     #[Route(path: '/login', name: 'app_login')]
  32.     public function login(AuthenticationUtils $authenticationUtils, Request $request): Response
  33.     {
  34.         // if ($this->getUser()) {
  35.         //     return $this->redirectToRoute('target_path');
  36.         // }
  38.         // get the login error if there is one
  39.         $error = $authenticationUtils->getLastAuthenticationError();
  40.         // last username entered by the user
  41.         $lastUsername = $authenticationUtils->getLastUsername();
  42.         $loginError = $request->hasSession() ? $request->getSession()->get('login_error', '') : '';
  43.         $request->getSession()->remove('login_error');
  45.         return $this->render('security/login.html.twig',
  46.             [
  47.                 'last_username' => $lastUsername,
  48.                 'error' => $error,
  49.                 'login_error' => $loginError
  50.             ]
  51.         );
  52.     }
  54.     #[Route(path: '/app-login', name: 'smartphone_app_login')]
  55.     public function app_login(Request $request,
  56.                               FirebaseNotificationRepository $firebaseNotificationRepository,
  57.                               TokenStorageInterface $tokenStorage,
  58.                               LoginController $loginController,
  59.                               LoggerInterface $logger): Response
  60.     {
  61.         $token = $request->query->get('token');
  62.         $model = $request->query->get('model');
  63.         $goUrl = $request->query->get('goUrl');
  64.         $request->getSession()->set('appUser', true);
  66.         $logger->error('Token:' . $token);
  67.         $logger->error('model:' . $model);
  68.         $logger->error('goUrl:' . $goUrl);
  70.         $url = $_ENV["WEBSITE_URL"] . '/user/start';
  71.         $url2 = $_ENV["WEBSITE_URL"] . '/logout';
  72.         $url3 = $_ENV["WEBSITE_URL"] . '/user/firma/startseite/0/info';
  73.         if(strlen($goUrl) > 5) {
  74.             $url = $goUrl;
  75.         }
  77.         if(strlen($token) < 10 || strlen($model) < 3) {
  78.             return $this->redirect($url);
  79.         }
  80.         $logger->error('erfolgreich 1');
  82.         $firebaseToken = $firebaseNotificationRepository->findOneBy(['token' => $token]);
  83.         if($firebaseToken == null) {
  84.             return $this->redirect($url);
  85.         }
  86.         $logger->error('erfolgreich 2');
  88.         $differenz = $firebaseToken->getDatum()->diff(new \DateTime('now', new \DateTimeZone('Europe/Berlin')));
  89.         if($differenz->days > 365) {
  90.             return $this->redirect($url);
  91.         }
  92.         $logger->error('erfolgreich 3');
  94.         /*
  95.                 $deviceInformation = json_decode($firebaseToken->getDeviceInformation(), true);
  96.                 if($deviceInformation['model'] != $model) {
  97.                     return $this->redirectToRoute('user_start');
  98.                 }
  99.                 */
  100.         $tokenEinstellungen = json_decode($firebaseToken->getEinstellungen(), true);
  101.         if($tokenEinstellungen['auto-login'] != 1) {
  102.             return $this->redirect($url2);
  103.         }
  104.         $logger->error('erfolgreich 4');
  106.         $request->getSession()->set('appUserTyp', $firebaseToken->getTyp());
  108.         //Login
  109.         $loginController->loginUser($firebaseToken->getUser(), $tokenStorage, $request);
  110.         $request->getSession()->set('firebaseToken', $firebaseToken->getToken());
  112.         if(strlen($goUrl) < 6) {
  113.             if ($firebaseToken->getUser()->getFirmenProfil() != null) {
  114.                 $url = $url3;
  115.             }
  116.         }
  118.         $logger->error('Login erfolgreich');
  120.         return $this->redirect($url);
  121.     }
  123.     #[Route(path: '/login/registrierung', name: 'app_login_registrierung')]
  124.     public function registerAccount(Request                     $request,
  125.                                     UserRepository              $userRepository,
  126.                                     EntityManagerInterface      $entityManager,
  127.                                     UserPasswordHasherInterface $passwordHasherEncoder,
  128.                                     MailerInterface             $mailer,
  129.                                     UrlGeneratorInterface       $urlGenerator,
  130.                                     HttpClientInterface         $client): Response
  131.     {
  132.         $responseData = [];
  133.         $responseData['success'] = false;
  134.         $responseData['message'] = '';
  135.         //Validierung
  136.         $vorname = $request->get('vorname');
  137.         $nachname = $request->get('nachname');
  138.         $email = $request->get('email');
  139.         $password = $request->get('password');
  140.         $newsletter = $request->get('newsletter');
  141.         if ($vorname == null || strlen($vorname) < 1) {
  142.             $responseData['message'] = 'Bitte Vorname angeben!';
  143.             return new JsonResponse($responseData);
  144.         }
  145.         if ($nachname == null || strlen($nachname) < 1) {
  146.             $responseData['message'] = 'Bitte Nachname angeben!';
  147.             return new JsonResponse($responseData);
  148.         }
  149.         if ($email == null || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
  150.             $responseData['message'] = 'Bitte gültige E-Mail angeben!';
  151.             return new JsonResponse($responseData);
  152.         }
  153.         if ($password == null || strlen($password) < 6) {
  154.             $responseData['message'] = 'Bitte längeres Kennwort!';
  155.             return new JsonResponse($responseData);
  156.         }
  157.         if (!is_numeric($newsletter)) {
  158.             $newsletter = 1;
  159.         }
  160.         //Validierung ReCaptcha
  161.         $recaptchaResponse = $client->request('POST', 'https://www.google.com/recaptcha/api/siteverify', [
  162.             'body' => [
  163.                 'secret' => $_ENV["RECAPTCHA_SECRET"],
  164.                 'response' => $request->get('g-recaptcha-response')
  165.             ]
  166.         ])->toArray();
  167.         if ($recaptchaResponse['success'] !== true || $recaptchaResponse['hostname'] !== $_SERVER['SERVER_NAME']) {
  168.             $responseData['message'] = 'Bitte Captcha neu ausführen';
  169.             return new JsonResponse($responseData);
  170.         }
  172.         //TODO Check AGB
  174.         //Prüfe ob Email schon vergeben
  175.         $emailCheckUser = $userRepository->findOneBy(['email' => $email]);
  176.         if ($emailCheckUser != null) {
  177.             $responseData['message'] = 'Diese E-Mail Adresse wurde bereits registriert!';
  178.             return new JsonResponse($responseData);
  179.         }
  181.         //Benutzer anlegen
  182.         $userID = $this->kontoErstellen($vorname, $nachname, $email, $password, 0, $newsletter, $userRepository, $entityManager, $passwordHasherEncoder);
  183.         $userNeu = $userRepository->findOneBy(['id' => $userID]);
  185.         //Optin Email Versenden
  186.         $this->sendOptinEmail($userNeu, $urlGenerator, $mailer);
  187.         /*$optinLink = $urlGenerator->generate('login_registrierung_ok', ['guid' => $userNeu->getGuid()], UrlGeneratorInterface::ABSOLUTE_URL);
  188.         $email = (new Email())
  189.             ->from($_ENV["MAILER_SENDER"])
  190.             ->to($email)
  191.             ->subject('handwerkXcampus Bestätigungsemail')
  192.             ->html('<p>Bestätigungstext</p><br><a href="' . $optinLink . '">Bestätigungslink</a>');
  193.         $mailer->send($email);*/
  195.         $responseData['success'] = true;
  196.         return new JsonResponse($responseData);
  197.     }
  199.     #[Route(path: '/login/registrierung/ok/{guid}', name: 'login_registrierung_ok')]
  200.     public function registrierungOK($guid, UserRepository $userRepository, EntityManagerInterface $entityManager): Response
  201.     {
  202.         $error = '';
  203.         $guidRichtig = $userRepository->findOneBy(['guid' => $guid]);
  204.         if ($guidRichtig != null) {
  205.             $guidRichtig->setFreigeschaltet(1);
  206.             $guidRichtig->setGuid(null);
  207.             $entityManager->persist($guidRichtig);
  208.             $entityManager->flush();
  209.         } else {
  210.             $error = 'Falscher Bestätigungscode!';
  211.         }
  213.         return $this->render('security/registrierung_ok.html.twig', ['error' => $error]);
  214.     }
  217.     #[Route(path: '/user/neue/mailadresse/{guid}', name: 'user_neue_mailadresse')]
  218.     public function login_neue_mailadresse($guid, UserRepository $userRepository, EntityManagerInterface $entityManager): Response
  219.     {
  220.         $error = '';
  221.         $ergebnis = '';
  222.         $user = $userRepository->findOneBy(['guid' => $guid]);
  223.         if ($user != null) {
  224.             $neueMail = $user->getAenderung();
  225.             $aenderungsIndex = $user->getAenderungsindex();
  227.             if ($aenderungsIndex == 1) {
  228.                 $ergebnis = 'Die neue E-Mail Adresse für den Login wurde übernommen.';
  229.                 $user->setEmail($neueMail);
  230.                 $user->setProvisorischerMitarbeiter(null);
  231.             }
  233.             $user->setAenderung(null);
  234.             $user->setAenderungsindex(null);
  235.             $user->setGuid(null);
  236.             $entityManager->persist($user);
  237.             $entityManager->flush();
  239.             if ($aenderungsIndex == 2) {
  240.                 $ergebnis = 'Die neue Benachrichtigungs E-Mail Adresse wurde übernommen.';
  241.                 $userProfil = $user->getUserProfil();
  242.                 $userProfil->setMailversand($neueMail);
  243.                 $entityManager->persist($userProfil);
  244.                 $entityManager->flush();
  245.             }
  246.         } else {
  247.             $error = 'Falscher Bestätigungscode, oder Änderungen wurden bereits übernommen!';
  248.         }
  250.         return $this->render('security/neue_email_adresse.html.twig', ['error' => $error, 'ergebnis' => $ergebnis]);
  251.     }
  254.     public function sendOptinEmail(User $user, UrlGeneratorInterface $urlGenerator, MailerInterface $mailer)
  255.     {
  256.         $optinLink = $urlGenerator->generate('login_registrierung_ok', ['guid' => $user->getGuid()], UrlGeneratorInterface::ABSOLUTE_URL);
  257.         $emailHTML = $this->render('emails/registrierung.html.twig', [
  258.             'preheader' => 'Bestätigung deiner Registrierung im handwerkXcampus',
  259.             'optinLink' => $optinLink,
  260.             'user' => $user,
  261.         ])->getContent();
  263.         $email = (new Email())
  264.             ->from($_ENV["MAILER_SENDER_NO_REPLY"])
  265.             ->to($user->getEmail())
  266.             ->subject('handwerkXcampus Registrierung')
  267.             ->html($emailHTML);
  268.         $mailer->send($email);
  269.     }
  272.     public function sendNeueMailadresseEmail(User $user, UrlGeneratorInterface $urlGenerator, MailerInterface $mailer)
  273.     {
  274.         $optinLink = $urlGenerator->generate('user_neue_mailadresse', ['guid' => $user->getGuid()], UrlGeneratorInterface::ABSOLUTE_URL);
  275.         $emailHTML = $this->render('emails/neue_login_mailadresse.html.twig', [
  276.             'preheader' => 'Du möchtest deine E-Mail Adresse für den Login ändern?',
  277.             'optinLink' => $optinLink,
  278.             'user' => $user,
  279.         ])->getContent();
  281.         $email = (new Email())
  282.             ->from($_ENV["MAILER_SENDER_NO_REPLY"])
  283.             ->to($user->getAenderung())
  284.             ->subject('handwerkXcampus Änderung der Login E-Mail Adresse')
  285.             ->html($emailHTML);
  286.         $mailer->send($email);
  287.     }
  289.     public function sendNeueVersandmailadresseEmail(User $user, UrlGeneratorInterface $urlGenerator, MailerInterface $mailer)
  290.     {
  291.         $optinLink = $urlGenerator->generate('user_neue_mailadresse', ['guid' => $user->getGuid()], UrlGeneratorInterface::ABSOLUTE_URL);
  292.         $emailHTML = $this->render('emails/neue_benachrichtigungs_mailadresse.html.twig', [
  293.             'preheader' => 'Du möchtest deine E-Mail Adresse für Benachrichtigungen ändern?',
  294.             'optinLink' => $optinLink,
  295.             'user' => $user,
  296.         ])->getContent();
  298.         $email = (new Email())
  299.             ->from($_ENV["MAILER_SENDER_NO_REPLY"])
  300.             ->to($user->getAenderung())
  301.             ->subject('handwerkXcampus Änderung der Benachrichtigungs E-Mail Adresse')
  302.             ->html($emailHTML);
  303.         $mailer->send($email);
  304.     }
  306.     public function sendKennwortVergessenEmail(User $user, UrlGeneratorInterface $urlGenerator, MailerInterface $mailer)
  307.     {
  308.         $optinLink = $urlGenerator->generate('user_kennwort_neu', ['guid' => $user->getGuid()], UrlGeneratorInterface::ABSOLUTE_URL);
  309.         $emailHTML = $this->render('emails/kennwort_vergessen.html.twig', [
  310.             'preheader' => 'Du möchtest dein Kennwort für den handwerkXcampus zurücksetzen?',
  311.             'optinLink' => $optinLink,
  312.             'user' => $user,
  313.         ])->getContent();
  315.         $email = (new Email())
  316.             ->from($_ENV["MAILER_SENDER_NO_REPLY"])
  317.             ->to($user->getEmail())
  318.             ->subject('handwerkXcampus Kennwort zurücksetzen')
  319.             ->html($emailHTML);
  320.         $mailer->send($email);
  321.     }
  323.     #[Route(path: '/user/kennwort/neu/{guid}', name: 'user_kennwort_neu')]
  324.     public function user_kennwort_neu($guid, UserRepository $userRepository, EntityManagerInterface $entityManager): Response
  325.     {
  326.         $user = null;
  327.         $neueGuid = null;
  328.         if ($guid == 'kennwort_neu') {
  329.             $neueGuid = Uuid::v4();
  330.             $user = $userRepository->findOneBy(['id' => $this->getUser()->getId()]);
  331.             if ($user == null) {
  332.                 return $this->redirectToRoute('user_start');
  333.             }
  334.             $user->setGuid($neueGuid);
  335.             $entityManager->persist($user);
  336.             $entityManager->flush();
  338.         } else {
  339.             $user = $userRepository->findOneBy(['guid' => $guid]);
  340.             $neueGuid = $user?->getGuid();
  341.         }
  344.         return $this->render('security/kennwort_zuruecksetzen.html.twig', ['user' => $user, 'guid' => $neueGuid]);
  345.     }
  349.     public function kontoErstellen($vorname, $nachname, $email, $password, $freigeschaltet, $newsletter,
  350.                                    UserRepository $userRepository,
  351.                                    EntityManagerInterface $entityManager,
  352.                                    UserPasswordHasherInterface $passwordHasherEncoder): int
  353.     {
  354.         $datum = new \DateTime('now', new \DateTimeZone('Europe/Berlin'));
  355.         $user = new User();
  356.         $user->setEmail(strtolower($email));
  357.         $user->setFreigeschaltet($freigeschaltet);
  358.         $user->setGuid(Uuid::v4());
  359.         $user->setAngelegtAm($datum);
  360.         $user->setLetzterLogin($datum);
  361.         $user->setFirmenProfil(null);
  362.         $user->setZweiFaktor(0);
  363.         $user->setNeueRoles(null);
  365.         $hashedPassword = '';
  366.         if (strlen($password) > 0) {
  367.             $hashedPassword = $passwordHasherEncoder->hashPassword($user, $password);
  368.         }
  369.         $user->setPassword($hashedPassword);
  370.         $user->setRoles((array)["ROLE_MITGLIED"]);
  371.         $entityManager->persist(($user));
  372.         $entityManager->flush();
  374.         $neueID = $user->getId();
  376.         $userProfil = new UserProfil();
  377.         $userNeu = $userRepository->findOneBy(['id' => $neueID]);
  378.         $userProfil->setUser($userNeu);
  379.         $userProfil->setVorname($vorname);
  380.         $userProfil->setNachname($nachname);
  381.         $userProfil->setMailversand(strtolower($email));
  382.         $userProfil->setNewsletter($newsletter);
  383.         $entityManager->persist(($userProfil));
  384.         $entityManager->flush();
  386.         return $neueID;
  387.     }
  389.     #[Route(path: '/logout_intern', name: 'app_logout_intern')]
  390.     public function logout_intern(): void
  391.     {
  392.         throw new \LogicException('This method can be blank - it will be intercepted by the logout key on your firewall.');
  393.     }
  395.     #[Route(path: '/logout', name: 'app_logout')]
  396.     public function logout (Request $request,  FirebaseNotificationRepository $firebaseNotificationRepository, EntityManagerInterface $entityManager): RedirectResponse
  397.     {
  398.         $redirectResponse = $this->redirectToRoute('app_logout_intern');
  399.         $firebaseToken = $request->getSession()->get('firebaseToken');
  400.         if($firebaseToken != null) {
  401.             $firebaseTokenObj = $firebaseNotificationRepository->findOneBy(['token' => $firebaseToken, 'user' => $this->getUser()]);
  402.             if($firebaseTokenObj != null) {
  403.                 $firebaseEinstellungen = json_decode($firebaseTokenObj->getEinstellungen(), true);
  404.                 $firebaseEinstellungen['auto-login'] = 0;
  405.                 $firebaseTokenObj->setEinstellungen(json_encode($firebaseEinstellungen));
  406.                 $entityManager->persist($firebaseTokenObj);
  407.                 $entityManager->flush();
  408.                 $redirectResponse->headers->setCookie(Cookie::create('app_user', true));
  409.             }
  410.         }
  412.         return $redirectResponse;
  413.     }
  415.     #[Route(path: '/after-logout', name: 'app_logout_after')]
  416.     public function after_logout (Request $request): RedirectResponse
  417.     {
  418.         if($request->cookies->get('app_user')) {
  419.             $request->getSession()->set('appUser', true);
  420.         }
  422.         return $this->redirectToRoute('user_start');
  423.     }
  424. }