src/Controller/userController/UserProfilController.php line 60

Open in your IDE?
  1. <?php
  3. namespace App\Controller\userController;
  5. use App\Controller\api\FirebaseController;
  6. use App\Controller\api\GoogleMapsController;
  7. use App\Controller\basisController\AllgemeineFunktionenController;
  8. use App\Controller\basisController\UserBasisController;
  9. use App\Controller\emailVersandController\MailsWarteschleifeController;
  10. use App\Controller\masteradminController\SecurityController;
  11. use App\Controller\oAuthLoginController\LoginController;
  12. use App\Entity\CelseoIntranetVerbindung;
  13. use App\Entity\Dozent;
  14. use App\Entity\FirmenMitgliederanfrage;
  15. use App\Entity\UserNotification;
  16. use App\Repository\AdminSecurityRoleRepository;
  17. use App\Repository\BuchungenRechnungenRepository;
  18. use App\Repository\BuchungenRepository;
  19. use App\Repository\BuchungenSeminareTeilnehmerRepository;
  20. use App\Repository\CelseoIntranetVerbindungRepository;
  21. use App\Repository\DozentRepository;
  22. use App\Repository\FirebaseNotificationRepository;
  23. use App\Repository\FirmenDateimanagerRepository;
  24. use App\Repository\FirmenInterneSchulungenRepository;
  25. use App\Repository\FirmenInterneSchulungenZertifikatRepository;
  26. use App\Repository\FirmenMitgliederanfrageRepository;
  27. use App\Repository\FirmenprofilRepository;
  28. use App\Repository\GutscheincodesRepository;
  29. use App\Repository\SchulungBeobachtenRepository;
  30. use App\Repository\SchulungsArtRepository;
  31. use App\Repository\SchulungsTermineRepository;
  32. use App\Repository\UserFavoritenRepository;
  33. use App\Repository\UserNotificationRepository;
  34. use App\Repository\UserProfilRepository;
  35. use App\Repository\UserRepository;
  36. use App\Repository\UserRolesGekauftRepository;
  37. use Doctrine\ORM\EntityManagerInterface;
  38. use Kreait\Firebase\Contract\Messaging;
  39. use Symfony\Component\Filesystem\Filesystem;
  40. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  41. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  42. use Symfony\Component\HttpFoundation\JsonResponse;
  43. use Symfony\Component\HttpFoundation\Request;
  44. use Symfony\Component\HttpFoundation\Response;
  45. use Symfony\Component\Mailer\MailerInterface;
  46. use Symfony\Component\Routing\Annotation\Route;
  47. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  48. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  49. use Symfony\Component\String\Slugger\SluggerInterface;
  50. use Symfony\Component\Finder\Finder;
  51. use Symfony\Component\Uid\Uuid;
  52. use Symfony\Contracts\HttpClient\HttpClientInterface;
  55. #[Route('/user/profil')]
  56. class UserProfilController extends UserBasisController
  57. {
  59.     #[Route('/mein_profil/info/{seite}', name: 'user_profil_mein_profil_info')]
  60.     public function index($seite, BuchungenSeminareTeilnehmerRepository $buchungenSeminareTeilnehmerRepository,
  61.                           FirmenInterneSchulungenZertifikatRepository $zertifikatRepository,
  62.                           GutscheincodesRepository $gutscheincodesRepository,
  63.                           UserFavoritenRepository $userFavoritenRepository): Response
  64.     {
  66.         $arrayScript = $this->getUserBC_script_bildupload();
  67.         $uploadTemplateScript = $arrayScript[0];
  68.         $downloadTemplateScript = $arrayScript[1];
  70.         return $this->render('user/profil/profil_info.html.twig', [
  71.             'seite' => $seite,
  72.             'gutscheine' => $gutscheincodesRepository->findBy(['an_user_id' => $this->getUser()->getId(), 'firma' => null]),
  73.             'zertifikate' => $zertifikatRepository->findBy(['user' => $this->getUser()], ['datum' => 'DESC']),
  74.             'favoritenanzahl' => count($userFavoritenRepository->findBy(['user_id' => $this->getUser()->getId()])),
  75.             'termine' => $buchungenSeminareTeilnehmerRepository->findBy(['user' => $this->getUser()->getId(), 'status' => 0]),
  76.             'uploadTemplateScript' => $uploadTemplateScript,
  77.             'downloadTemplateScript' => $downloadTemplateScript,
  78.         ]);
  79.     }
  82.     #[Route('/mein_profil/account_loeschen', name: 'user_profil_mein_profil_account_loeschen')]
  83.     public function user_profil_mein_profil_account_loeschen(): Response
  84.     {
  85.         return $this->render('user/profil/profil_loeschen_abfrage.html.twig', [
  86.         ]);
  87.     }
  89.     #[Route('/mein_profil/account_loeschen_durchfuehren', name: 'user_profil_mein_profil_account_loeschen_durchfuehren')]
  90.     public function user_profil_mein_profil_account_loeschen_durchfuehren(Request                $request,
  91.                                                                           UserRepository         $userRepository,
  92.                                                                           EntityManagerInterface $entityManager): Response
  93.     {
  94.         $returnData["error"] = true;
  95.         $user = $userRepository->findOneBy(['id' => $this->getUser()]);
  98.         if ($user != null) {
  99.             if (password_verify($request->get('kennwort'), $user->getPassword())) {
  101.                 //Todo: alle Dateien löschen wenn irgendwann Aktiv
  103.                 foreach ($user->getNotdienste() as $notdienst) {
  104.                     $notdienst->setUser(null);
  105.                     $notdienst->setVorname($user->getUserProfil()->getVorname());
  106.                     $notdienst->setNachname($user->getUserProfil()->getNachname());
  107.                     if ($notdienst->getErsatzUser() == null) {
  108.                         $notdienst->setPushNotificationDatum(null);
  109.                     }
  110.                     $entityManager->persist($notdienst);
  111.                 }
  112.                 foreach ($user->getNotdiensteErsatz() as $notdienst) {
  113.                     $notdienst->setErsatzUser(null);
  114.                     $notdienst->setErsatzVorname($user->getUserProfil()->getVorname());
  115.                     $notdienst->setErsatzNachname($user->getUserProfil()->getNachname());
  116.                     $notdienst->setPushNotificationDatum(null);
  117.                     $entityManager->persist($notdienst);
  118.                 }
  119.                 $entityManager->flush();
  121.                 $user->setFirmenProfil(null);
  122.                 $user->setEmail('geloeschter_account_' . $user->getId() . '_' . $user->getEmail());
  123.                 $user->setFreigeschaltet(0);
  124.                 $entityManager->persist($user);
  125.                 $entityManager->flush();
  126.                 $returnData["error"] = false;
  127.             }
  128.         }
  129.         return new JsonResponse($returnData);
  130.     }
  132.     #[Route('/mein_profil/updates/laden', name: 'user_profil_mein_profil_updates_laden')]
  133.     public function profilUpdatesLaden(UserRepository $userRepository, EntityManagerInterface $entityManager): Response
  134.     {
  135.         $user = $userRepository->findOneBy(['id' => $this->getUser()->getId()]);
  136.         if ($user->getCampusUpdate() != $_ENV["CAMPUS_UPDATE_VERSION"]) {
  137.             $user->setCampusUpdate($_ENV["CAMPUS_UPDATE_VERSION"]);
  138.             $entityManager->persist($user);
  139.             $entityManager->flush();
  140.         }
  141.         return $this->render('user/profil/profil_info_updates.html.twig', [
  142.         ]);
  143.     }
  146.     #[Route('/mein_profil/kalender/laden', name: 'user_profil_mein_profil_kalender_laden')]
  147.     public function profilKalenderLaden(): Response
  148.     {
  149.         return $this->render('user/profil/profil_info_kalender.html.twig', [
  150.         ]);
  151.     }
  153.     #[Route('/mein_profil/bearbeiten/laden', name: 'user_profil_mein_profil_bearbeiten_laden')]
  154.     public function profilBearbeitenLaden(): Response
  155.     {
  156.         return $this->render('user/profil/profil_info_bearbeiten.html.twig', [
  157.         ]);
  158.     }
  160.     #[Route('/mein_profil/dashboard/laden', name: 'user_profil_mein_profil_dashboard_laden')]
  161.     public function profilDashboardLaden(FirmenInterneSchulungenZertifikatRepository $zertifikatRepository,
  162.                                          BuchungenRepository                         $buchungenRepository,
  163.                                          GutscheincodesRepository                    $gutscheincodesRepository): Response
  164.     {
  165.         return $this->render('user/profil/profil_info_dashboard.html.twig', [
  166.             'gutscheine' => $gutscheincodesRepository->findBy(['an_user_id' => $this->getUser()->getId(), 'firma' => null]),
  167.             'zertifikate' => $zertifikatRepository->findBy(['user' => $this->getUser()], ['datum' => 'DESC']),
  168.             'offeneBuchungen' => $buchungenRepository->findBy(['user' => $this->getUser(), 'bezahlstatus' => 0]),
  169.         ]);
  170.     }
  172.     #[Route('/mein_profil/gutscheine/laden', name: 'user_profil_mein_profil_gutscheine_laden')]
  173.     public function user_profil_mein_profil_gutscheine_laden(GutscheincodesRepository $gutscheincodesRepository): Response
  174.     {
  176.         return $this->render('user/profil/profil_info_gutscheine.html.twig', [
  177.             'gutscheine' => $gutscheincodesRepository->findBy(['an_user_id' => $this->getUser()->getId(), 'firma' => null]),
  178.         ]);
  179.     }
  181.     #[Route('/mein_profil/favoriten/laden', name: 'user_profil_mein_profil_favoriten_laden')]
  182.     public function profilFavoritenLaden(FirmenprofilRepository  $firmenprofilRepository,
  183.                                          UserFavoritenRepository $userFavoritenRepository): Response
  184.     {
  186.         return $this->render('user/profil/profil_info_favoriten.html.twig', [
  187.             'favoriten' => $userFavoritenRepository->findBy(['user_id' => $this->getUser()->getId()]),
  188.             'firmenprofile' => $firmenprofilRepository->findAll(),
  189.         ]);
  190.     }
  192.     #[Route('/mein_profil/beobachtungen/laden', name: 'user_profil_mein_profil_beobachtungen_laden')]
  193.     public function profilBeobachtungenLaden(FirmenprofilRepository       $firmenprofilRepository,
  194.                                              SchulungBeobachtenRepository $schulungBeobachtenRepository): Response
  195.     {
  197.         return $this->render('user/profil/profil_info_beobachtungen.html.twig', [
  198.             'beobachtungen' => $schulungBeobachtenRepository->findBy(['user' => $this->getUser()]),
  199.             'firmenprofile' => $firmenprofilRepository->findAll(),
  200.         ]);
  201.     }
  203.     #[Route('/mein_profil/zertifikate/laden', name: 'user_profil_mein_profil_zertifikate_laden')]
  204.     public function profilZertifikateLaden(FirmenInterneSchulungenZertifikatRepository $zertifikatRepository,
  205.                                            FirmenInterneSchulungenRepository           $firmenInterneSchulungenRepository): Response
  206.     {
  207.         $zertifikate = $zertifikatRepository->findBy(['user' => $this->getUser()], ['datum' => 'DESC']);
  208.         $musterIDs = [];
  209.         $schulungsIDs = [];
  210.         foreach ($zertifikate as $zertifikat) {
  211.             $schulungsIDs[] = $zertifikat->getFirmenSchulungId();
  212.         }
  213.         $schulungsIDs = array_unique($schulungsIDs);
  214.         $schulungen = $firmenInterneSchulungenRepository->findBy(['id' => $schulungsIDs, 'status' => 1]);
  215.         foreach ($zertifikate as $zertifikat) {
  216.             foreach ($schulungen as $schulung) {
  217.                 if ($schulung->getId() == $zertifikat->getFirmenSchulungId()) {
  218.                     $tmpMuster['id'] = $zertifikat->getId();
  219.                     $tmpMuster['datum'] = $schulung->getStatusDatum()->format('d.m.Y');
  220.                     $musterIDs[] = $tmpMuster;
  221.                 }
  222.             }
  223.         }
  225.         return $this->render('user/profil/profil_info_zertifikate.html.twig', [
  226.             'zertifikate' => $zertifikate,
  227.             'musterIDs' => $musterIDs,
  228.         ]);
  229.     }
  232.     #[Route('/mein_profil/buchungen/laden', name: 'user_profil_mein_profil_buchungen_laden')]
  233.     public function profilBuchungenLaden(BuchungenRepository                   $buchungenRepository,
  234.                                          BuchungenSeminareTeilnehmerRepository $buchungenSeminareTeilnehmerRepository,
  235.                                          SchulungsArtRepository                $schulungsArtRepository,
  236.                                          UserNotificationRepository            $notificationRepository,
  237.                                          EntityManagerInterface                $entityManager): Response
  238.     {
  239.         $notifications = $notificationRepository->findBy(['type' => 9, 'user' => $this->getUser()->getId()]);
  240.         foreach ($notifications as $notification) {
  241.             $entityManager->remove($notification);
  242.             $entityManager->flush();
  243.         }
  244.         $buchungenIDs = [];
  245.         $selbstGebuchte = $buchungenRepository->findBy(['user' => $this->getUser()->getId()]);
  246.         foreach ($selbstGebuchte as $selbstGebucht) {
  247.             $buchungenIDs[] = $selbstGebucht->getId();
  248.         }
  249.         $seminareTeilnehmer = $buchungenSeminareTeilnehmerRepository->findBy(['user' => $this->getUser()->getId()]);
  250.         foreach ($seminareTeilnehmer as $teilnehmer) {
  251.             if ($teilnehmer->getBuchungenSeminar()->getBuchung()->getBezahlstatus() > 10) {
  252.                 $buchungenIDs[] = $teilnehmer->getBuchungenSeminar()->getBuchung()->getId();
  253.             }
  254.         }
  255.         $buchungenIDs = array_unique($buchungenIDs);
  256.         $buchungen = $buchungenRepository->findBy(['id' => $buchungenIDs], ['datum_bestellung' => 'DESC']);
  258.         return $this->render('user/profil/profil_info_buchungen.html.twig', [
  259.             'buchungen' => $buchungen,
  260.             'schulungsarten' => $schulungsArtRepository->findAll(),
  261.         ]);
  262.     }
  264.     #[Route('/mein_profil/warenkorb/laden', name: 'user_profil_mein_profil_warenkorb_laden')]
  265.     public function profilWarenkorbLaden(BuchungenRepository    $buchungenRepository,
  266.                                          SchulungsArtRepository $schulungsArtRepository): Response
  267.     {
  268.         return $this->render('user/profil/profil_info_warenkorb.html.twig', [
  269.             'buchungen' => $buchungenRepository->findBy(['bezahlstatus' => 0, 'user' => $this->getUser()->getId()], ['datum_bestellung' => 'DESC']),
  270.             'schulungsarten' => $schulungsArtRepository->findAll(),
  271.         ]);
  272.     }
  275.     #[Route('/mein_profil/buchungen/rechnungen/download/{id}', name: 'user_profil_mein_profil_buchungen_rechnungen_download')]
  276.     public function user_profil_mein_profil_buchungen_rechnungen_download($id,
  277.                                                                           BuchungenRechnungenRepository $buchungenRechnungenRepository,
  278.                                                                           HttpClientInterface $httpClient): Response
  279.     {
  280.         $buchungenRechnungen = $buchungenRechnungenRepository->findOneBy(['id' => $id]);
  282.         if ($buchungenRechnungen->getBuchung()->getUser()->getId() == $this->getUser()->getId() && $buchungenRechnungen->getBuchung()->getBezahlstatus() == 41) {
  284.             $rechnung = $httpClient->request('GET', $_ENV['WECLAPP_API_URL'] . 'salesInvoice/id/' . $buchungenRechnungen->getWeclappRechnungsId(), [
  285.                 'headers' => [
  286.                     'Content-Type' => 'application/json',
  287.                     'AuthenticationToken' => $_ENV['WECLAPP_API_KEY']
  288.                 ],
  289.             ])->toArray(false);
  291.             $rechnungResponse = $httpClient->request("GET", $_ENV['WECLAPP_API_URL'] . 'salesInvoice/id/' . $buchungenRechnungen->getWeclappRechnungsId() . '/downloadLatestSalesInvoicePdf', [
  292.                 'headers' => [
  293.                     'Content-Type' => 'application/json',
  294.                     'AuthenticationToken' => $_ENV['WECLAPP_API_KEY']
  295.                 ],
  296.             ]);
  298.             if ($rechnungResponse->getStatusCode() == 200) {
  299.                 $outputStream = fopen('php://memory', 'rw+');
  300.                 foreach ($httpClient->stream($rechnungResponse) as $chunk) {
  301.                     fwrite($outputStream, $chunk->getContent());
  302.                 }
  303.             } else {
  304.                 // TODO: FEHLER
  305.                 dd("Es ist ein FEHLER aufgetreten");
  306.             }
  308.             $response = new Response();
  309.             $response->headers->set('Content-Type', 'application/pdf');
  310.             $response->headers->set('Content-Disposition', 'attachment; filename="campus-' . $rechnung['invoiceNumber'] . '.pdf"');
  311.             $response->setContent(stream_get_contents($outputStream, -1, 0));
  312.             return $response;
  314.         } else {
  315.             return $this->redirectToRoute('user_start');
  316.         }
  318.     }
  321.     #[Route('/mein_profil/termine/laden', name: 'user_profil_mein_profil_termine_laden')]
  322.     public function profilTermineLaden(BuchungenSeminareTeilnehmerRepository $buchungenSeminareTeilnehmerRepository,
  323.                                        SchulungsArtRepository                $schulungsArtRepository,
  324.                                        SchulungsTermineRepository            $schulungsTermineRepository): Response
  325.     {
  326.         $gebuchteTermine = $buchungenSeminareTeilnehmerRepository->findBy(['user' => $this->getUser()->getId(), 'status' => 0]);
  327.         $terminIDs = [];
  328.         foreach ($gebuchteTermine as $gebuchterTermin) {
  329.             $schulungsart = $gebuchterTermin->getBuchungenSeminar()->getTermin()->getSchulung()->getSchulungsart()->getId();
  330.             if ($schulungsart == 1 or $schulungsart == 4) {
  331.                 foreach ($gebuchterTermin->getBuchungenSeminar()->getTermin()->getSchulung()->getSchulungstermine() as $gefundenTermin) {
  332.                     $terminIDs[] = $gefundenTermin->getId();
  333.                 }
  334.             } else {
  335.                 $terminIDs[] = $gebuchterTermin->getBuchungenSeminar()->getTermin()->getId();
  336.             }
  337.         }
  338.         $termine = $schulungsTermineRepository->findBy(['id' => $terminIDs], ['von' => 'ASC']);
  340.         return $this->render('user/profil/profil_info_termine.html.twig', [
  341.             'gebuchteTermine' => $gebuchteTermine,
  342.             'termine' => $termine,
  343.             'schulungsarten' => $schulungsArtRepository->findAll(),
  344.         ]);
  345.     }
  347.     #[Route('/mein_profil/benachrichtigungen/laden', name: 'user_profil_mein_profil_benachrichtigungen_laden')]
  348.     public function profilBenachrichtigungenLaden(FirebaseNotificationRepository $firebaseNotificationRepository): Response
  349.     {
  350.         $geraete = $firebaseNotificationRepository->findBy(['user' => $this->getUser()]);
  351.         return $this->render('user/profil/profil_info_benachrichtigungen.html.twig', [
  352.             'geraete' => $geraete,
  353.             'lable' => $this->getLableInternerBereich(),
  354.         ]);
  355.     }
  357.     #[Route('/mein_profil/benachrichtigungen/geraetename/laden/{id}', name: 'user_profil_mein_profil_benachrichtigungen_geraetename_laden')]
  358.     public function benachrichtigungen_geraetename_laden($id,
  359.                                                          FirebaseNotificationRepository $firebaseNotificationRepository): Response
  360.     {
  361.         $geraet = $firebaseNotificationRepository->findOneBy(['user' => $this->getUser(), 'id' => $id]);
  362.         return $this->render('user/profil/profil_info_benachrichtigungen_geraetename.html.twig', [
  363.             'geraet' => $geraet,
  364.         ]);
  365.     }
  367.     #[Route('/mein_profil/benachrichtigungen/geraetename/speichern/{id}', name: 'user_profil_mein_profil_benachrichtigungen_geraetename_speichern')]
  368.     public function benachrichtigungen_geraetename_speichern(Request                        $request, $id, EntityManagerInterface $entityManager,
  369.                                                              FirebaseNotificationRepository $firebaseNotificationRepository): Response
  370.     {
  371.         $geraet = $firebaseNotificationRepository->findOneBy(['user' => $this->getUser(), 'id' => $id]);
  372.         $returnData["error"] = true;
  373.         $returnData["geraeteID"] = $id;
  374.         $returnData["geraetename"] = '';
  375.         if ($geraet != null) {
  376.             $name = $request->get('name');
  377.             if (strlen($name) > 0) {
  378.                 $geraet->setName($name);
  379.                 $returnData["geraetename"] = $name;
  380.             } else {
  381.                 $geraet->setName(null);
  382.                 $deviceInformation = json_decode($geraet->getDeviceInformation(), true);
  383.                 $returnData["geraetename"] = $deviceInformation['model'];
  384.             }
  385.             $entityManager->persist($geraet);
  386.             $entityManager->flush();
  387.             $returnData["error"] = false;
  388.         }
  389.         return new JsonResponse($returnData);
  390.     }
  393.     #[Route('/mein_profil/benachrichtigungen/test_notification/{id}', name: 'user_profil_mein_profil_test_notification')]
  394.     public function test_notification($id,
  395.                                       FirebaseNotificationRepository $firebaseNotificationRepository,
  396.                                       UserRepository $userRepository,
  397.                                       Messaging $messaging,
  398.                                       FirebaseController $firebaseController): Response
  399.     {
  400.         $geraet = $firebaseNotificationRepository->findBy(['id' => $id, 'user' => $this->getUser()]);
  401.         if ($geraet != null) {
  402.             $userIDs = [];
  403.             $userIDs[] = $this->getUser()->getId();
  404.             $notificationEmpfaenger = $userIDs;
  405.             $notificationTitle = 'handwerkXcampus Test-Notification';
  406.             $notificationVorschau = 'Hallo ' . $this->getUser()->getUserProfil()->getVorname() . ', Test bestanden.';
  407.             $notificationBody = 'Dies ist eine Testnotification. Der Test war erfolgreich';
  408.             $notificationLink = $_ENV["WEBSITE_URL"] . '/user/profil/mein_profil/info/benachrichtigungen';
  409.             $firebaseController->firebaseNotificationSenden('Test', $notificationEmpfaenger, $notificationTitle, $notificationVorschau, $notificationBody, $notificationLink, $userRepository, $firebaseNotificationRepository, $messaging, $id);
  410.         }
  412.         $returnData["error"] = false;
  413.         return new JsonResponse($returnData);
  414.     }
  416.     #[Route('/mein_profil/benachrichtigungen/pushnachrichten_speichern', name: 'user_profil_mein_profil_app_pushnachrichten_speichern')]
  417.     public function user_profil_mein_profil_app_pushnachrichten_speichern(Request                        $request,
  418.                                                                           FirebaseNotificationRepository $firebaseNotificationRepository,
  419.                                                                           EntityManagerInterface         $entityManager): Response
  420.     {
  421.         $daten = null;
  422.         $geraeteId = $request->get('geraetId');
  423.         $art = $request->get('art');
  424.         $value = $request->get('value');
  426.         $geraet = $firebaseNotificationRepository->findOneBy(['user' => $this->getUser(), 'id' => $geraeteId]);
  427.         if ($geraet != null) {
  428.             if ($geraet->getEinstellungen() != null) {
  429.                 $daten = json_decode($geraet->getEinstellungen(), true);
  430.             }
  431.             $daten[$art] = $value;
  433.             $geraet->setEinstellungen(json_encode($daten));
  434.             $entityManager->persist($geraet);
  435.             $entityManager->flush();
  436.         }
  438.         $returnData["error"] = false;
  440.         return new JsonResponse($returnData);
  441.     }
  443.     #[Route('/mein_profil/benachrichtigungen/emailnachrichten_speichern', name: 'user_profil_mein_profil_emailnachrichten_speichern')]
  444.     public function user_profil_mein_profil_emailnachrichten_speichern(Request                $request, UserRepository $userRepository,
  445.                                                                        EntityManagerInterface $entityManager): Response
  446.     {
  447.         $daten = null;
  448.         $art = $request->get('art');
  449.         $value = $request->get('value');
  450.         $user = $userRepository->findOneBy(['id' => $this->getUser()]);
  451.         if ($user->getEinstellungen() != null) {
  452.             $daten = json_decode($user->getEinstellungen(), true);
  453.         }
  454.         $daten[$art] = $value;
  456.         $user->setEinstellungen(json_encode($daten));
  457.         $entityManager->persist($user);
  458.         $entityManager->flush();
  460.         $returnData["error"] = false;
  462.         return new JsonResponse($returnData);
  463.     }
  465.     #[Route('/mein_profil/benachrichtigungen/geraet_entfernen/{id}', name: 'user_profil_mein_profil_geraet_entfernen')]
  466.     public function user_profil_mein_profil_geraet_entfernen($id, FirebaseNotificationRepository $firebaseNotificationRepository, EntityManagerInterface $entityManager): Response
  467.     {
  468.         $geraet = $firebaseNotificationRepository->findOneBy(['id' => $id, 'user' => $this->getUser()->getId()]);
  469.         $returnData["error"] = false;
  471.         if ($geraet != null) {
  472.             $entityManager->remove($geraet);
  473.             $entityManager->flush();
  474.         } else {
  475.             $returnData["error"] = true;
  476.         }
  477.         return new JsonResponse($returnData);
  478.     }
  485.     #[Route('/mein_profil/intranet/laden', name: 'user_profil_mein_profil_intranet_laden')]
  486.     public function profilIntranetLaden(CelseoIntranetVerbindungRepository $celseoIntranetVerbindungRepository,
  487.                                         AllgemeineFunktionenController     $allgemeineFunktionenController): Response
  488.     {
  489.         $verbindungscode = null;
  490.         $verbindungscodeEnde = null;
  491.         $tmpVerbindungscode = $celseoIntranetVerbindungRepository->findVerbindungsCode($this->getUser()->getId());
  492.         if (count($tmpVerbindungscode) > 0) {
  493.             $verbindungscode = $tmpVerbindungscode[0]->getGuid();
  494.             $datumClone = clone $tmpVerbindungscode[0]->getDatum();
  495.             $verbindungscodeEnde = $datumClone->modify('+30 minutes');
  496.         }
  497.         $jsonData['campusId'] = $this->getUser()->getId();
  499.         $ergebnis = false;
  500.         $accounts = [];
  501.         $intranetResponse = $allgemeineFunktionenController->jsonDatenSendenAnIntranet('intranet_user_verbindungen/auslesen', $jsonData);
  502.         if ($intranetResponse['ergebnis']) {
  503.             $ergebnis = true;
  504.             $accounts = $intranetResponse['accounts'];
  505.         }
  506.         return $this->render('user/profil/profil_info_intranet.html.twig', [
  507.             'ergebnis' => $ergebnis,
  508.             'accounts' => $accounts,
  509.             'verbindungscode' => $verbindungscode,
  510.             'verbindungscodeEnde' => $verbindungscodeEnde,
  511.         ]);
  512.     }
  514.     #[Route('/mein_profil/intranet/verbindungscode', name: 'user_profil_mein_profil_intranet_verbindungscode')]
  515.     public function user_profil_mein_profil_intranet_verbindungscode(CelseoIntranetVerbindungRepository $celseoIntranetVerbindungRepository,
  516.                                                                      EntityManagerInterface             $entityManager): Response
  517.     {
  518.         $returnData["error"] = false;
  519.         $datum = new \DateTime('now', new \DateTimeZone('Europe/Berlin'));
  521.         $verbindungscodes = $celseoIntranetVerbindungRepository->findBy(['user_id' => $this->getUser()->getId(), 'intranet_user_id' => 0]);
  522.         foreach ($verbindungscodes as $verbindungscode) {
  523.             $entityManager->remove($verbindungscode);
  524.             $entityManager->flush();
  525.         }
  526.         $tmpGuid = Uuid::v4();
  527.         $tmpGuidExplode = explode('-', $tmpGuid);
  528.         $guid = $tmpGuidExplode[1] . '-' . $tmpGuidExplode[2] . '-' . $tmpGuidExplode[3] . '-' . $this->getUser()->getId();
  530.         $verbindungscode = new CelseoIntranetVerbindung();
  531.         $verbindungscode->setUserId($this->getUser()->getId());
  532.         $verbindungscode->setGuid($guid);
  533.         $verbindungscode->setDatum($datum);
  534.         $verbindungscode->setIntranetUserId(0);
  535.         $entityManager->persist($verbindungscode);
  536.         $entityManager->flush();
  538.         return new JsonResponse($returnData);
  539.     }
  541.     #[Route('/mein_profil/intranet/login/{intranetAnsprechpartnerId}', name: 'user_profil_mein_profil_intranet_login')]
  542.     public function user_profil_mein_profil_intranet_login($intranetAnsprechpartnerId,
  543.                                                            CelseoIntranetVerbindungRepository $celseoIntranetVerbindungRepository,
  544.                                                            AllgemeineFunktionenController $allgemeineFunktionenController,
  545.                                                            EntityManagerInterface $entityManager): Response
  546.     {
  547.         $returnData["error"] = true;
  548.         $returnData["link"] = $_ENV["CELSEO_INTRANET_URL"];
  549.         $datum = new \DateTime('now', new \DateTimeZone('Europe/Berlin'));
  551.         $verbindungscodes = $celseoIntranetVerbindungRepository->findBy(['user_id' => $this->getUser()->getId()]);
  552.         foreach ($verbindungscodes as $verbindungscode) {
  553.             if ($verbindungscode->getIntranetUserId() != 0) {
  554.                 $entityManager->remove($verbindungscode);
  555.                 $entityManager->flush();
  556.             }
  557.         }
  558.         $jsonData['campusId'] = $this->getUser()->getId();
  560.         $intranetResponse = $allgemeineFunktionenController->jsonDatenSendenAnIntranet('intranet_user_verbindungen/auslesen', $jsonData);
  561.         if ($intranetResponse['ergebnis']) {
  562.             foreach ($intranetResponse['accounts'] as $account) {
  563.                 if ($account['intranetAnsprechpartnerId'] == $intranetAnsprechpartnerId && $account['campusZumIntranetLogin'] == 1) {
  564.                     $returnData["error"] = false;
  565.                     $tmpGuid = Uuid::v4();
  566.                     $guid = str_replace('-', '', $tmpGuid);
  568.                     $verbindungscode = new CelseoIntranetVerbindung();
  569.                     $verbindungscode->setUserId($this->getUser()->getId());
  570.                     $verbindungscode->setGuid($guid);
  571.                     $verbindungscode->setDatum($datum);
  572.                     $verbindungscode->setIntranetUserId($intranetAnsprechpartnerId);
  573.                     $entityManager->persist($verbindungscode);
  574.                     $entityManager->flush();
  576.                     $returnData["link"] = $_ENV["CELSEO_INTRANET_DEMO_URL"] . 'campus-login?AP=' . $intranetAnsprechpartnerId . '&guid=' . $guid;
  577.                     break;
  578.                 }
  579.             }
  580.         }
  581.         return new JsonResponse($returnData);
  582.     }
  584.     #[Route('/mein_profil/intranet/campus_verbindung_entfernen/{intranetAnsprechpartnerId}', name: 'user_profil_mein_profil_intranet_campus_verbindung_entfernen')]
  585.     public function user_profil_mein_profil_intranet_campus_verbindung_entfernen($intranetAnsprechpartnerId,
  586.                                                            AllgemeineFunktionenController $allgemeineFunktionenController): Response
  587.     {
  588.         $jsonData['campusId'] = $this->getUser()->getId();
  589.         $jsonData['apId'] = $intranetAnsprechpartnerId;
  590.         $intranetResponse = $allgemeineFunktionenController->jsonDatenSendenAnIntranet('intranet_user_verbindung/loeschen', $jsonData);
  591.         $returnData["ergebnis"] = $intranetResponse['ergebnis'];
  592.         return new JsonResponse($returnData);
  593.     }
  599.     #[Route('/mein_profil/mailadressen/laden', name: 'user_profil_mein_profil_mailadressen_laden')]
  600.     public function profilMailadressenLaden(): Response
  601.     {
  602.         return $this->render('user/profil/profil_info_mailadressen.html.twig', [
  603.         ]);
  604.     }
  606.     #[Route('/mein_profil/mailadressen/mail/speichern', name: 'user_profil_mein_profil_mailadressen_mail_speichern')]
  607.     public function profilMailadressenMailSpeichern(Request                $request,
  608.                                                     UserRepository         $userRepository,
  609.                                                     MailerInterface        $mailer,
  610.                                                     UrlGeneratorInterface  $urlGenerator,
  611.                                                     SecurityController     $securityController,
  612.                                                     EntityManagerInterface $entityManager): Response
  613.     {
  614.         $userKontrolle = $userRepository->findBy(['email' => $request->get('neue_mailadresse')]);
  615.         $returnData["error"] = false;
  617.         if ($userKontrolle == null) {
  618.             $user = $userRepository->findOneBy(['id' => $this->getUser()->getId()]);
  619.             $user->setAenderungsindex(1);
  620.             $user->setAenderung($request->get('neue_mailadresse'));
  621.             $user->setGuid(Uuid::v4());
  622.             $entityManager->persist($user);
  623.             $entityManager->flush();
  624.             $securityController->sendNeueMailadresseEmail($user, $urlGenerator, $mailer);
  625.         } else {
  626.             $returnData["error"] = true;
  627.         }
  629.         return new JsonResponse($returnData);
  630.     }
  632.     #[Route('/mein_profil/mailadressen/mail/speichern/abbrechen', name: 'user_profil_mein_profil_mailadressen_mail_speichern_abbrechen')]
  633.     public function profilMailadressenMailSpeichernAbbrechen(UserRepository         $userRepository,
  634.                                                              EntityManagerInterface $entityManager): Response
  635.     {
  636.         $user = $userRepository->findOneBy(['id' => $this->getUser()->getId()]);
  637.         $user->setAenderungsindex(null);
  638.         $user->setAenderung(null);
  639.         $user->setGuid(null);
  640.         $entityManager->persist($user);
  641.         $entityManager->flush();
  643.         $returnData["error"] = false;
  644.         return new JsonResponse($returnData);
  645.     }
  647.     #[Route('/mein_profil/mailadressen/versandmail/speichern', name: 'user_profil_mein_profil_mailadressen_versandmail_speichern')]
  648.     public function profilMailadressenVersandmailSpeichern(Request                $request,
  649.                                                            UserRepository         $userRepository,
  650.                                                            MailerInterface        $mailer,
  651.                                                            UrlGeneratorInterface  $urlGenerator,
  652.                                                            SecurityController     $securityController,
  653.                                                            EntityManagerInterface $entityManager): Response
  654.     {
  655.         $neueMail = $request->get('neue_versandmailadresse');
  656.         $user = $userRepository->findOneBy(['id' => $this->getUser()->getId()]);
  657.         $returnData["error"] = false;
  659.         if ($user->getEmail() != $neueMail) {
  660.             $user->setAenderungsindex(2);
  661.             $user->setAenderung($neueMail);
  662.             $user->setGuid(Uuid::v4());
  663.             $entityManager->persist($user);
  664.             $entityManager->flush();
  665.             $securityController->sendNeueVersandmailadresseEmail($user, $urlGenerator, $mailer);
  666.         } else {
  667.             $returnData["error"] = true;
  668.             $userProfil = $user->getUserProfil();
  669.             $userProfil->setMailversand($neueMail);
  670.             $entityManager->persist($userProfil);
  671.             $entityManager->flush();
  672.         }
  674.         return new JsonResponse($returnData);
  675.     }
  678.     #[Route('/mein_profil/mailadressen/anzeigemail/speichern', name: 'user_profil_mein_profil_mailadressen_anzeigemail_speichern')]
  679.     public function profilMailadressenAnzeigeMailSpeichern(Request                $request,
  680.                                                            UserProfilRepository   $userProfilRepository,
  681.                                                            EntityManagerInterface $entityManager): Response
  682.     {
  683.         $emailAnzeigen = null;
  684.         if (strlen($request->get('email_anzeigen')) > 1) {
  685.             $emailAnzeigen = $this->getUser()->getFirmenprofil()->getId() . ',' . $request->get('email_anzeigen');
  686.         }
  687.         $userprofil = $userProfilRepository->findOneBy(['user' => $this->getUser()]);
  688.         $userprofil->setEmailAnzeigen($emailAnzeigen);
  689.         $entityManager->persist($userprofil);
  690.         $entityManager->flush();
  692.         $returnData["error"] = false;
  693.         return new JsonResponse($returnData);
  694.     }
  697.     #[Route('/mein_profil/ondemand/laden', name: 'user_profil_mein_profil_ondemand_laden')]
  698.     public function profilOndemandLaden(BuchungenSeminareTeilnehmerRepository $buchungenSeminareTeilnehmerRepository): Response
  699.     {
  700.         return $this->render('user/profil/profil_info_on_demand.html.twig', [
  701.             'bstTermine' => $buchungenSeminareTeilnehmerRepository->findBy(['user' => $this->getUser()->getId()]),
  702.         ]);
  703.     }
  705.     #[Route('/mein_profil/ondemand/ansehen/{bstId}', name: 'user_profil_mein_profil_ondemand_ansehen')]
  706.     public function user_profil_mein_profil_ondemand_ansehen($bstId, BuchungenSeminareTeilnehmerRepository $buchungenSeminareTeilnehmerRepository): Response
  707.     {
  708.         return $this->render('user/profil/profil_info_on_demand_ansehen.html.twig', [
  709.             'bstTermin' => $buchungenSeminareTeilnehmerRepository->findOneBy(['id' => $bstId, 'user' => $this->getUser()->getId()]),
  710.         ]);
  711.     }
  713.     #[Route('/mein_profil/firma', name: 'user_profil_mein_profil_firma_laden', methods: ['GET'])]
  714.     public function profilFirma(FirmenMitgliederanfrageRepository $firmenMitgliederanfrageRepository,
  715.                                 UserNotificationRepository        $notificationRepository,
  716.                                 AdminSecurityRoleRepository       $adminSecurityRoleRepository,
  717.                                 EntityManagerInterface            $entityManager): Response
  718.     {
  719.         $anfrage = 0;
  720.         $firmenprofil = null;
  721.         $firmenid = $this->getUser()?->getFirmenProfil()?->getId();
  723.         if ($firmenid == null) {
  724.             $userFirmenanfrage = $firmenMitgliederanfrageRepository->findOneBy(['user' => $this->getUser()->getId()]);
  725.             if ($userFirmenanfrage != null) {
  726.                 $firmenprofil = $userFirmenanfrage->getFirma();
  727.                 $anfrage = 1;
  728.             }
  729.         } else {
  730.             $firmenprofil = $this->getUser()->getFirmenProfil();
  731.         }
  733.         $notifications = $notificationRepository->findBy(['type' => 4, 'user' => $this->getUser()->getId()]);
  734.         foreach ($notifications as $notification) {
  735.             $entityManager->remove($notification);
  736.             $entityManager->flush();
  737.         }
  739.         return $this->render('user/profil/profil_firmenbewerbung.html.twig', [
  740.             'anfrage' => $anfrage,
  741.             'firma' => $firmenprofil,
  742.             'adminroles' => $adminSecurityRoleRepository->findAll(),
  743.         ]);
  744.     }
  747.     #[Route('/mein_profil/firmencode/senden', name: 'user_profil_firmencode_senden')]
  748.     public function userProfilFirmencodeSenden(Request                $request,
  749.                                                EntityManagerInterface $entityManager,
  750.                                                FirmenprofilRepository $firmenprofilRepository,
  751.                                                UserRepository         $userRepository): Response
  752.     {
  753.         $firmencode = $request->get('firmencode');
  754.         $firmaGefunden = null;
  756.         if ($firmencode != null) {
  757.             if (str_starts_with($firmencode, "C-")) {
  758.                 $code = explode('-', $firmencode, 3);
  759.                 if (count($code) == 3) {
  760.                     if (is_numeric($code[1])) {
  761.                         $firmaGefunden = $firmenprofilRepository->findOneBy(['id' => (int)$code[1], 'firmencode' => $code[2]]);
  762.                     }
  763.                 }
  764.             }
  765.         }
  767.         if ($firmaGefunden != null) {
  768.             $userProfil = $userRepository->findOneBy(['id' => $this->getUser()->getId()]);
  770.             $beiFirmaAnmelden = new FirmenMitgliederanfrage();
  771.             $beiFirmaAnmelden->setUser($userProfil);
  772.             $beiFirmaAnmelden->setDatum(new \DateTime('now', new \DateTimeZone('Europe/Berlin')));
  773.             $beiFirmaAnmelden->setFirma($firmaGefunden);
  774.             $entityManager->persist($beiFirmaAnmelden);
  775.             $entityManager->flush();
  777.             $alleFirmenmitglieder = $userRepository->findBy(['firmen_profil' => $firmaGefunden]);
  780.             foreach ($alleFirmenmitglieder as $firmenmitglied) {
  781.                 if (in_array("ROLE_FIRMA_ADMIN_MITGLIEDER_RECHTE", $firmenmitglied->getRoles())) {
  782.                     $neueNotification = new UserNotification();
  783.                     $neueNotification->setUser($firmenmitglied);
  784.                     $neueNotification->setVonUserId($this->getUser()->getId());
  785.                     $neueNotification->setUserName($this->getUser()->getuserProfil()->getNachname() . ' ' . $this->getUser()->getuserProfil()->getVorname());
  786.                     $neueNotification->setType(3);
  787.                     $neueNotification->setDatum(new \DateTime('now', new \DateTimeZone('Europe/Berlin')));
  788.                     $neueNotification->setGelesen(0);
  789.                     $neueNotification->setText('Anfrage Firmenmitglied');
  790.                     $neueNotification->setLink('admin_start_neue_mitglieder');
  791.                     $entityManager->persist($neueNotification);
  792.                     $entityManager->flush();
  793.                 }
  794.             }
  796.             $returnData["error"] = false;
  797.             return new JsonResponse($returnData);
  798.         }
  800.         $returnData["error"] = true;
  801.         return new JsonResponse($returnData);
  802.     }
  805.     #[Route('/mein_profil/firmencode/abbrechen/{firmenId}', name: 'user_profil_firmencode_abbrechen')]
  806.     public function userProfilFirmencodeAbbrechen(Request                           $request, $firmenId, EntityManagerInterface $entityManager,
  807.                                                   FirmenDateimanagerRepository      $firmenDateimanagerRepository,
  808.                                                   FirmenMitgliederanfrageRepository $firmenMitgliederanfrageRepository,
  809.                                                   FirmenprofilRepository            $firmenprofilRepository,
  810.                                                   MailsWarteschleifeController      $mailsWarteschleifeController,
  811.                                                   UrlGeneratorInterface             $urlGenerator,
  812.                                                   UserFavoritenRepository           $userFavoritenRepository,
  813.                                                   TokenStorageInterface             $tokenStorage,
  814.                                                   UserRepository                    $userRepository,
  815.                                                   UserRolesGekauftRepository        $userRolesGekauftRepository,
  816.                                                   UserNotificationRepository        $notificationRepository): Response
  817.     {
  818.         $userId = $this->getUser()->getId();
  819.         $firmaAnfrage = $firmenMitgliederanfrageRepository->findOneBy(['user' => $userId, 'firma' => $firmenId]);
  821.         if ($firmaAnfrage != null) {
  822.             $entityManager->remove($firmaAnfrage);
  823.             $entityManager->flush();
  825.             $notifications = $notificationRepository->findBy(['von_user_id' => $userId, 'type' => 3]);
  826.             foreach ($notifications as $notification) {
  827.                 $entityManager->remove($notification);
  828.                 $entityManager->flush();
  829.             }
  830.         }
  831.         $user = $userRepository->findOneBy(['id' => $userId, 'firmen_profil' => $firmenId, 'firmen_profil_boss' => null]);
  832.         if ($user != null) {
  834.             $userRolesExtra = $userRolesGekauftRepository->findBy(['user' => $userId]);
  835.             $neueUserRoles = [];
  836.             $neueUserRoles[] = "ROLE_MITGLIED";
  837.             if ($userRolesExtra != null) {
  838.                 foreach ($userRolesExtra as $userRoles) {
  839.                     $neueUserRoles[] = $userRoles->getRole();
  840.                 }
  841.             }
  844.             $firma = $firmenprofilRepository->findOneBy(['id' => $firmenId]);
  845.             $alleFirmenmitglieder = $userRepository->findBy(['firmen_profil' => $firma]);
  847.             foreach ($alleFirmenmitglieder as $firmenmitglied) {
  848.                 if (in_array("ROLE_FIRMA_ADMIN_MITGLIEDER_RECHTE", $firmenmitglied->getRoles()) && $firmenmitglied->getId() != $userId) {
  850.                     $emailSenden = 1;
  851.                     if ($firmenmitglied->getEinstellungen() != null) {
  852.                         $einstellungen = json_decode($firmenmitglied->getEinstellungen(), true);
  853.                         if (isset($einstellungen['hatFirmaVerlassen'])) {
  854.                             $emailSenden = (int)$einstellungen['hatFirmaVerlassen'];
  855.                         }
  856.                     }
  857.                     if ($emailSenden == 1) {
  858.                         $optinLink = $urlGenerator->generate('admin_firmenadmin_start', [], UrlGeneratorInterface::ABSOLUTE_URL);
  859.                         $optinLink2 = $urlGenerator->generate('user_profil_mein_profil_info', ['seite' => 'benachrichtigungen'], UrlGeneratorInterface::ABSOLUTE_URL);
  860.                         $mailsWarteschleifeController->insertMail([
  861.                             'preheader' => 'handwerkXcampus Mitarbeiter*in hat Firmenverbindung gelöscht',
  862.                             'vorname' => $firmenmitglied->getUserProfil()->getVorname(),
  863.                             'nachname' => $firmenmitglied->getUserProfil()->getNachname(),
  864.                             'vornameSender' => $user->getuserProfil()->getVorname(),
  865.                             'nachnameSender' => $user->getuserProfil()->getNachname(),
  866.                             'firmenposition' => $user->getuserProfil()->getFirmenposition(),
  867.                             'optinLink' => $optinLink,
  868.                             'optinLink2' => $optinLink2,
  869.                         ], $_ENV["MAILER_SENDER_NO_REPLY"],
  870.                             $firmenmitglied->getuserProfil()->getMailversand(),
  871.                             'handwerkXcampus Mitarbeiter*in hat Firmenverbindung gelöscht',
  872.                             'emails/benachrichtigung_firma_verlassen.html.twig',
  873.                             'VonFirmaGegangen', 0,
  874.                             $firmenmitglied);
  875.                     }
  877.                 }
  878.             }
  880.             //Todo: Chat Upload Kontrolle ob löschen
  882.             foreach ($user->getNotdienste() as $notdienst) {
  883.                 $notdienst->setUser(null);
  884.                 $notdienst->setVorname($user->getUserProfil()->getVorname());
  885.                 $notdienst->setNachname($user->getUserProfil()->getNachname());
  886.                 if ($notdienst->getErsatzUser() == null) {
  887.                     $notdienst->setPushNotificationDatum(null);
  888.                 }
  889.                 $entityManager->persist($notdienst);
  890.             }
  891.             foreach ($user->getNotdiensteErsatz() as $notdienst) {
  892.                 $notdienst->setErsatzUser(null);
  893.                 $notdienst->setErsatzVorname($user->getUserProfil()->getVorname());
  894.                 $notdienst->setErsatzNachname($user->getUserProfil()->getNachname());
  895.                 $notdienst->setPushNotificationDatum(null);
  896.                 $entityManager->persist($notdienst);
  897.             }
  898.             $entityManager->flush();
  900.             $userDateien = $firmenDateimanagerRepository->findBy(['user_id' => $user->getId()]);
  901.             foreach ($userDateien as $datei) {
  902.                 $serverFilePath = $this->getParameter('admin_ordner') . '/dateimanager/' . $user->getFirmenProfil()->getId() . '/' . $datei->getSpeichername();
  903.                 $fileSystem = new Filesystem();
  904.                 $fileSystem->remove($serverFilePath);
  905.             }
  907.             $user->setFirmenProfil(null);
  908.             $user->setNeueRoles(null);
  909.             $user->setRoles($neueUserRoles);
  910.             $entityManager->persist($user);
  911.             $entityManager->flush();
  913.             //Benutzer neu einloggen
  914.             $loginController = new LoginController($userFavoritenRepository);
  915.             $loginController->loginUser($user, $tokenStorage, $request);
  917.         }
  919.         $returnData["error"] = false;
  920.         return new JsonResponse($returnData);
  921.     }
  924.     #[Route('/mein_profil/rechte/aktualisieren', name: 'user_profil_mein_profil_rechte_aktualisieren')]
  925.     public function user_profil_rechte_aktualisieren(EntityManagerInterface  $entityManager,
  926.                                                      UserRepository          $userRepository,
  927.                                                      UserFavoritenRepository $userFavoritenRepository,
  928.                                                      TokenStorageInterface   $tokenStorage,
  929.                                                      Request                 $request): Response
  930.     {
  931.         $user = $userRepository->findOneBy(['id' => $this->getUser()->getId()]);
  933.         if ($user->getNeueRoles() != null) {
  934.             $userNeueRoles = $user->getNeueRoles();
  935.             $user->setRoles($userNeueRoles);
  936.             $user->setNeueRoles(null);
  937.             $entityManager->persist($user);
  938.             $entityManager->flush();
  940.             //Benutzer neu einloggen
  941.             $loginController = new LoginController($userFavoritenRepository);
  942.             $loginController->loginUser($user, $tokenStorage, $request);
  943.         }
  945.         $returnData["error"] = false;
  946.         return new JsonResponse($returnData);
  947.     }
  950.     #[Route('/mein_profil/bearbeiten/speichern', name: 'user_profil_mein_profil_bearbeiten_speichern')]
  951.     public function userProfilSpeichern(Request                $request,
  952.                                         UserProfilRepository   $userProfilRepository,
  953.                                         DozentRepository       $dozentRepository,
  954.                                         EntityManagerInterface $entityManager,
  955.                                         GoogleMapsController   $googleMapsController,
  956.                                         HttpClientInterface    $httpClient): Response
  957.     {
  958.         $id = $this->getUser()->getId();
  959.         $userProfil = $userProfilRepository->findOneBy(['user' => $id]);
  960.         $dozent = $dozentRepository->findOneBy(['user' => $id]);
  962.         if (strlen($request->get('plz'))) {
  963.             $adresse = $request->get('plz');
  964.             if (strlen($request->get('ort'))) {
  965.                 $adresse = $adresse . ' ' . $request->get('ort');
  966.             }
  967.             if (strlen($request->get('strasse'))) {
  968.                 $adresse = $adresse . ' ' . $request->get('strasse');
  969.             }
  971.             $ergebnis = $googleMapsController->googleMapsKoordinatenSuchen($adresse, $httpClient);
  972.             if (count($ergebnis) > 0) {
  973.                 $userProfil->setGoogleLat($ergebnis[0]['geometry']['location']['lat'] . '');
  974.                 $userProfil->setGoogleLen($ergebnis[0]['geometry']['location']['lng'] . '');
  975.             }
  976.         } else {
  977.             $userProfil->setGoogleLat(null);
  978.             $userProfil->setGoogleLen(null);
  979.         }
  980.         if ($request->get('geburtsdatum') == -1) {
  981.             $userProfil->setGeburtsdatum(null);
  982.         } else {
  983.             $userProfil->setGeburtsdatum(new \DateTime($request->get('geburtsdatum')));
  984.         }
  987.         $userProfil->setVorname($request->get('vorname'));
  988.         $userProfil->setNachname($request->get('nachname'));
  989.         $userProfil->setStrasse($request->get('strasse'));
  990.         $userProfil->setPlz($request->get('plz'));
  991.         $userProfil->setOrt($request->get('ort'));
  992.         $userProfil->setTelefon($request->get('telefon'));
  993.         $userProfil->setMobil($request->get('mobil'));
  994.         $userProfil->setNewsletter($request->get('newsletter'));
  995.         $entityManager->persist($userProfil);
  996.         $entityManager->flush();
  999.         if ($request->get('dozent_anlegen') != '0' || $dozent != null) {
  1000.             if ($request->get('dozent_anlegen') == '1' && $dozent == null) {
  1001.                 $dozent = new Dozent();
  1002.                 $dozent->setUser($userProfil->getUser());
  1003.             }
  1004.             $dozent->setTelefon($request->get('dozent_telefon'));
  1005.             $dozent->setEmail($request->get('dozent_email'));
  1006.             $dozent->setFacebook($request->get('dozent_facebook'));
  1007.             $dozent->setInstagram($request->get('dozent_instagram'));
  1008.             $dozent->setYoutube($request->get('dozent_youtube'));
  1009.             $dozent->setVorstellungsvideo($request->get('dozent_vorstellungsvideo'));
  1010.             $dozent->setBeschreibung($request->get('dozent_beschreibung'));
  1011.             $entityManager->persist($dozent);
  1012.             $entityManager->flush();
  1013.         }
  1015.         $returnData["fehlermeldung"] = false;
  1016.         return new JsonResponse($returnData);
  1017.     }
  1020.     #[Route('/mein_profil/bearbeiten/upload', name: 'user_profil_mein_profil_bearbeiten_upload')]
  1021.     public function schulungUpload(Request $request, SluggerInterface $slugger, UserProfilRepository $userProfilRepository): Response
  1022.     {
  1023.         $id = $this->getUser()->getId();
  1024.         $returnData = [];
  1025.         $returnData['files'] = [];
  1026.         $returnData['files'][0] = [];
  1028.         /*        $doctrine = $this->getDoctrine()->getManager();
  1029.                 $userProfil = $userProfilRepository->findOneBy(['user' => $id]);*/
  1031.         $uploadFile = $request->files->all()['files'][0];
  1032.         $safeFilename = $slugger->slug($uploadFile->getClientOriginalName());
  1033.         $newFilename = $safeFilename . '-' . md5(uniqid()) . '.' . $uploadFile->guessExtension();
  1034.         $mimeType = $uploadFile->getMimeType();
  1036.         if ($uploadFile->guessExtension() != 'jpg' && $uploadFile->guessExtension() != 'jpeg' && $uploadFile->guessExtension() != 'png') {
  1037.             $returnData['files'][0]['error'] = 'Ungültige Datei';
  1038.             return new JsonResponse($returnData);
  1039.         }
  1041.         try {
  1042.             $filePath = $this->getParameter('user_ordner') . '/' . $id . '/profilbild_original/';
  1043.             $fileSystem = new Filesystem();
  1044.             $fileSystem->remove($filePath);
  1046.             $uploadFile->move($this->getParameter('user_ordner') . '/' . $id . '/profilbild_original/', $newFilename);
  1047.         } catch (FileException $e) {
  1048.             // ... handle exception if something happens during file upload
  1049.             $returnData['files'][0]['error'] = 'Es ist ein Fehler beim Upload aufgetreten';
  1050.             return new JsonResponse($returnData);
  1051.         }
  1053.         //$userProfil->setProfilbild($newFilename);
  1054.         //$doctrine->persist($userProfil);
  1055.         //$doctrine->flush();
  1057.         $returnData['files'][0]['name'] = $newFilename;
  1058.         $returnData['files'][0]['type'] = $mimeType;
  1059.         $returnData['files'][0]['size'] = 0;
  1060.         $returnData['files'][0]['thumbnailUrl'] = $this->generateUrl('user_profilbild_original');
  1062.         return new JsonResponse($returnData);
  1063.     }
  1065.     #[Route('/mein_profil/bearbeiten/upload-cropped', name: 'user_profil_mein_profil_bearbeiten_upload_cropped')]
  1066.     public function schulungUploadCropped(Request                $request, SluggerInterface $slugger,
  1067.                                           UserProfilRepository   $userProfilRepository,
  1068.                                           EntityManagerInterface $entityManager): Response
  1069.     {
  1070.         $id = $this->getUser()->getId();
  1071.         $returnData = [];
  1072.         $returnData['success'] = false;
  1074.         $userProfil = $userProfilRepository->findOneBy(['user' => $id]);
  1076.         $uploadFile = $request->files->all()['croppedImage'];
  1078.         //$filename = md5(uniqid()) . '.png';
  1079.         //$safeFilename = $slugger->slug($uploadFile->getClientOriginalName());
  1080.         $filename = md5(uniqid()) . '.png';
  1082.         if ($uploadFile->guessExtension() != 'png') {
  1083.             $returnData['message'] = 'Ungültige Datei';
  1084.             return new JsonResponse($returnData);
  1085.         }
  1087.         try {
  1088.             $fileSystem = new Filesystem();
  1089.             $filePath = $this->getParameter('user_ordner') . '/' . $id . '/profilbild/';
  1090.             $fileSystem->remove($filePath);
  1092.             $uploadFile->move($this->getParameter('user_ordner') . '/' . $id . '/profilbild/', $filename);
  1094.             $filePath = $this->getParameter('user_ordner') . '/' . $id . '/profilbild_original/';
  1095.             $fileSystem->remove($filePath);
  1096.         } catch (FileException $e) {
  1097.             // ... handle exception if something happens during file upload
  1098.             $returnData['message'] = 'Es ist ein Fehler beim Upload aufgetreten';
  1099.             return new JsonResponse($returnData);
  1100.         }
  1102.         $userProfil->setProfilbild($filename);
  1103.         $entityManager->persist($userProfil);
  1104.         $entityManager->flush();
  1106.         $returnData['success'] = true;
  1107.         return new JsonResponse($returnData);
  1108.     }
  1111.     #[Route('/mein_profil/bearbeiten/profilbild_loeschen', name: 'user_profil_mein_profil_bearbeiten_profilbild_loeschen')]
  1112.     public function user_profil_mein_profil_bearbeiten_profilbild_loeschen(UserProfilRepository   $userProfilRepository,
  1113.                                                                            EntityManagerInterface $entityManager): Response
  1114.     {
  1115.         $id = $this->getUser()->getId();
  1116.         $returnData['error'] = false;
  1117.         $userProfil = $userProfilRepository->findOneBy(['user' => $id]);
  1119.         if ($userProfil != null) {
  1120.             $userProfil->setProfilbild(null);
  1121.             $entityManager->persist($userProfil);
  1122.             $entityManager->flush();
  1123.             try {
  1124.                 $fileSystem = new Filesystem();
  1125.                 $filePath = $this->getParameter('user_ordner') . '/' . $id . '/profilbild/';
  1126.                 $fileSystem->remove($filePath);
  1127.             } catch (FileException $e) {
  1128.                 $returnData['message'] = 'Es ist ein Fehler beim Löschen aufgetreten';
  1129.                 return new JsonResponse($returnData);
  1130.             }
  1131.         }
  1132.         return new JsonResponse($returnData);
  1133.     }
  1136.     // Bild einbinden aus dem var Ordner mit Berechtigungsabfrage
  1137.     #[Route('/mein_profil/profilbild_original', name: 'user_profilbild_original')]
  1138.     public function meinProfilbildOriginal(Request $request, UserProfilRepository $userProfilRepository): Response
  1139.     {
  1140.         $id = $this->getUser()->getId();
  1141.         $folderPath = $this->getParameter('user_ordner') . '/' . $id . '/profilbild_original/';
  1142.         $finder = new Finder();
  1143.         $finder->files()->in($folderPath);
  1144.         $filePath = null;
  1145.         if ($finder->hasResults()) {
  1146.             foreach ($finder as $file) {
  1147.                 $filePath = $file->getRealPath();
  1148.             }
  1149.         }
  1150.         if ($filePath != null) {
  1151.             return new BinaryFileResponse($filePath);
  1152.         }
  1153.         return new JsonResponse('File not found', 404);
  1154.     }
  1157.     #[Route('/mein_profil/zertifikat/interne_schulungen_download/{id}', name: 'user_zertifikat_interne_schulungen_download')]
  1158.     public function user_zertifikat_interne_schulungen_download($id, FirmenInterneSchulungenZertifikatRepository $zertifikatRepository,
  1159.                                                                 FirmenInterneSchulungenRepository $firmenInterneSchulungenRepository): Response
  1160.     {
  1161.         $zertifikat = $zertifikatRepository->findOneBy(['id' => $id, 'user' => $this->getUser()]);
  1162.         $datum = new \DateTime('now', new \DateTimeZone('Europe/Berlin'));
  1163.         $heuteUS = $datum->format("YmdHis");
  1165.         if ($zertifikat != null) {
  1166.             $filePath = $this->getParameter('zertifikat_ordner_user') . '/' . $this->getUser()->getId() . '/zertifikate/' . $id . '.pdf';
  1167.             $schulung = $firmenInterneSchulungenRepository->findOneBy(['id' => $zertifikat->getFirmenSchulungId()]);
  1168.             if ($schulung != null && $schulung->getStatus() == 1) {
  1169.                 $mpdf = new \Mpdf\Mpdf([
  1170.                     'mode' => 'utf-8',
  1171.                     'fontDir' => [
  1172.                         $this->getParameter('font_ordner'),
  1173.                     ],
  1174.                     'fontdata' => [
  1175.                         'roboto' => [
  1176.                             'R' => 'Roboto-Light.ttf',
  1177.                             'B' => 'Roboto-Bold.ttf',
  1178.                             'I' => 'Roboto-Medium.ttf',
  1179.                         ],
  1180.                     ],
  1181.                     'default_font' => 'roboto'
  1182.                 ]);
  1183.                 $mpdf->SetTitle('Zertifikat');
  1184.                 $mpdf->SetAuthor('CELSEO Service GmbH');
  1185.                 $mpdf->SetSubject($zertifikat->getCelseoSchulung()->getTitel());
  1186.                 $mpdf->SetKeywords($zertifikat->getCelseoSchulung()->getSchulungsbereich());
  1188.                 $pagecount = $mpdf->setSourceFile($filePath);
  1189.                 $tplIdx = $mpdf->importPage($pagecount);
  1190.                 $mpdf->useTemplate($tplIdx);
  1191.                 $mpdf->SetWatermarkText('MUSTERZERTIFIKAT');
  1192.                 $mpdf->watermarkTextAlpha = 0.1;
  1193.                 $mpdf->watermarkImageAlpha = 0.5;
  1194.                 $mpdf->showWatermarkText = true;
  1195.                 $mpdf->Output($heuteUS . '_Zertifikat.pdf', \Mpdf\Output\Destination::INLINE);
  1196.                 return new BinaryFileResponse($mpdf);
  1197.             }
  1199.         }
  1201.         return new BinaryFileResponse($filePath);
  1202.     }
  1205.     // Bild einbinden aus dem var Ordner mit Berechtigungsabfrage
  1206.     #[Route('/mein_profil/profilbild', name: 'user_profilbild')]
  1207.     public function meinProfilbild(Request $request, UserProfilRepository $userProfilRepository): Response
  1208.     {
  1209.         $id = $this->getUser()->getId();
  1210.         $userProfil = $userProfilRepository->findOneBy(['user' => $id]);
  1211.         $filePath = $this->getParameter('user_ordner') . '/' . $id . '/profilbild/' . $userProfil->getProfilbild();
  1212.         //return new JsonResponse("", 403);
  1214.         return new BinaryFileResponse($filePath);
  1215.     }
  1218. }