src/Controller/EmailController.php line 133

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Person;
  6. use App\Form\EmailType;
  7. use App\Entity\Attachment;
  8. use App\Entity\Newsletter;
  9. use App\Service\PdfService;
  10. use App\Entity\Dto\EmailDto;
  11. use App\Service\MailerService;
  12. use App\Entity\EmailHistoryEntry;
  13. use App\Repository\PersonRepository;
  14. use App\Service\EmailHistoryService;
  15. use App\Repository\InvoiceRepository;
  16. use App\Repository\NewsletterRepository;
  17. use Doctrine\Persistence\ManagerRegistry;
  18. use App\Repository\ClientConfigRepository;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpFoundation\Response;
  21. use App\Repository\EmailHistoryEntryRepository;
  22. use Symfony\Component\Routing\Annotation\Route;
  23. use App\Repository\CustomerHistoryEntryRepository;
  24. use Symfony\Component\HttpFoundation\File\UploadedFile;
  25. use Menke\UserBundle\Controller\AbstractClientableController;
  26. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  27. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  28. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  30. /**
  31.  * @Route("/email")
  32.  * @IsGranted("ROLE_MANAGER")
  33.  * @IsGranted("ROLE_ADMIN")
  34.  */
  35. class EmailController extends AbstractClientableController
  36. {
  37.     const LISTING_LIMIT = 20;
  39.     private $em;
  41.     public function __construct(ManagerRegistry $em)
  42.     {
  43.         $this->em = $em->getManager();
  44.     }
  46.     /**
  47.      * @Route("/", name="email_index", methods="GET")
  48.      */
  49.     public function index(EmailHistoryEntryRepository $emailHistoryRepo): Response
  50.     {
  51.         $emailEntries = $emailHistoryRepo->getHistoryByClientPaged($this->getCurrentClient(), self::LISTING_LIMIT, 'DESC', 'date', 1);
  53.         return $this->render('email/index.html.twig', [
  54.             'emailEntries' => $emailEntries,
  55.             'total' => $emailEntries->count(),
  56.             'pages' => ceil($emailEntries->count() / self::LISTING_LIMIT),
  57.             'page' => 1,
  58.         ]);
  59.     }
  61.     /**
  62.      * @Route("/{page}/{orderby}/{order}", name="email_index_listing", methods="GET", requirements={"page"="\d+","order"="asc|desc"})
  63.      */
  64.     public function indexListing(EmailHistoryEntryRepository $emailHistoryRepo, $page, $orderby, $order): Response
  65.     {
  66.         $emailEntries = $emailHistoryRepo->getHistoryByClientPaged($this->getCurrentClient(), self::LISTING_LIMIT, $order, $orderby, $page);
  68.         return $this->render('email/_index_listing.html.twig', [
  69.             'emailEntries' => $emailEntries,
  70.             'total' => $emailEntries->count(),
  71.             'pages' => ceil($emailEntries->count() / self::LISTING_LIMIT),
  72.             'page' => $page,
  73.         ]);
  74.     }
  76.     /**
  77.      * @Route("/{id}", name="email_show", methods="GET", requirements={"id"="\d+"})
  78.      */
  79.     public function show(Request $request, EmailHistoryEntry $emailEntry): Response
  80.     {
  81.         $this->denyAccessUnlessGranted('ROLE_MANAGER', $emailEntry);
  83.         return $this->render('email/show.html.twig', [
  84.             'emailEntry' => $emailEntry,
  85.         ]);
  86.     }
  88.     // /**
  89.     //  * @Route("/{id}/attachment", name="email_attachment", methods="GET", requirements={"id"="\d+"})
  90.     //  */
  91.     // public function attachment(Request $request, EmailHistoryEntry $emailEntry): Response
  92.     // {
  93.     //     $this->denyAccessUnlessGranted('ROLE_MANAGER', $emailEntry);
  95.     //     if ($emailEntry->getAttachment() && $emailEntry->getAttachmentName()) {
  96.     //         $file = $this->getParameter('attachment_directory') . '/' . $emailEntry->getAttachment();
  97.     //         $mimeType = mime_content_type($file);
  98.     //         $headers = [
  99.     //             'Content-Type' => $mimeType,
  100.     //             'Content-Disposition' => 'attachment; filename="' . $emailEntry->getAttachmentName() . '"'
  101.     //         ];
  102.     //         return new Response(file_get_contents($file), 200, $headers);
  103.     //     }
  105.     //     return new Response('Die Datei konnte nicht gefunden werden.', 404);
  106.     // }
  108.     /**
  109.      * @Route("/{id}/attachment", name="email_attachment", methods="GET", requirements={"id"="\d+"})
  110.      */
  111.     public function attachment(Request $request, Attachment $attachment): Response
  112.     {
  113.         if ($attachment->getEmailHistoryEntry()) {
  114.             $this->denyAccessUnlessGranted('ROLE_MANAGER', $attachment->getEmailHistoryEntry());
  115.     
  116.             if ($attachment->getName() && $attachment->getPath()) {
  117.                 $file = $attachment->getPath();
  118.                 $mimeType = mime_content_type($file);
  119.                 $headers = [
  120.                     'Content-Type' => $mimeType,
  121.                     'Content-Disposition' => 'attachment; filename="' . $attachment->getName() . '"'
  122.                 ];
  123.                 return new Response(file_get_contents($file), 200, $headers);
  124.             }
  125.         }
  127.         return new Response('Die Datei konnte nicht gefunden werden.', 404);
  128.     }
  130.     /**
  131.      * @Route("/sender/{personId}/{emailAddress}", name="email_sender", methods="GET|POST", requirements={"personId"="\d+"}, defaults={"personId"=0, "email"=""})
  132.      */
  133.     public function sender(Request $request, $personId = 0, $emailAddress = '', MailerService $mailer, EmailHistoryService $emailHistoryService, PersonRepository $personRepo)
  134.     {
  135.         $user = $this->getCurrentUser();
  136.         $email = new EmailDto();
  138.         if ($emailAddress) {
  139.             $email->recipient = $emailAddress;
  140.         } elseif ($personId) {
  141.             $person = $personRepo->findOneBy(['id' => $personId]);
  142.             if ($person && $person->getContactEmail()) {
  143.                 $email->recipientId = $personId;
  144.                 $email->recipient = $person->getContactEmail();
  145.             }
  146.         }
  148.         $form = $this->createForm(EmailType::class, $email, [
  149.             'action' => $this->generateUrl('email_sender'),
  150.         ]);
  151.         $form->handleRequest($request);
  153.         if ($form->isSubmitted() && $form->isValid()) {
  155.             $isTest = false;
  156.             if ($email->testRecipient != '') {
  157.                 $isTest = true;
  158.                 $recipients = [$email->testRecipient];
  159.             } else {
  160.                 $recipients = [$email->recipient];
  161.             }
  162.            
  163.             $attachments = [];
  164.             $this->handleAttachmentUpload($form, $attachments);
  166.             $success = $mailer->sendCustomMessage(
  167.                 $user->getClient(),
  168.                 $email->sender,
  169.                 $email->subject,
  170.                 $email->content,
  171.                 $recipients,
  172.                 $attachments
  173.             );
  175.             if ($success) {
  176.                 $this->addFlash('notice', 'E-Mail wurde versandt.');
  177.                 if (!$isTest) {
  178.                     $people = [];
  179.                     if ($email->recipientId) {
  180.                         $people = $personRepo->findBy(['id' => $email->recipientId]);
  181.                     }
  182.                     $emailHistoryService->saveProtocolEntriesFromEmailDto($email, $attachments, $people, $this->getCurrentUser()->getEmail(), $this->getCurrentClient());
  183.                 }
  184.             } else {
  185.                 $this->addFlash('error', 'Beim E-Mail-Versand ist ein Fehler aufgetreten.');
  186.             }
  188.             return $this->redirectToRoute('customer_index');
  189.         }
  191.         return $this->render('email/sender.html.twig', [
  192.             'email' => $email,
  193.             'form' => $form->createView(),
  194.         ]);
  195.     }
  197.     /**
  198.      * @Route("/sender/multiple", name="email_sender_multiple", methods="GET|POST")
  199.      */
  200.     public function senderMultiple(
  201.         Request $request,
  202.         MailerService $mailer,
  203.         PersonRepository $personRepo,
  204.         EmailHistoryService $emailHistoryService,
  205.         ClientConfigRepository $clientConfigRepo
  206.     ) {
  207.         $user = $this->getCurrentUser();
  208.         $config = $clientConfigRepo->getSingleByClient($this->getCurrentClient());
  209.         $email = new EmailDto();
  211.         $items = $request->request->get('item');
  212.         if ($items) {
  213.             $people = $personRepo->getPeopleByClientAndIds($this->getCurrentClient(), array_keys($items));
  214.             $email->recipients = $people;
  215.         }
  216.         $speakers = $request->request->get('speaker');
  217.         if (empty($email->recipients) && $speakers) {
  218.             $people = $personRepo->getPeopleByClientAndSpeakerIds($this->getCurrentClient(), array_keys($speakers));
  219.             $email->recipients = $people;
  220.         }
  222.         $form = $this->createForm(EmailType::class, $email, [
  223.             'action' => $this->generateUrl('email_sender_multiple'),
  224.             'form_mode' => EmailType::FORM_MODE_MULTIPLE,
  225.             'client' => $this->getCurrentClient(),
  226.         ]);
  227.         $form->handleRequest($request);
  229.         if ($form->isSubmitted() && $form->isValid()) {
  230.             $isTest = false;
  231.             if ($email->testRecipient != '') {
  232.                 $isTest = true;
  233.                 $recipients = ['email' => $email->testRecipient];
  234.                 $subject = '[TEST] '.$email->subject;
  235.             } else {
  236.                 $recipients = $this->parseRecipients($email, $config);
  237.                 $subject = $email->subject;
  238.             }
  240.             $attachments = [];
  241.             $this->handleAttachmentUpload($form, $attachments);
  243.             $success = $mailer->sendIndividualMessage(
  244.                 $user->getClient(),
  245.                 $email->sender,
  246.                 $subject,
  247.                 $email->content,
  248.                 $recipients,
  249.                 $attachments
  250.             );
  252.             if ($success) {
  253.                 $this->addFlash('notice', 'E-Mail wurde versandt.');
  254.                 if (!$isTest) {
  255.                     $emailHistoryService->saveProtocolEntriesFromEmailDto($email, $attachments, $email->recipients, $this->getCurrentUser()->getEmail(), $this->getCurrentClient());
  256.                     return $this->redirectToRoute('customer_index');
  257.                 }
  259.                 $this->addFlash('notice', 'E-Mail wurde versandt.');
  260.             } else {
  261.                 $this->addFlash('error', 'Beim E-Mail-Versand ist ein Fehler aufgetreten.');
  262.             }
  264.            return $this->redirectToRoute('customer_index');
  265.            
  266.         }
  268.         return $this->render('email/sender-multiple.html.twig', [
  269.             'email' => $email,
  270.             'form' => $form->createView(),
  271.         ]);
  272.     }
  274.     /**
  275.      * @Route("/sender/all/{type}", name="email_sender_all", methods="GET|POST")
  276.      */
  277.     public function senderAll(
  278.         Request $request,
  279.         MailerService $mailer,
  280.         PersonRepository $personRepo,
  281.         EmailHistoryService $emailHistoryService,
  282.         ClientConfigRepository $clientConfigRepo,
  283.         NewsletterRepository $newsletterRepository,
  284.         $type
  285.     ) {
  286.         $user = $this->getCurrentUser();
  287.         $config = $clientConfigRepo->getSingleByClient($this->getCurrentClient());
  288.         $email = new EmailDto();
  289.         $recipientEntities = [];
  291.         switch ($type) {
  292.             case 'customer':
  293.                 $recipientEntities = $personRepo->getPersonByClient($this->getCurrentClient(), true);
  294.                 break;
  295.             case 'speaker':
  296.                 $recipientEntities = $personRepo->getPersonByClient($this->getCurrentClient(), false, true);
  297.                 break;
  298.             case 'family':
  299.                 $recipientEntities = $personRepo->getFamilyByClient($this->getCurrentClient());
  300.                 break;
  301.             case 'newsletter':
  302.                 $recipientEntities['persons'] = $personRepo->getNewsletterRecipientsByClient($this->getCurrentClient());
  303.                 $recipientEntities['newsletter_persons'] = $newsletterRepository->getActiveMembers();
  304.                 break;
  305.         }
  306.         $email->recipients = count($recipientEntities) . ' Empfänger';
  308.         if ($type === 'newsletter') {
  309.             $customers = 0;
  310.             $speakers = 0;
  311.             $newsletterPersons = 0;
  313.             foreach ($recipientEntities['persons'] as $recipient) {
  314.                 if ($recipient->isSpeaker()) {
  315.                     $speakers++;
  316.                 } else if ($recipient->isCustomer()) {
  317.                     $customers++;
  318.                 }
  319.             }
  321.             $newsletterPersons = count($recipientEntities['newsletter_persons']);
  323.             $email->recipients .= " (davon {$customers} Kunde(n) und {$speakers} Referent(en)) "
  324.                 . "sowie {$newsletterPersons} Newsletter Abonnenten";
  326.             $recipientEntities = array_merge($recipientEntities['persons'], $recipientEntities['newsletter_persons']);
  327.         }
  329.         $form = $this->createForm(EmailType::class, $email, [
  330.             'action' => $this->generateUrl('email_sender_all', ['type' => $type]),
  331.             'form_mode' => EmailType::FORM_MODE_ALL,
  332.             'client' => $this->getCurrentClient(),
  333.         ]);
  334.         $form->handleRequest($request);
  336.         if ($form->isSubmitted() && $form->isValid()) {
  337.             $email->recipients = $recipientEntities;
  338.             $isTest = false;
  339.             if ($email->action == 'test') {
  340.                 $isTest = true;
  341.                 $recipients = [['email' => $email->testRecipient]];
  342.             } else {
  343.                 $recipients = $this->parseRecipients($email, $config);
  344.             }
  346.             $attachments = [];
  347.             $this->handleAttachmentUpload($form, $attachments);
  349.             $success = $mailer->sendIndividualMessage(
  350.                 $user->getClient(),
  351.                 $email->sender,
  352.                 $email->subject,
  353.                 $email->content,
  354.                 $recipients,
  355.                 $attachments
  356.             );
  358.             if ($success) {
  359.                 $this->addFlash('notice', 'E-Mail wurde versandt.');
  360.                 if (!$isTest) {
  361.                     $emailHistoryService->saveProtocolEntriesFromEmailDto($email, $attachments, $email->recipients, $this->getCurrentUser()->getEmail(), $this->getCurrentClient());
  362.                     return $this->redirectToRoute('customer_index');
  363.                 }
  364.             } else {
  365.                 $this->addFlash('error', 'Beim E-Mail-Versand ist ein Fehler aufgetreten.');
  367.                 return $this->redirectToRoute('customer_index');
  368.             }
  369.         }
  371.         return $this->render('email/sender-multiple.html.twig', [
  372.             'email' => $email,
  373.             'form' => $form->createView(),
  374.         ]);
  375.     }
  377.     protected function parseRecipients(EmailDto $email, $config)
  378.     {
  379.         $recipients = [];
  380.         foreach ($email->recipients as $recipient) {
  381.             if ($recipient instanceof Person) {
  382.                 $recipientItem = [];
  383.                 if ($recipient->getContactEmail()) {
  384.                     $recipientItem['email'] = $recipient->getContactEmail();
  385.                 } elseif ($recipient->getUser() && $recipient->getUser()->getEmail()) {
  386.                     $recipientItem['email'] = $recipient->getUser()->getEmail();
  387.                 } elseif ($recipient->getFamilyMemberOf()) {
  388.                     if ($recipient->getFamilyMemberOf()->getContactEmail()) {
  389.                         $recipientItem['email'] = $recipient->getFamilyMemberOf()->getContactEmail();
  390.                     } elseif ($recipient->getFamilyMemberOf()->getUser() && $recipient->getFamilyMemberOf()->getUser()->getEmail()) {
  391.                         $recipientItem['email'] = $recipient->getFamilyMemberOf()->getUser()->getEmail();
  392.                     }
  393.                 }
  394.             } elseif ($recipient instanceof Newsletter) {
  395.                 $recipientItem['email'] = $recipient->getEmail();
  396.             }
  397.             if (count($recipientItem) > 0) {
  398.                 if ($email->isNewsletter && $recipient->isReceiveNewsletter()) {
  399.                     $hash = md5($recipient->getId() . '_' . $recipient->getCreated()->format('Y-m-d H:i:s'));
  400.                     $link = $this->generateUrl('newsletter_unsubscribe', ['hash' => $hash], UrlGeneratorInterface::ABSOLUTE_URL);
  401.                     $recipientItem['addendum'] = str_ireplace(
  402.                         '[link]',
  403.                         '<a href="' . $link . '" target="_blank">Link</a>',
  404.                         $config->getNewsletterClause()
  405.                     );
  406.                     $recipients[] = $recipientItem;
  407.                 } elseif (!$email->isNewsletter) {
  408.                     $recipients[] = $recipientItem;
  409.                 }
  410.             }
  411.         }
  412.         return $recipients;
  413.     }
  415.     /**
  416.      * @Route("/send-again/{id}", name="email_send_again", methods="GET|POST")
  417.      */
  418.     public function sendHistoryEntryAgain(
  419.         Request $request,
  420.         EmailHistoryEntry $emailEntry,
  421.         MailerService $mailer,
  422.         CustomerHistoryEntryRepository $repo,
  423.         EmailHistoryService $emailHistoryService,
  424.         InvoiceRepository $invoiceRepository,
  425.         PdfService $pdfService
  426.     ) {
  427.         $this->denyAccessUnlessGranted('ROLE_MANAGER', $emailEntry);
  429.         try {
  431.             if ($request->query->has('invoiceId')) {
  433.                 $customerHistoryEntry = $repo->findOneBy(['emailHistoryEntry' => $emailEntry]);
  434.                 $recipients = explode(',', $emailEntry->getRecipients());
  435.                 if ($customerHistoryEntry && count($recipients) > 0) {
  437.                     $invoice = $invoiceRepository->find($request->get('invoiceId'));
  439.                     $pdf = $pdfService->getInvoicePdf($this->getCurrentClient(), $invoice);
  440.                     $sentMessage = $mailer->sendInvoiceEmail(
  441.                         $invoice,
  442.                         'Rechnung-' . $invoice->getNumber() . '.pdf',
  443.                         $pdf->Output('S', 'Rechnung-' . $invoice->getNumber() . '.pdf')
  444.                     );
  446.                     $outputfile = $this->generateUniqueFileName() . '.pdf';
  447.                     $outputpath = $this->getParameter('attachment_directory') . '/' . $outputfile;
  448.                     $pdf->Output('F', $outputpath);
  450.                     $emailHistoryService->saveProtocolEntryFromInvoiceMessage(
  451.                         $invoice,
  452.                         $sentMessage['sender'],
  453.                         $sentMessage['subject'],
  454.                         $sentMessage['message'],
  455.                         $outputfile,
  456.                         'Rechnung-' . $invoice->getNumber() . '.pdf'
  457.                     );
  459.                     $this->addFlash('notice', 'E-Mail wurde versandt.');
  460.                 } else {
  461.                     $this->addFlash('error', 'Diese E-Mail kann nicht versandt werden, weil der Empfänger ungültig ist.');
  462.                 }
  464.                 return $this->redirectToRoute('customer_index');
  465.             }
  467.             $customerHistoryEntry = $repo->findOneBy(['emailHistoryEntry' => $emailEntry]);
  468.             $recipients = explode(',', $emailEntry->getRecipients());
  469.             if ($customerHistoryEntry && count($recipients) > 0) {
  470.                 $recipient = $recipients[0];
  471.                 $mailer->sendPlainMessage(
  472.                     $this->getCurrentClient(),
  473.                     null,
  474.                     $emailEntry->getSubject(),
  475.                     $emailEntry->getContent(),
  476.                     $recipient,
  477.                     $emailEntry->getAttachments()
  478.                 );
  480.                 $emailHistoryService->saveProtocolEntriesFromPerson(
  481.                     $this->getCurrentClient(),
  482.                     $customerHistoryEntry->getCustomer(),
  483.                     $customerHistoryEntry->getType(),
  484.                     $emailEntry->getSubject(),
  485.                     $emailEntry->getContent(),
  486.                     $customerHistoryEntry->getEntry(),
  487.                     null,
  488.                     $emailEntry->getAttachments()
  489.                 );
  491.                 $this->addFlash('notice', 'E-Mail wurde versandt.');
  492.             } else {
  493.                 $this->addFlash('error', 'Diese E-Mail kann nicht versandt werden, weil der Empfänger ungültig ist.');
  494.             }
  495.         } catch (\Exception $e) {
  496.             $this->addFlash('error', 'Beim E-Mail-Versand ist ein Fehler aufgetreten.');
  497.         }
  499.         return $this->redirectToRoute('customer_index');
  500.     }
  504.     protected function handleAttachmentUpload(&$form, &$attachments)
  505.     {
  506.         if ($attachmentsList = $form->get('attachments')->getData()) {
  507.             foreach ($attachmentsList as $attachment) {
  508.                 /** @var UploadedFile */
  509.                 $attachmentName = $attachment->getClientOriginalName();
  510.                 $fileName = $this->generateUniqueFileName() . '.' . $attachment->guessExtension();
  511.     
  512.                 try {
  513.                     $attachment->move(
  514.                         $this->getParameter('attachment_directory'),
  515.                         $fileName
  516.                     );
  517.                     $attachmentPath = $this->getParameter('attachment_directory') . '/' . $fileName;
  518.                     
  519.                     $attachmentModel = new Attachment();
  520.                     $attachmentModel->setName($attachmentName);
  521.                     $attachmentModel->setPath($attachmentPath);
  522.                     $attachmentModel->setCreatedAt(new \DateTimeImmutable());
  523.                     $this->em->persist($attachmentModel);
  524.                     $this->em->flush();
  525.                     $attachments[] = $attachmentModel;
  526.                 } catch (FileException $e) {
  527.                     // ... handle exception if something happens during file upload
  528.                 }
  529.             }
  530.         }
  531.     }
  533.     private function generateUniqueFileName()
  534.     {
  535.         return md5(uniqid());
  536.     }
  537. }