Symfony Profiler

<?php
namespace App\Controller;
use App\Entity\Course;
use App\Entity\CourseData;
use App\Entity\CourseOccurrence;
use App\Entity\Invoice;
use App\Entity\InvoicePayment;
use App\Entity\Order;
use App\Entity\OrderItem;
use App\Entity\OrderItemPerson;
use App\Entity\Presence;
use App\Entity\WaitItem;
use App\Entity\CartItem;
use App\Entity\InvoiceItem;
use App\Entity\CourseSubscriptionBooking;
use App\Form\CourseImagesType;
use App\Form\CourseType;
use App\Repository\CartItemRepository;
use App\Repository\CourseDataRepository;
use App\Repository\CourseFieldRepository;
use App\Repository\CourseOccurrenceRepository;
use App\Repository\CourseOccurrenceTimeRepository;
use App\Repository\CourseRepository;
use App\Repository\InvoiceItemRepository;
use App\Repository\OrderItemPersonRepository;
use App\Repository\OrderItemRepository;
use App\Repository\OrderRepository;
use App\Repository\PersonRepository;
use App\Repository\PresenceReasonRepository;
use App\Repository\PresenceRepository;
use App\Repository\SpeakerRepository;
use App\Repository\TagsPersonRepository;
use App\Repository\TextblocksRepository;
use App\Repository\WaitItemRepository;
use App\Service\CertificatePdfBundleService;
use App\Service\CertificateService;
use App\Service\ConfigurationService;
use App\Service\EmailHistoryService;
use App\Service\Exception\ServiceException;
use App\Service\InvoiceService;
use App\Service\MailerService;
use App\Service\OrderService;
use App\Service\PdfService;
use App\Service\SepaXmlService;
use App\Service\ZoomService;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\Persistence\ManagerRegistry;
use App\User\Controller\AbstractClientableController;
use App\User\Repository\UserRepository;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
/**
* @Route("/course")
*
* @IsGranted("ROLE_SPEAKER")
*/
class CourseController extends AbstractClientableController
{
private $managerRegistry;
private $certificateService;
public function __construct(ManagerRegistry $managerRegistry, CertificateService $certificateService)
{
$this->managerRegistry = $managerRegistry->getManager();
$this->certificateService = $certificateService;
}
public const LISTING_LIMIT = 25;
private function getListingLimit(): int
{
return !empty($_ENV['COURSES_LISTINGLIMIT']) ? (int) $_ENV['COURSES_LISTINGLIMIT'] : 4;
}
/**
* @Route("/", name="course_index", methods="GET")
*/
public function index(
Request $request,
\App\Service\UiService $uiService,
CourseRepository $courseRepository,
PersonRepository $personRepository,
EntityManagerInterface $manager,
SpeakerRepository $speakerRepository,
UserRepository $userRepository,
): Response {
// $this->denyAccessUnlessGranted('ROLE_MANAGER');
$order = $uiService->getSortOrder('course-index-listing');
$archive = !empty($request->get('archive'));
// /////////////////////////////////////////////////////////
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
$speaker = $speakerRepository->getByUser($user);
/*
if ($speaker == null) {
$this->addFlash('error', 'Sie sind kein Speaker');
return $this->redirectToRoute('dashboard');
}else{
$this->addFlash('notice', 'Speaker ID: ' . $speaker->getId().' Person ID'.$user->getId());
}*/
$courses = $courseRepository->getCoursesByClientPaged(
$this->getCurrentClient(),
$this->getListingLimit(),
$order['orderDirection'] ?? 'ASC',
$order['orderBy'] ?? 'title',
1,
$archive,
$speaker,
);
// die Anzahl der Kurse mit den gebuchten überprüfen und die bookedSlots bei den CourseOccurreces aktualisieren
$this->manager = $manager;
foreach ($courses as $course) {
foreach ($course->getOccurrences() as $occurrence) {
$occurrence->setBookedSlots($occurrence->getBookedSlots());
$this->manager->persist($occurrence);
}
}
$this->manager->flush();
if (null == $speaker) {
$render = 'course/index.html.twig';
} else {
$render = 'course/index_speaker.html.twig';
}
// /////////////////////////////////////////
return $this->render($render, [
'uiService' => $uiService,
'courses' => $courses,
'total' => $courses->count(),
'pages' => ceil($courses->count() / $this->getListingLimit()),
'page' => 1,
'archive' => $archive,
'env' => $_ENV,
'user' => $user,
'person' => $person,
]);
}
/**
* @Route("/{page}/{orderby}/{order}", name="course_index_listing", methods="GET", requirements={"page"="\d+","order"="asc|desc"})
*/
public function indexListing(
Request $request,
CourseRepository $courseRepository,
\App\Service\UiService $uiService,
$page,
$orderby,
$order): Response
{
$uiService->storeSortOrder('course-index-listing', $orderby, $order);
$archive = !empty($request->get('archive'));
$courses = $courseRepository->getCoursesByClientPaged($this->getCurrentClient(), $this->getListingLimit(), $order, $orderby, $page, $archive);
return $this->render('course/_index_listing.html.twig', [
'courses' => $courses,
'total' => $courses->count(),
'pages' => ceil($courses->count() / $this->getListingLimit()),
'page' => $page,
'archive' => $archive,
'env' => $_ENV,
]);
}
/**
* @Route("/new", name="course_new", methods="GET|POST")
*/
public function new(
Request $request,
ConfigurationService $configService,
PersonRepository $personRepository): Response
{
$course = new Course();
if (!empty($courseNature = $request->get('courseNature'))) {
$course->setCourseNature($courseNature);
}
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
$form = $this->createForm(CourseType::class, $course, [
'client' => $this->getCurrentClient(),
'taxes' => $configService->getTaxConfigbyClient($this->getCurrentClient()),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$course->setClient($this->getCurrentClient());
$course->setNumber($configService->getNewCourseNumberByClient($this->getCurrentClient()));
foreach ($course->getTexts() as $key => $text) {
$text->setCreated(new \DateTime());
if (empty($text->getOrderId())) {
$text->setOrderId($key + 1000);
}
}
$em = $this->getDoctrine()->getManager();
$course->setCreated(new \DateTime());
$em->persist($course);
$em->flush();
$this->addFlash('success', 'Kurs angelegt');
return $this->redirectToRoute('course-occurrence_new', ['courseId' => $course->getId()]);
}
return $this->render('course/new.html.twig', [
'course' => $course,
'fields' => null,
'form' => $form->createView(),
'user' => $user,
]);
}
/**
* @Route("/{id}/edit", name="course_edit", methods="GET|POST", requirements={"id"="\d+"})
*/
public function edit(
Request $request,
Course $course,
ConfigurationService $configService,
CourseFieldRepository $courseFieldRepository,
CourseDataRepository $courseDataRepository,
PersonRepository $personRepository): Response
{
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
$courseTexts = new ArrayCollection();
foreach ($course->getTexts() as $text) {
$courseTexts->add($text);
}
$form = $this->createForm(CourseType::class, $course, [
'client' => $this->getCurrentClient(),
'taxes' => $configService->getTaxConfigbyClient($this->getCurrentClient()),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$manager = $this->getDoctrine()->getManager();
foreach ($courseTexts as $text) {
if (false === $course->getTexts()->contains($text)) {
$text->setCourse(null);
$manager->remove($text);
}
}
foreach ($course->getTexts() as $key => $text) {
if (empty($text->getOrderId())) {
$text->setCreated(new \DateTime());
$text->setOrderId($key + 1000);
}
$text->setModified(new \DateTime());
}
$fields = $request->request->get('fields');
if (!is_null($fields)) {
foreach ($fields as $fieldId => $value) {
$field = $courseFieldRepository->find($fieldId);
$data = $courseDataRepository->findBy([
'course' => $course,
'field' => $field,
]);
if (0 == count($data)) {
$data = new CourseData();
$data->setClient($this->getCurrentClient());
$data->setCourse($course);
$data->setField($field);
$data->setCreated(new \DateTime());
$manager->persist($data);
} else {
$data = $data[0];
}
$data->setValueText($value);
$data->setModified(new \DateTime());
}
} else {
$fields = [];
}
$course->setModified(new \DateTime());
$manager->flush();
$this->addFlash('notice', 'Kurs gespeichert');
return $this->redirectToRoute('course_edit', ['id' => $course->getId()]);
}
// Fetch course fields
$sql = 'SELECT
f.*,
d.value_text,
d.value_integer,
d.value_date
FROM
course_field f
LEFT JOIN
course_data d
ON
d.field_id = f.id AND
d.course_id = '.$course->getId();
$em = $this->getDoctrine()->getManager();
$stmt = $em->getConnection()->prepare($sql);
$stmt->execute();
$result = $stmt->fetchAll();
$fields = [];
$isset = false;
foreach ($result as $field) {
$isset = false;
if (!empty($field['category'])) {
if (!$course->getCategory()) {
continue;
}
if (!in_array($course->getCategory()->getId(), json_decode($field['category'], true))) {
continue;
} else {
$field = $this->createDescription($field, 'course');
$isset = true;
}
}
if (!empty($field['course_type'])) {
if (!$course->getType()) {
continue;
}
if (!in_array($course->getType()->getId(), json_decode($field['course_type'], true))) {
continue;
} else {
if (!$isset) {
$field = $this->createDescription($field, 'course');
$isset = true;
}
}
}
if (empty($field['category']) && empty($field['course_type']) && !empty($field['certificate'])) {
if (!$isset) {
$field = $this->createDescription($field, 'certificate');
}
}
if (
!empty($field['category'])
|| !empty($field['course_type'])
|| $field['certificate']
) {
$fields[] = $field;
}
}
return $this->render('course/edit.html.twig', [
'course' => $course,
'form' => $form->createView(),
'fields' => $fields,
'env' => $_ENV,
'user' => $user,
]);
}
/**
* @Route("/{id}", name="course_delete", methods="DELETE", requirements={"id"="\d+"})
*/
public function delete(Request $request, Course $course): Response
{
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
if ($this->isCsrfTokenValid('delete'.$course->getId(), $request->request->get('_token'))) {
$em = $this->getDoctrine()->getManager();
// Prüfe Abhängigkeiten vor dem Löschen
$dependencies = $this->checkCourseDependencies($course);
if (!empty($dependencies)) {
$this->addFlash('error', 'Der Kurs kann nicht gelöscht werden, weil folgende Abhängigkeiten existieren:');
foreach ($dependencies as $dependency) {
$this->addFlash('error', $dependency);
}
return $this->redirectToRoute('course_index');
}
$em->remove($course);
try {
$em->flush();
} catch (\Exception $e) {
$errorMessage = $e->getMessage();
if (str_contains($errorMessage, 'Integrity constraint violation')) {
$this->addFlash('error', 'Der Kurs kann nicht gelöscht werden, weil er an anderer Stelle gebraucht wird.');
} else {
$this->addFlash('error', 'Beim Löschen ist ein Fehler aufgetreten.');
}
return $this->redirectToRoute('course_index');
}
$this->addFlash('notice', 'Kurs gelöscht');
}
return $this->redirectToRoute('course_index');
}
/**
* Prüft alle Abhängigkeiten eines Kurses
*/
private function checkCourseDependencies(Course $course): array
{
$dependencies = [];
$em = $this->getDoctrine()->getManager();
// 1. Prüfe Kurstermine mit Buchungen
$occurrences = $course->getOccurrences();
$occurrencesWithBookings = 0;
$totalBookings = 0;
foreach ($occurrences as $occurrence) {
$orderItems = $em->getRepository(OrderItem::class)->findBy(['courseOccurrence' => $occurrence]);
if (count($orderItems) > 0) {
$occurrencesWithBookings++;
$totalBookings += count($orderItems);
}
}
if ($totalBookings > 0) {
$dependencies[] = sprintf(
'• %d Buchung(en) in %d Kurstermin(en)',
$totalBookings,
$occurrencesWithBookings
);
}
// 2. Prüfe Warteliste
$totalWaitItems = 0;
foreach ($occurrences as $occurrence) {
$waitItems = $em->getRepository(WaitItem::class)->findBy(['courseOccurrence' => $occurrence]);
$totalWaitItems += count($waitItems);
}
if ($totalWaitItems > 0) {
$dependencies[] = sprintf('• %d Reservierung(en) auf der Warteliste', $totalWaitItems);
}
// 3. Prüfe Rechnungen
$totalInvoiceItems = 0;
foreach ($occurrences as $occurrence) {
$orderItems = $em->getRepository(OrderItem::class)->findBy(['courseOccurrence' => $occurrence]);
foreach ($orderItems as $orderItem) {
$invoiceItems = $em->getRepository(InvoiceItem::class)->findBy(['orderItem' => $orderItem]);
$totalInvoiceItems += count($invoiceItems);
}
}
if ($totalInvoiceItems > 0) {
$dependencies[] = sprintf('• %d Rechnungsposition(en)', $totalInvoiceItems);
}
// 4. Prüfe Warenkorbeinträge
$totalCartItems = 0;
foreach ($occurrences as $occurrence) {
$cartItems = $em->getRepository(CartItem::class)->findBy(['courseOccurrence' => $occurrence]);
$totalCartItems += count($cartItems);
}
if ($totalCartItems > 0) {
$dependencies[] = sprintf('• %d Warenkorb-Eintrag/Einträge', $totalCartItems);
}
// 5. Prüfe Kursabo-Buchungen
$subscriptionBookings = $em->getRepository(CourseSubscriptionBooking::class)->findBy(['course' => $course]);
if (count($subscriptionBookings) > 0) {
$dependencies[] = sprintf('• %d Kursabo-Buchung(en)', count($subscriptionBookings));
}
return $dependencies;
}
/**
* @Route("/{id}/copy", name="course_copy", methods={"POST","GET"}, requirements={"id"="\d+"})
*/
public function copy(
Request $request,
Course $course,
ConfigurationService $configService,
CourseDataRepository $courseDataRepository,
): Response {
$em = $this->getDoctrine()->getManager();
$client = $this->getCurrentClient();
$withOccurrences = (bool) $request->query->get('withOccurrences', false);
// --- NEUEN KURS ANLEGEN & Basisfelder kopieren ---
$new = new Course();
$new->setClient($client);
$new->setNumber($configService->getNewCourseNumberByClient($client));
$new->setCourseNature($course->getCourseNature());
// Primitive/Relationen 1:1 übernehmen
$new->setTitle($course->getTitle().' (Kopie)');
$new->setSubtitle($course->getSubtitle());
$new->setDescription($course->getDescription());
$new->setPrice($course->getPrice() ?? 0.0);
$new->setTaxRate($course->getTaxRate() ?? 0.0);
$new->setCategory($course->getCategory());
$new->setSeries($course->getSeries());
$new->setType($course->getType());
$new->setSubscription($course->getSubscription());
$new->setMaterialCost($course->getMaterialCost());
$new->setTargetAgeMin($course->getTargetAgeMin());
$new->setTargetAgeMax($course->getTargetAgeMax());
$new->setInvoiceUpperComment($course->getInvoiceUpperComment());
$new->setInvoiceLowerComment($course->getInvoiceLowerComment());
$new->setInvoiceLowerCommentDebit($course->getInvoiceLowerCommentDebit());
// --- TEXTE kopieren ---
foreach ($course->getTexts() as $idx => $oldText) {
$text = new \App\Entity\CourseText();
// Felder vorsichtig kopieren – passe an deine CourseText-Entity an:
$text->setCourse($new);
$text->setCreated(new \DateTime());
// Häufige Felder (falls vorhanden):
if (method_exists($oldText, 'getTitle') && method_exists($text, 'setTitle')) {
$text->setTitle($oldText->getTitle());
}
if (method_exists($oldText, 'getContent') && method_exists($text, 'setContent')) {
$text->setContent($oldText->getContent());
}
// Reihenfolge stabil halten
$order = method_exists($oldText, 'getOrderId') ? $oldText->getOrderId() : ($idx + 1000);
if (method_exists($text, 'setOrderId')) {
$text->setOrderId($order);
}
$text->setCreated(new \DateTime());
$text->setModified(new \DateTime());
$new->addText($text);
}
// --- BILDER kopieren ---
$fs = new Filesystem();
$publicDir = rtrim($this->getParameter('kernel.project_dir'), '/').'/public';
$dirRel = 'images/kurse'; // fixer Web-Pfad relativ zu /public
$dirAbs = $publicDir.'/'.$dirRel; // absoluter Ziel/Quell-Pfad
$fs->mkdir($dirAbs); // sicherstellen, dass es existiert
foreach ($course->getImages() as $idx => $oldImage) {
$img = new \App\Entity\CourseImage();
$img->setCourse($new);
// --- Meta übernehmen ---
if (method_exists($oldImage, 'getTitle') && method_exists($img, 'setTitle')) {
$img->setTitle($oldImage->getTitle());
}
if (method_exists($oldImage, 'getAuthor') && method_exists($img, 'setAuthor')) {
$img->setAuthor($oldImage->getAuthor());
}
if (method_exists($oldImage, 'getDescription') && method_exists($img, 'setDescription')) {
$img->setDescription($oldImage->getDescription());
}
if (method_exists($oldImage, 'getOrderId') && method_exists($img, 'setOrderId')) {
$img->setOrderId($oldImage->getOrderId() ?? ($idx + 1000));
} elseif (method_exists($img, 'setOrderId')) {
$img->setOrderId($idx + 1000);
}
if (method_exists($img, 'setCreated')) {
$img->setCreated(new \DateTime());
}
if (method_exists($img, 'setModified')) {
$img->setModified(new \DateTime());
}
// --- Quelldateiname ermitteln (in deiner DB steht nur der Name) ---
$srcName = null;
if (method_exists($oldImage, 'getImage')) {
$srcName = $oldImage->getImage(); // z. B. "bild.jpg"
} elseif (method_exists($oldImage, 'getPath')) {
// Falls früher mal ein Pfad gespeichert wurde, auf Dateinamen reduzieren
$srcName = basename((string) $oldImage->getPath());
}
if ($srcName) {
// Normalize (Backslashes etc. entfernen, nur Name behalten)
$srcName = basename(str_replace('\\', '/', trim($srcName)));
// Primäre Quelle: /public/Images/Kurse/<Datei>
$srcAbs = $dirAbs.'/'.$srcName;
// Optionaler Fallback: falls Altbestand unter kleinem Pfad lag
if (!$fs->exists($srcAbs)) {
$lowerAbs = $publicDir.'/images/kurse/'.$srcName;
if ($fs->exists($lowerAbs)) {
$srcAbs = $lowerAbs;
}
}
if ($fs->exists($srcAbs)) {
$pi = pathinfo($srcAbs);
$ext = isset($pi['extension']) && '' !== $pi['extension'] ? '.'.$pi['extension'] : '';
$newFilename = ($pi['filename'] ?? 'image').'-copy-'.bin2hex(random_bytes(4)).$ext;
$dstAbs = $dirAbs.'/'.$newFilename;
// Datei physisch duplizieren
$fs->copy($srcAbs, $dstAbs, true);
// In die Entität NUR den Dateinamen schreiben
if (method_exists($img, 'setImage')) {
$img->setImage($newFilename);
} elseif (method_exists($img, 'setPath')) {
$img->setPath($newFilename);
}
} else {
// Quelle nicht gefunden → Originalnamen übernehmen (kein physisches Duplikat möglich)
if (method_exists($img, 'setImage')) {
$img->setImage($srcName);
} elseif (method_exists($img, 'setPath')) {
$img->setPath($srcName);
}
// Optional: $this->addFlash('warning', "Bild nicht gefunden: {$srcName}");
}
}
$new->addImage($img);
}
// --- (OPTIONAL) OCCURRENCES kopieren ---
if ($withOccurrences) {
foreach ($course->getAllOccurrences(false, false) as $oldOcc) {
$occ = new CourseOccurrence();
$occ->setCourse($new);
// Typische Felder – bitte an deine Entity anpassen:
if (method_exists($occ, 'setStart') && method_exists($oldOcc, 'getStart')) {
$occ->setStart($oldOcc->getStart());
}
if (method_exists($occ, 'setEnd') && method_exists($oldOcc, 'getEnd')) {
$occ->setEnd($oldOcc->getEnd());
}
if (method_exists($occ, 'setVenue') && method_exists($oldOcc, 'getVenue')) {
$occ->setVenue($oldOcc->getVenue());
}
if (method_exists($occ, 'setPublished') && method_exists($oldOcc, 'getPublished')) {
$occ->setPublished(false); // Sicherer Default: nicht sofort veröffentlichen
}
if (method_exists($occ, 'setSlots') && method_exists($oldOcc, 'getSlots')) {
$occ->setSlots($oldOcc->getSlots());
}
// Übernehme weitere Felder
if (method_exists($occ, 'setSlots') && method_exists($oldOcc, 'getSlots')) {
$occ->setSlots($oldOcc->getSlots());
}
if (method_exists($occ, 'setCode') && method_exists($oldOcc, 'getCode')) {
$occ->setCode($oldOcc->getCode());
}
if (method_exists($occ, 'setReservationAllowed') && method_exists($oldOcc, 'getReservationAllowed')) {
$occ->setReservationAllowed($oldOcc->getReservationAllowed());
}
if (method_exists($occ, 'setPrice') && method_exists($oldOcc, 'getPrice')) {
$occ->setPrice($oldOcc->getPrice());
}
if (method_exists($occ, 'setTaxRate') && method_exists($oldOcc, 'getTaxRate')) {
$occ->setTaxRate($oldOcc->getTaxRate());
}
if (method_exists($occ, 'setMaterialCost') && method_exists($oldOcc, 'getMaterialCost')) {
$occ->setMaterialCost($oldOcc->getMaterialCost());
}
if (method_exists($occ, 'setNumber') && method_exists($oldOcc, 'getNumber')) {
$occ->setNumber($oldOcc->getNumber());
}
if (method_exists($occ, 'setCreated')) {
$occ->setCreated(new \DateTime());
}
if (method_exists($occ, 'setVenueRoom') && method_exists($oldOcc, 'getVenueRoom')) {
$occ->setVenueRoom($oldOcc->getVenueRoom());
}
$new->addOccurrence($occ);
}
}
// --- COURSE_DATA (dynamische Felder) kopieren ---
$oldDataList = $courseDataRepository->findBy(['course' => $course]);
foreach ($oldDataList as $old) {
$data = new CourseData();
$data->setClient($client);
$data->setCourse($new);
$data->setField($old->getField()); // funktioniert jetzt
$data->setCreated(new \DateTime());
$data->setModified(new \DateTime());
if (method_exists($old, 'getValueText')) {
$data->setValueText($old->getValueText());
}
if (method_exists($old, 'getValueInteger')) {
$data->setValueInteger($old->getValueInteger());
}
if (method_exists($old, 'getValueDate')) {
$data->setValueDate($old->getValueDate());
}
$em->persist($data);
}
$new->setCreated(new \DateTime());
$em->persist($new);
$em->flush();
$this->addFlash('success', 'Kurs kopiert');
return $this->redirectToRoute('course_edit', ['id' => $new->getId()]);
}
/**
* @Route("/multiple", name="course_delete-multiple", methods="DELETE")
*/
public function deleteMultiple(
Request $request,
CourseRepository $courseRepo,
CartItemRepository $cartItemRepo,
WaitItemRepository $waitItemRepo,
OrderItemRepository $orderItemRepo): Response
{
if ($this->isCsrfTokenValid('delete_courses', $request->request->get('_token'))) {
$em = $this->getDoctrine()->getManager();
$deleteIds = $request->request->get('delete');
// Prüfe zuerst alle Kurse auf Abhängigkeiten
$coursesWithDependencies = [];
foreach ($deleteIds as $id => $value) {
if ($value) {
$course = $courseRepo->find($id);
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
$dependencies = $this->checkCourseDependencies($course);
if (!empty($dependencies)) {
$coursesWithDependencies[$course->getTitle()] = $dependencies;
}
}
}
// Wenn Abhängigkeiten existieren, zeige sie an
if (!empty($coursesWithDependencies)) {
$this->addFlash('error', 'Folgende Kurse können nicht gelöscht werden:');
foreach ($coursesWithDependencies as $courseTitle => $dependencies) {
$this->addFlash('error', sprintf('"%s":', $courseTitle));
foreach ($dependencies as $dependency) {
$this->addFlash('error', ' ' . $dependency);
}
}
return $this->redirectToRoute('course_index');
}
// Lösche Kurse ohne Abhängigkeiten
foreach ($deleteIds as $id => $value) {
if ($value) {
$course = $courseRepo->find($id);
$waitItems = $waitItemRepo->findBy(['course' => $course]);
foreach ($waitItems as $waitItem) {
$em->remove($waitItem);
}
$cartItems = $cartItemRepo->findBy(['course' => $course]);
foreach ($cartItems as $cartItem) {
$em->remove($cartItem);
}
$orderItems = $orderItemRepo->findBy(['course' => $course]);
foreach ($orderItems as $orderItem) {
$orderItem->setCourseOccurrence(null);
}
$em->remove($course);
}
}
try {
$em->flush();
} catch (\Exception $e) {
$errorMessage = $e->getMessage();
if (str_contains($errorMessage, 'Integrity constraint violation')) {
$this->addFlash('error', 'Mindestens ein Kurs kann nicht gelöscht werden, weil er an anderer Stelle gebraucht wird.');
} else {
$this->addFlash('error', 'Beim Löschen ist ein Fehler aufgetreten.');
}
return $this->redirectToRoute('course_index');
}
$this->addFlash('notice', count($deleteIds) > 1 ? 'Kurse gelöscht' : 'Kurs gelöscht');
}
return $this->redirectToRoute('course_index');
}
/**
* @Route("/{id}/occurrences", name="course_occurrences", methods="GET", requirements={"id"="\d+"})
*/
public function courseOccurrences(
Request $request,
Course $course,
CourseOccurrenceRepository $repo,
\App\Service\UiService $uiService,
PersonRepository $personRepository): Response
{
// $this->denyAccessUnlessGranted('ROLE_MANAGER', $course);
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
$order = $uiService->getSortOrder('course-occurrences-listing');
$archive = !empty($request->get('archive'));
$occurrences = $repo->findByCoursePaged(
$course,
self::LISTING_LIMIT,
$order['orderDirection'] ?? 'ASC',
$order['orderBy'] ?? 'title'
);
return $this->render('course/occurrences.html.twig', [
'uiService' => $uiService,
'course' => $course,
'user' => $user,
'occurrences' => $occurrences->getIterator(),
'total' => $occurrences->count(),
'pages' => self::LISTING_LIMIT > 0
? ceil($occurrences->count() / self::LISTING_LIMIT)
: 1, // Fallback, wenn LISTING_LIMIT 0 ist
'page' => 1,
'env' => $_ENV,
'archive' => $archive,
]);
}
/**
* @Route("/{id}/occurrences/{page}/{orderby}/{order}/{search}", name="course_occurrences_listing", methods="GET", defaults={"search"="", "order"="desc", "orderby"="start"}, requirements={"id"="\d+"})
*/
public function courseOccurrencesListing(
Request $request,
Course $course,
$page,
$orderby,
$order,
$search,
CourseOccurrenceRepository $repo,
\App\Service\UiService $uiService): Response
{
// $this->denyAccessUnlessGranted('ROLE_MANAGER', $course);
$uiService->storeSortOrder('course-occurrences-listing', $orderby, $order);
$occurrences = $repo->findByCoursePaged($course, self::LISTING_LIMIT, $order, $orderby, $page, $search);
return $this->render('course/tabs/_occurrences_listing.html.twig', [
'course' => $course,
'occurrences' => $occurrences->getIterator(),
'total' => $occurrences->count(),
'pages' => ceil($occurrences->count() / self::LISTING_LIMIT),
'page' => $page,
'env' => $_ENV,
]);
}
/**
* @Route("/{id}/images", name="course_images", methods="GET|POST", requirements={"id"="\d+"})
*/
public function courseImages(
Request $request,
Course $course,
PersonRepository $personRepository,
) {
// $this->denyAccessUnlessGranted('ROLE_MANAGER', $course);
$courseImages = new ArrayCollection();
foreach ($course->getImages() as $image) {
$courseImages->add($image);
}
$form = $this->createForm(CourseImagesType::class, $course);
$form->handleRequest($request);
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
if ($form->isSubmitted() && $form->isValid()) {
$manager = $this->getDoctrine()->getManager();
foreach ($courseImages as $image) {
$image->setCreated(new \DateTime());
if (false === $course->getImages()->contains($image)) {
$image->setCourse(null);
$manager->remove($image);
}
}
foreach ($course->getImages() as $key => $image) {
// Setze das `created`-Datum, falls es nicht gesetzt wurde
if (null === $image->getCreated()) {
$image->setCreated(new \DateTime());
}
// Setze die Reihenfolge, falls `orderId` leer ist
if (empty($image->getOrderId())) {
$image->setOrderId($key + 1000);
}
}
$manager->flush();
$this->addFlash('notice', 'Kursbilder gespeichert');
return $this->redirectToRoute('course_images', ['id' => $course->getId()]);
}
return $this->render('course/images.html.twig', [
'course' => $course,
'form' => $form->createView(),
'env' => $_ENV,
'user' => $user,
]);
}
/**
* @Route("/{id}/invoices", name="course_invoices", methods="GET", requirements={"id"="\d+"})
*/
public function courseInvoices(
Request $request,
Course $course,
OrderItemRepository $repo,
OrderService $orderService,
TagsPersonRepository $tagsPersonRepository,
PersonRepository $personRepository,
) {
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
$orderItems = $repo->findByCoursePaged($course);
/**
* The display logic of subscription courses is different, as there only one order exists per
* customer/participant, but they should appear in every following course occurrence until they cancel.
*/
// if ($course->getCourseNature() === 'CourseSubscription') {
// return $this->render('course/invoices-subscription.html.twig', [
// 'course' => $course,
// 'orderItems' => $orderItems->getIterator(),
// ]);
// } else {
$archive = !empty($request->get('archive'));
if ('CourseSubscription' === $course->getCourseNature()) {
foreach ($orderItems as $orderItem) {
$orderItem->isAfterCancelDate = $orderService->isOrderItemOccurrenceAfterCancelDateByParticipant($this->getCurrentClient(), $orderItem);
}
}
return $this->render('course/invoices.html.twig', [
'tagsPerson' => $tagsPersonRepository->findAll(),
'course' => $course,
'orderItems' => $orderItems->getIterator(),
'archive' => $archive,
'user' => $user,
]);
// }
}
/**
* @Route("/{id}/invoices/create", name="course_create_invoices", methods="POST", requirements={"id"="\d+"})
*/
public function courseCreateInvoices(
Request $request,
Course $course,
OrderItemRepository $itemRepo,
InvoiceService $invoiceService,
) {
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
if ($this->isCsrfTokenValid('create_invoices', $request->request->get('_token'))) {
$em = $this->getDoctrine()->getManager();
$createIds = $request->request->get('create');
$count = 0;
if (!empty($createIds)) {
foreach ($createIds as $id => $value) {
if ($value) {
$orderItem = $itemRepo->find($id);
$results = $invoiceService->createInvoiceFromOrderItem($orderItem);
foreach ($results['attendees'] as $attendee) {
$em->persist($attendee);
}
$em->persist($results['invoice']);
$em->flush();
++$count;
}
}
$em->flush();
}
$this->addFlash('notice', $count.(1 === $count ? ' Rechnung' : ' Rechnungen').' erstellt');
}
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
/**
* @Route("/{id}/invoices/merge-pdf", name="course_invoices_merge-pdf", methods="POST", requirements={"id"="\d+"})
*/
public function courseMergePdf(
Request $request,
Course $course,
OrderItemRepository $repo,
PdfService $pdfService,
) {
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
if ($this->isCsrfTokenValid('create_invoices', $request->request->get('_token'))) {
$em = $this->getDoctrine()->getManager();
$mergeIds = $request->request->get('close');
if (!empty($mergeIds)) {
$mergeInvoices = new ArrayCollection();
foreach ($mergeIds as $id => $value) {
if ($value) {
$orderItem = $repo->find($id);
$order = $orderItem->getOrder();
foreach ($order->getInvoices() as $invoice) {
if (!$mergeInvoices->contains($invoice)) {
$mergeInvoices->add($invoice);
}
}
}
}
$pdf = $pdfService->getMergedInvoicePdf($this->getCurrentClient(), $mergeInvoices->toArray());
$pdf->Output('D', 'Rechnungen_'.date('Y-m-d_H-i').'.pdf');
exit;
} else {
$this->addFlash('notice', 'Keine Rechnungen ausgewählt.');
}
}
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
/**
* @Route("/{id}/invoices/close", name="course_close_invoices", methods="POST", requirements={"id"="\d+"})
*/
public function courseCloseInvoices(
Request $request,
Course $course,
InvoiceItemRepository $repo,
ConfigurationService $configService,
MailerService $mailer,
PdfService $pdfService,
EmailHistoryService $emailHistoryService,
) {
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
if ($this->isCsrfTokenValid('create_invoices', $request->request->get('_token'))) {
$em = $this->getDoctrine()->getManager();
$closeIds = $request->request->get('close');
$count = 0;
if (!empty($closeIds)) {
foreach ($closeIds as $id => $value) {
if ($value) {
$invoiceItem = $repo->findOneBy(['orderItem' => $id]);
$invoice = $invoiceItem->getInvoice();
if (Invoice::STATUS_DRAFT == $invoice->getStatus()) {
$pdf = $pdfService->getInvoicePdf($this->getCurrentClient(), $invoice);
$sentMessage = $mailer->sendInvoiceEmail(
$invoice,
'Rechnung-'.$invoice->getNumber().'.pdf',
$pdf->Output('S', 'Rechnung-'.$invoice->getNumber().'.pdf')
);
$outputfile = $this->generateUniqueFileName().'.pdf';
$outputpath = $this->getParameter('attachment_directory').'/'.$outputfile;
$pdf->Output('F', $outputpath);
$emailHistoryService->saveProtocolEntryFromInvoiceMessage(
$invoice,
$sentMessage['sender'],
$sentMessage['subject'],
$sentMessage['message'],
$outputfile,
'Rechnung-'.$invoice->getNumber().'.pdf'
);
if (Invoice::STATUS_CLOSED != $invoice->getStatus()) {
if ($invoice->isPaymentDebit()) {
$invoice->setStatus(Invoice::STATUS_DEBIT_PENDING);
} else {
$invoice->setStatus(Invoice::STATUS_CLOSED);
}
}
++$count;
} else {
// Send invoice again
$pdf = $pdfService->getInvoicePdf($this->getCurrentClient(), $invoice);
$sentMessage = $mailer->sendInvoiceEmail(
$invoice,
'Rechnung-'.$invoice->getNumber().'.pdf',
$pdf->Output('S', 'Rechnung-'.$invoice->getNumber().'.pdf')
);
++$count;
}
// Update the order status
$newOrderState = $invoice->getOrder()->setStatus(Order::STATUS_DONE);
$em->persist($newOrderState);
$em->flush();
}
}
}
$this->addFlash('notice', $count.(1 === $count ? ' Rechnung' : ' Rechnungen').' versendet');
}
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
/**
* @Route("/{id}/invoices/close-sepa/{all}", name="course_close_sepa-invoices", defaults={"all"="false"},methods="POST", requirements={"id"="\d+"})
*/
public function courseCloseSepaInvoices(
Request $request,
Course $course,
$all = false,
OrderRepository $repo,
OrderItemRepository $itemRepo,
ConfigurationService $configService,
SepaXmlService $sepaXmlService,
) {
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
if ($this->isCsrfTokenValid('create_invoices', $request->request->get('_token'))) {
$em = $this->getDoctrine()->getManager();
$closeIds = $request->request->get('close');
$invoicesToExport = new ArrayCollection();
if ($all) {
$orderItems = $itemRepo->findByCoursePaged($course);
foreach ($orderItems as $orderItem) {
$order = $orderItem->getOrder();
foreach ($order->getInvoices() as $invoice) {
if (
$invoice->containsCourse($course)
&& !$invoicesToExport->contains($invoice)
&& $invoice->isPaymentDebit()
) {
$invoicesToExport->add($invoice);
$invoice->setStatus(Invoice::STATUS_CLOSED);
if (!$order->getCustomer()->getDebitActive()) {
$order->getCustomer()->setDebitActive(true);
$invoice->setIsNewSepaMandate(true);
}
}
if (!empty($_ENV['SEPAEXPORT_PAYED'])) {
$restsumme = $invoice->getMissingSum();
if (0 != $restsumme) {
$invoicePayment = new InvoicePayment();
$invoicePayment->setInvoice($invoice);
$invoicePayment->setPayedDate(new \DateTime());
$invoicePayment->setSum($invoice->getMissingSum());
$invoice->setPaymentStatus(Invoice::FULLY_PAID);
$invoice->setExportStatus(Invoice::EXPORTED);
$em = $this->getDoctrine()->getManager();
$em->persist($invoicePayment);
}
$invoice->setPaymentStatus(Invoice::FULLY_PAID);
$invoice->setExportStatus(Invoice::EXPORTED);
$em->persist($invoice);
$em->flush();
}
}
}
} elseif (!empty($closeIds)) {
foreach ($closeIds as $id => $value) {
if ($value) {
$orderItem = $itemRepo->find($id);
$order = $orderItem->getOrder();
foreach ($order->getInvoices() as $invoice) {
if (
$invoice->containsCourse($course)
&& !$invoicesToExport->contains($invoice)
&& $invoice->isPaymentDebit()
) {
$invoicesToExport->add($invoice);
$invoice->setStatus(Invoice::STATUS_CLOSED);
if (!$order->getCustomer()->getDebitActive()) {
$order->getCustomer()->setDebitActive(true);
$invoice->setIsNewSepaMandate(true);
}
}
}
if (!empty($_ENV['SEPAEXPORT_PAYED'])) {
$restsumme = $invoice->getMissingSum();
if (0 != $restsumme) {
$invoicePayment = new InvoicePayment();
$invoicePayment->setInvoice($invoice);
$invoicePayment->setPayedDate(new \DateTime());
$invoicePayment->setSum($invoice->getMissingSum());
$invoice->setExportStatus(Invoice::EXPORTED);
$em = $this->getDoctrine()->getManager();
$em->persist($invoicePayment);
}
$invoice->setPaymentStatus(Invoice::FULLY_PAID);
$invoice->setExportStatus(Invoice::EXPORTED);
$em->persist($invoice);
$em->flush();
}
}
}
} else {
$this->addFlash('warning', 'Es wurden keine Rechnungen zum Export ausgewählt.');
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
// Check invoices for past due dates
foreach ($invoicesToExport as $invoice) {
if (new \DateTime() > $invoice->getDueDate()) {
$this->addFlash('warning', 'Mindestens eine Rechnung enthält ein Zahlungsziel in der Vergangenheit.');
// return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
}
if (count($invoicesToExport) > 0) {
$config = $configService->getSepaXmlConfigByClient($this->getCurrentClient());
try {
$xml = $sepaXmlService->getSepaXmlMultiple($this->getCurrentClient(), $config, $invoicesToExport);
} catch (ServiceException $e) {
$this->addFlash('error', $e->getMessage());
return $this->redirectToRoute('invoice_index');
}
$em->flush();
$response = new Response($xml);
$response->headers->set('Content-Type', 'text/xml');
$response->headers->set('Content-disposition', 'attachment; filename="SEPA-'.date('Ymd-His').'.xml"');
return $response;
}
$this->addFlash('error', 'Mindestens eine Rechnung enthält Fehler.');
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
$this->addFlash('error', 'Der Sicherheits-Token ist ungültig. Bitte versuchen Sie es noch einmal.');
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
/**
* @Route("/{id}/invoices/close-sepa/", name="course_close_sepa-invoice_selected", methods="POST", requirements={"id"="\d+"})
*/
public function courseCloseSepaInvoiceSelected(
Request $request,
Course $course,
OrderItemRepository $itemRepo,
ConfigurationService $configService,
SepaXmlService $sepaXmlService,
) {
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
if ($this->isCsrfTokenValid('create_invoices', $request->request->get('_token'))) {
$em = $this->getDoctrine()->getManager();
$closeIds = $request->request->get('close');
$invoicesToExport = new ArrayCollection();
if (!empty($closeIds)) {
foreach ($closeIds as $id => $value) {
if ($value) {
$orderItem = $itemRepo->find($id);
$order = $orderItem->getOrder();
foreach ($order->getInvoices() as $invoice) {
if (
$invoice->containsCourse($course)
&& !$invoicesToExport->contains($invoice)
&& $invoice->isPaymentDebit()
) {
$invoicesToExport->add($invoice);
$invoice->setStatus(Invoice::STATUS_CLOSED);
if (!$order->getCustomer()->getDebitActive()) {
$order->getCustomer()->setDebitActive(true);
$invoice->setIsNewSepaMandate(true);
}
}
}
if (!empty($_ENV['SEPAEXPORT_PAYED'])) {
$restsumme = $invoice->getMissingSum();
if (0 != $restsumme) {
$invoicePayment = new InvoicePayment();
$invoicePayment->setInvoice($invoice);
$invoicePayment->setPayedDate(new \DateTime());
$invoicePayment->setSum($invoice->getMissingSum());
$invoice->setExportStatus(Invoice::EXPORTED);
$em = $this->getDoctrine()->getManager();
$em->persist($invoicePayment);
}
$invoice->setPaymentStatus(Invoice::FULLY_PAID);
$invoice->setExportStatus(Invoice::EXPORTED);
$em->persist($invoice);
$em->flush();
}
}
}
} else {
$this->addFlash('warning', 'Es wurden keine Rechnungen zum Export ausgewählt.');
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
// Check invoices for past due dates
foreach ($invoicesToExport as $invoice) {
if (new \DateTime() > $invoice->getDueDate()) {
$this->addFlash('warning', 'Mindestens eine Rechnung enthält ein Zahlungsziel in der Vergangenheit.');
// return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
}
if (count($invoicesToExport) > 0) {
$config = $configService->getSepaXmlConfigByClient($this->getCurrentClient());
try {
$xml = $sepaXmlService->getSepaXmlMultiple($this->getCurrentClient(), $config, $invoicesToExport);
} catch (ServiceException $e) {
$this->addFlash('error', $e->getMessage());
return $this->redirectToRoute('invoice_index');
}
$em->flush();
$response = new Response($xml);
$response->headers->set('Content-Type', 'text/xml');
$response->headers->set('Content-disposition', 'attachment; filename="SEPA-'.date('Ymd-His').'.xml"');
return $response;
}
$this->addFlash('error', 'Mindestens eine Rechnung enthält Fehler.');
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
$this->addFlash('error', 'Der Sicherheits-Token ist ungültig. Bitte versuchen Sie es noch einmal.');
return $this->redirectToRoute('course_invoices', ['id' => $course->getId()]);
}
/**
* @Route("/{id}/participants", name="course_participants", methods="GET", requirements={"id"="\d+"})
*/
public function courseParticipants(
Request $request,
Course $course,
OrderItemRepository $repo,
OrderService $orderService,
TagsPersonRepository $tagsPersonRepository,
PersonRepository $personRepository,
PresenceRepository $presenceRepository,
) {
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
$orderItems = $repo->findByCoursePaged($course);
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
$archive = !empty($request->get('archive'));
if ('CourseSubscription' === $course->getCourseNature()) {
foreach ($orderItems as $orderItem) {
foreach ($orderItem->getParticipants() as $participant) {
$participant->isAfterCancelDate = $orderService->isOrderItemOccurrenceAfterCancelDateByParticipant($this->getCurrentClient(), $orderItem, $participant->getId());
$participant->cancelDate = $orderService->getCancelDateForParticipantInCourse($this->getCurrentClient(), $participant);
}
}
}
$occurrenceIds = [];
foreach ($orderItems as $oi) {
if ($oi->getCourseOccurrence()) {
$occurrenceIds[$oi->getCourseOccurrence()->getId()] = true;
}
}
$occurrenceIds = array_keys($occurrenceIds);
// 2) Alle Presences zu diesen Occurrences in EINER Query holen (mit Reason/Time/Person)
$presences = [];
if (!empty($occurrenceIds)) {
$presences = $presenceRepository->createQueryBuilder('p')
->addSelect('r', 't', 'o', 'per')
->leftJoin('p.presenceReason', 'r')
->leftJoin('p.occurrenceTime', 't')
->leftJoin('p.occurrence', 'o')
->leftJoin('p.person', 'per')
->andWhere('p.occurrence IN (:occIds)')
->setParameter('occIds', $occurrenceIds)
->orderBy('per.lastname', 'ASC')
->getQuery()->getResult();
}
// 3) Aggregation je (Occurrence, Person)
// presenceSummary[occId][personId] = [
// 'present' => int, 'total' => int,
// 'lastAbsentReason' => ?string, 'lastAbsentAt' => ?\DateTimeInterface
// ]
$presenceSummary = [];
foreach ($presences as $p) {
$occId = $p->getOccurrence()->getId();
$person = $p->getPerson();
if (!$person) {
continue;
}
$perId = $person->getId();
if (!isset($presenceSummary[$occId][$perId])) {
$presenceSummary[$occId][$perId] = [
'present' => 0,
'total' => 0,
'lastAbsentReason' => null,
'lastAbsentAt' => null,
'details' => [], // ← NEU
];
}
++$presenceSummary[$occId][$perId]['total'];
$present = (bool) $p->getPresence();
$reason = $p->getPresenceReason() ? $p->getPresenceReason()->getName() : null;
// Datum für Anzeige (Startzeit des Einzeltermins, sonst modified/created)
$dt = $p->getOccurrenceTime() ? $p->getOccurrenceTime()->getStart() : ($p->getModified() ?? $p->getCreated());
$dateStr = $dt ? $dt->format('d.m.Y H:i') : '';
// Details-Zeile hinzufügen (nur Strings/Bool, kein DateTime in JSON)
$presenceSummary[$occId][$perId]['details'][] = [
'date' => $dateStr,
'present' => $present,
'reason' => $present ? null : ($reason ?? ''),
];
if ($present) {
++$presenceSummary[$occId][$perId]['present'];
} else {
// letzte Abwesenheit aktualisieren
$prev = $presenceSummary[$occId][$perId]['lastAbsentAt'];
if ($dt && (!$prev || $dt > $prev)) {
$presenceSummary[$occId][$perId]['lastAbsentAt'] = $dt;
$presenceSummary[$occId][$perId]['lastAbsentReason'] = $reason;
}
}
}
return $this->render('course/participants.html.twig', [
'env' => $_ENV,
'course' => $course,
'orderItems' => $orderItems->getIterator(),
'showCertificatesLink' => !empty($_ENV['CERTIFICATES_ENABLED']),
'archive' => $archive,
'user' => $user,
// ⬇️ neu:
// 'presenceSummary' => $presenceSummary,
]);
}
/**
* @Route("/{id}/participants-pdf/{page}/{orderby}/{order}", name="course_participants_pdf", methods="GET", requirements={"id"="\d+"})
*
* @IsGranted("ROLE_SPEAKER")
*/
public function courseParticipantsPdf(
Request $request,
CourseOccurrence $courseOccurrence,
OrderItemRepository $repo,
PdfService $pdfService,
OrderService $orderService,
$page = 1,
$orderby = 'customerLastname',
$order = 'asc',
) {
// $this->denyAccessUnlessGranted('client_allowed', $courseOccurrence);
// Security: Check client ownership via CourseOccurrenceVoter
$this->denyAccessUnlessGranted('view', $courseOccurrence);
$orderItems = $repo->findByCourseOccurrence($courseOccurrence, $orderby, $order);
if ('CourseSubscription' === $courseOccurrence->getCourse()->getCourseNature()) {
foreach ($orderItems as $orderItem) {
foreach ($orderItem->getParticipants() as $participant) {
$participant->isAfterCancelDate = $orderService->isOrderItemOccurrenceAfterCancelDateByParticipant($this->getCurrentClient(), $orderItem, $participant->getId());
}
}
}
$pdf = $pdfService->getParticipantsPdf($this->getCurrentClient(), $courseOccurrence, $orderItems);
$pdf->Output('D', 'Teilnehmerliste-'.$courseOccurrence->getStart()->format('Y-m-d').'.pdf');
exit;
}
/**
* @Route("/{id}/participants-pdf-esf/{page}/{orderby}/{order}", name="course_participants_pdf_esf", methods="GET", requirements={"id"="\d+"})
*
* @IsGranted("ROLE_SPEAKER")
*/
public function courseParticipantsPdfEsf(
Request $request,
CourseOccurrence $courseOccurrence,
OrderItemRepository $repo,
PdfService $pdfService,
OrderService $orderService,
$page = 1,
$orderby = 'customerLastname',
$order = 'asc',
) {
// $this->denyAccessUnlessGranted('client_allowed', $courseOccurrence);
// Security: Check client ownership via CourseOccurrenceVoter
$this->denyAccessUnlessGranted('view', $courseOccurrence);
$orderItems = $repo->findByCourseOccurrence($courseOccurrence, $orderby, $order);
if ('CourseSubscription' === $courseOccurrence->getCourse()->getCourseNature()) {
foreach ($orderItems as $orderItem) {
foreach ($orderItem->getParticipants() as $participant) {
$participant->isAfterCancelDate = $orderService->isOrderItemOccurrenceAfterCancelDateByParticipant($this->getCurrentClient(), $orderItem, $participant->getId());
}
}
}
$pdf = $pdfService->getParticipantsPdfEsf($this->getCurrentClient(), $courseOccurrence, $orderItems, 'esf');
$pdf->Output('D', 'ESF-Teilnehmerliste-'.$courseOccurrence->getStart()->format('Y-m-d').'.pdf');
exit;
}
/**
* @Route("/participant/certificateemails/{id}", name="course_participants_Zertifikat_emails", methods="GET", requirements={"id"="\d+","downlaod"="\d+"})
*/
public function courseParticipantsCertificateEmails(
Request $request,
$id,
CourseOccurrenceRepository $repo,
ConfigurationService $configService,
TextblocksRepository $textblocksRepository,
CourseDataRepository $courseDataRepository,
OrderItemRepository $orderItemRepo,
$orderby = 'customerLastname',
$order = 'asc'): Response
{
$courseOccurrence = $repo->find($id);
// Security: Check client ownership via CourseOccurrenceVoter
$this->denyAccessUnlessGranted('view', $courseOccurrence);
$orderItems = $orderItemRepo->findByCourseOccurrence($courseOccurrence, $orderby, $order);
foreach ($orderItems as $orderItem) {
$participants = $orderItem->getParticipants();
foreach ($participants as $participant) {
if ('cancelled' === $participant->getStatus() && !$participant->isStillSubscribed($courseOccurrence->getStart())) {
continue;
}
if ('cancelled' === $participant->getStatus()) {
continue;
}
if ((null != $participant->getCancelled()) and ($courseOccurrence->getEnd() > $participant->getCancelled())) {
continue;
}
if (!$participant->getOrderItem()->getOrder()->getCustomer()) {
continue;
}
if ($participant->getOrderItem()->isCancelled()) {
continue;
}
// if (($participant->getOrderItem()->getStatus() === 'partially_cancelled')) continue;
if ($participant->getOrderItem()->getOrder()->isCancelled()) {
continue;
}
if (isset($participant)) {
$orderItemPerson = $participant;
$id = $participant->getId();
$this->certificateService->generateAndSendCertificate(
$request,
$id,
$configService,
$orderItemPerson,
$textblocksRepository,
$courseDataRepository,
$orderItemRepo,
);
}
}
}
return $this->redirectToRoute('course_participants', ['id' => $orderItemPerson->getOrderItem()->getCourse()->getId()]);
}
/**
* @Route("/participant/downloadAllCertificates/{id}", name="course_participants_all_Zertifikat_download", methods="GET", requirements={"id"="\d+","downlaod"="\d+"})
*/
public function downloadAllCertificates(
Request $request,
$id,
CourseOccurrenceRepository $repo,
ConfigurationService $configService,
TextblocksRepository $textblocksRepository,
CourseDataRepository $courseDataRepository,
CertificatePdfBundleService $certificatePdfBundleService,
OrderItemRepository $orderItemRepo,
$orderby = 'customerLastname',
$order = 'asc')
{
$orderby = $request->query->get('orderby', 'customerLastname');
$order = $request->query->get('order', 'asc');
$courseOccurrence = $repo->find($id);
// Security: Check client ownership via CourseOccurrenceVoter
$this->denyAccessUnlessGranted('view', $courseOccurrence);
$orderItems = $orderItemRepo->findByCourseOccurrence($courseOccurrence, $orderby, $order);
// Hier werden die Teilnehmer gefiltert, die ein Zertifikat erhalten sollen
// und die nicht mehr abgemeldet sind oder deren Abmeldung nicht nach dem Kursende liegt.
$filteredParticipants = [];
foreach ($orderItems as $orderItem) {
$participants = $orderItem->getParticipants();
// Filter wie du sie schon hast:
foreach ($participants as $participant) {
if ('cancelled' === $participant->getStatus() && !$participant->isStillSubscribed($courseOccurrence->getStart())) {
continue;
}
if ('cancelled' === $participant->getStatus()) {
continue;
}
if (null != $participant->getCancelled() && $courseOccurrence->getEnd() > $participant->getCancelled()) {
continue;
}
if (!$participant->getOrderItem()->getOrder()->getCustomer()) {
continue;
}
if ($participant->getOrderItem()->isCancelled()) {
continue;
}
if ($participant->getOrderItem()->getOrder()->isCancelled()) {
continue;
}
$filteredParticipants[] = $participant;
}
}
// Optional: Template wählen, Default reicht meist
$viewTemplate = $_ENV['ZERTIFIKAT'] ?? 'Default';
return $certificatePdfBundleService->createPdfForAllParticipants($filteredParticipants, $viewTemplate);
}
/**
* @Route(
* "/participant/certificateemails-selected/{id}",
* name="course_participants_Zertifikat_emails_selected",
* requirements={"id"="\d+"},
* methods={"POST"}
* )
*
* @IsGranted("ROLE_SPEAKER", subject="courseOccurrence")
*/
public function certificateEmailsSelected(
Request $request,
int $id,
CourseOccurrenceRepository $occRepo,
OrderItemPersonRepository $participantRepo,
ConfigurationService $configService,
CertificateService $certificateService,
TextblocksRepository $textRepo,
CourseDataRepository $courseDataRepo,
OrderItemRepository $orderItemRepo): Response
{
// CSRF-Schutz
$this->denyAccessUnlessGranted('ROLE_USER');
if (!$this->isCsrfTokenValid(
'cert_select_'.$id,
$request->request->get('_csrf_token')
)) {
throw $this->createAccessDeniedException('Ungültiges CSRF-Token');
}
$courseOccurrence = $occRepo->find($id);
if (!$courseOccurrence) {
throw $this->createNotFoundException();
}
/** @var int[] $ids */
$ids = $request->request->get('participants', []);
if (!$ids) {
$this->addFlash('warning', 'Es wurde kein Teilnehmer ausgewählt.');
return $this->redirectToRoute(
'course_participants',
['id' => $courseOccurrence->getCourse()->getId()]
);
}
$participants = $participantRepo->findBy(['id' => $ids]);
foreach ($participants as $participant) {
// Sicherheits-Checks: gehört der Teilnehmer zu diesem Termin?
if ($participant->getOrderItem()
->getCourseOccurrence()->getId() !== $id
) {
continue;
}
if ('cancelled' === $participant->getStatus()) {
continue;
}
if ($participant->getCancelled()
&& ($courseOccurrence->getEnd() > $participant->getCancelled())
) {
continue;
}
// Zertifikat erzeugen + mailen
$certificateService->generateAndSendCertificate(
$request,
$id,
$configService,
$participant,
$textRepo,
$courseDataRepo,
$orderItemRepo
);
}
$this->addFlash(
'success',
'Zertifikate wurden an die ausgewählten Teilnehmer versendet.'
);
return $this->redirectToRoute(
'course_participants',
['id' => $courseOccurrence->getCourse()->getId()]
);
}
/**
* @Route("/participant/{id}/certificateemail", name="course_participants_Zertifikat_email", methods="GET", requirements={"id"="\d+","downlaod"="\d+"})
*/
public function courseParticipantsCertificateEmail(
Request $request,
$id,
ConfigurationService $configService,
OrderItemPerson $orderItemPerson,
TextblocksRepository $textblocksRepository,
CourseDataRepository $courseDataRepository,
OrderItemRepository $repo): Response
{
$orderItem = $repo->find($id);
$currentUrl = $request->getUri();
// $orderItemPerson = $orderItemPersonRepository->find($id);
// hier werden die reihenfolge, ANzahl und Namen fü die Tickets vorbereitet
$participants = $orderItemPerson->getOrderItem()->getParticipants();
$searchedName = $id; // Der Name, den du suchst.
$position = null;
$i = 0;
foreach ($participants as $participant) {
++$i;
if ($participant->getId() == $searchedName) {
$position = $i;
break;
}
}
if (null === $position) {
$position = '1';
}
// /
$this->certificateService->generateAndSendCertificate(
$request,
$id,
$configService,
$orderItemPerson,
$textblocksRepository,
$courseDataRepository,
$repo
);
return $this->redirectToRoute('course_participants', ['id' => $orderItemPerson->getOrderItem()->getCourse()->getId()]);
}
/**
* @Route("/{courseId}/participants/certificateemail-multiple", name="course_participants_Zertifikat_emails_multiple", methods={"POST"})
*/
public function sendMultipleCertificates(
$courseId,
Request $request,
ConfigurationService $configService,
OrderItemPersonRepository $orderItemPersonRepository,
TextblocksRepository $textblocksRepository,
CourseDataRepository $courseDataRepository,
OrderItemRepository $orderItemRepository): Response
{
$items = $request->request->get('item'); // kommt als [id => id, ...]
if (!$items) {
$this->addFlash('warning', 'Keine Teilnehmer ausgewählt.');
return $this->redirectToRoute('course_index');
}
$lastOccurrence = null;
$successCount = 0;
foreach (array_keys($items) as $id) {
$participant = $orderItemPersonRepository->find($id);
if (!$participant) {
continue;
}
$orderItem = $participant->getOrderItem();
if (!$orderItem || !$orderItem->getCourseOccurrence()) {
continue;
}
$lastOccurrence = $orderItem->getCourseOccurrence();
// ggf. Zugriffsrechte prüfen
$this->denyAccessUnlessGranted('ROLE_SPEAKER', $lastOccurrence);
// Zertifikat erzeugen und senden
$this->certificateService->generateAndSendCertificate(
$request,
$participant->getId(),
$configService,
$participant,
$textblocksRepository,
$courseDataRepository,
$orderItemRepository
);
++$successCount;
}
$this->addFlash('success', "$successCount Zertifikate wurden versendet.");
return $this->redirectToRoute('course_participants', ['id' => $courseId]);
}
/**
* @Route("/{id}/presences", name="course_presences", methods="GET", requirements={"id"="\d+"})
*/
public function coursePresences(
Request $request,
Course $course,
OrderItemRepository $repo,
OrderService $orderService,
CourseOccurrenceRepository $occurrencesrepo,
TagsPersonRepository $tagsPersonRepository,
\App\Service\UiService $uiService,
PresenceRepository $presenceRepository,
PersonRepository $personRepository,
PresenceReasonRepository $reasonRepo,
SpeakerRepository $speakerRepository)
{
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
// Grunddaten
$orderItems = $repo->findByCoursePaged($course);
$order = $uiService->getSortOrder('course-occurrences-listing');
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
$speaker = $speakerRepository->getByUser($user);
$archive = !empty($request->get('archive'));
// Zusatzinfos für Abo-Kurse
if ('CourseSubscription' === $course->getCourseNature()) {
foreach ($orderItems as $orderItem) {
foreach ($orderItem->getParticipants() as $participant) {
$participant->isAfterCancelDate = $orderService->isOrderItemOccurrenceAfterCancelDateByParticipant(
$this->getCurrentClient(),
$orderItem,
$participant->getId()
);
$participant->cancelDate = $orderService->getCancelDateForParticipantInCourse(
$this->getCurrentClient(),
$participant
);
}
}
}
// Occurrences (paginiert) laden
$occurrences = $occurrencesrepo->findByCoursePaged(
$course,
self::LISTING_LIMIT,
$order['orderDirection'] ?? 'ASC',
$order['orderBy'] ?? 'title'
);
$occArray = iterator_to_array($occurrences->getIterator(), false);
$occIter = new \ArrayIterator($occArray);
// Filtern: nur Occurrences, bei denen der Speaker NICHT zugeordnet ist
if ($speaker) {
$filteredOccurrences = [];
foreach ($occurrences as $occurrence) {
if (in_array($speaker, $occurrence->getSpeakers()->toArray())) {
$filteredOccurrences[] = $occurrence;
}
}
// Erstelle neuen Iterator mit gefilterten Daten
$occurrences = new \ArrayIterator($filteredOccurrences);
}
// Wir brauchen ein *stabiles* Array der Occurrences (für IN()-Query und fürs Template)
// Abwesenheitsgründe
$reasons = $reasonRepo->createQueryBuilder('r')
->andWhere('r.active = :a')->setParameter('a', true)
->orderBy('r.sort', 'ASC')->addOrderBy('r.name', 'ASC')
->getQuery()->getResult();
// Presences nur für die gelisteten Occurrences laden (inkl. Beziehungen, um N+1 zu vermeiden)
$presences = [];
if (!empty($occArray)) {
$presences = $presenceRepository->createQueryBuilder('p')
->addSelect('r', 't', 'o', 'per')
->leftJoin('p.presenceReason', 'r')
->leftJoin('p.occurrenceTime', 't')
->leftJoin('p.occurrence', 'o')
->leftJoin('p.person', 'per')
->andWhere('p.occurrence IN (:occs)')
->setParameter('occs', $occArray) // ENTITÄTEN sind ok als Parameter
->orderBy('per.lastname', 'ASC')
->getQuery()->getResult();
}
// Index: [occId][timeId][personId] => Presence
$presenceIndex = [];
foreach ($presences as $p) {
// Falls in deiner DB occurrenceTime/person garantiert NOT NULL ist, brauchst du die Checks nicht
if (!$p->getOccurrence() || !$p->getOccurrenceTime() || !$p->getPerson()) {
continue;
}
$oid = $p->getOccurrence()->getId();
$tid = $p->getOccurrenceTime()->getId();
$pid = $p->getPerson()->getId();
$presenceIndex[$oid][$tid][$pid] = $p;
}
return $this->render('course/presences.html.twig', [
// KEIN 'presences' => findAll() mehr!
'presenceIndex' => $presenceIndex,
'uiService' => $uiService,
'tagsPerson' => $tagsPersonRepository->findAll(),
'env' => $_ENV,
'course' => $course,
'occurrences' => $occurrences, // stabiles Array
'total' => $occurrences->count(),
'pages' => ceil($occurrences->count() / self::LISTING_LIMIT),
'page' => 1,
'orderItems' => $orderItems->getIterator(),
'showCertificatesLink' => !empty($_ENV['CERTIFICATES_ENABLED']),
'archive' => $archive,
'user' => $user,
'person' => $person,
'reasons' => $reasons,
]);
}
/**
* @Route("/coursepresence/{id}/add/{courseOccurrence}/{participant}", name="course_presence_add", methods="GET|POST")
*/
public function savePresenseNew(
$id,
$courseOccurrence,
$participant,
CourseOccurrenceTimeRepository $occurrenceTimeRepository,
CourseOccurrenceRepository $occurrenceRepository,
PersonRepository $personRepository,
) {
$occurrenceTime = $occurrenceTimeRepository->find($id);
$occurrence = $occurrenceRepository->find($courseOccurrence);
$user = $this->getCurrentUser();
// $person = $personRepository->getByUser($user);
$person = $personRepository->find($participant);
$newpresence = new Presence();
$newpresence->setOccurrence($occurrence);
$newpresence->setOccurrenceTime($occurrenceTime);
$newpresence->setUser($user);
$newpresence->setPerson($person);
$newpresence->setPresence('1');
$newpresence->setCreated(new \DateTime());
$newpresence->setClient($this->getCurrentClient());
$this->managerRegistry->persist($newpresence);
$this->managerRegistry->flush();
return $this->json([
'success' => 'Die Anwesenheit wurde eingetragen.',
'presence' => true,
]);
}
/**
* @Route("/coursepresence/{id}/delete", name="course_presence_delete", methods="GET|POST")
*/
public function deletePresense(
$id,
PresenceRepository $presenceRepository): Response
{
$presence = $presenceRepository->find($id);
// $presenceRepository->remove($presenceremove);
$presence->setPresence('0');
$presence->setModified(new \DateTime());
$this->managerRegistry->persist($presence);
$this->managerRegistry->flush();
return $this->json([
'success' => 'Die Anwesenheit wurde ausgetragen.',
'presence' => true,
]);
}
/**
* @Route("/coursepresence/{id}/edit", name="course_presence_edit", methods="GET|POST")
*/
public function editPresense(
$id,
PresenceRepository $presenceRepository): Response
{
$presence = $presenceRepository->find($id);
// $presenceRepository->remove($presenceremove);
$presence->setReason('x');
$presence->setModified(new \DateTime());
$this->managerRegistry->persist($presence);
$this->managerRegistry->flush();
return $this->json([
'success' => 'Der Grund wurde eingetragen.',
]);
}
/**
* @Route("/coursepresence/{id}/update", name="course_presence_update", methods="GET|POST")
*/
public function updatePresence(Request $request): JsonResponse
{
// JSON-Daten aus der Anfrage extrahieren
$data = json_decode($request->getContent(), true);
$id = $data['id'] ?? null;
$value = $data['value'] ?? null;
if (null === $id || null === $value) {
return new JsonResponse(['success' => false, 'message' => 'Invalid data'], 400);
}
// Hier können Sie die Logik für das Aktualisieren der Anwesenheit implementieren
// Zum Beispiel: Suchen Sie das entsprechende Entity und aktualisieren Sie den Wert
$entityManager = $this->getDoctrine()->getManager();
$presence = $entityManager->getRepository(Presence::class)->find($id);
if (!$presence) {
return new JsonResponse(['success' => false, 'message' => 'Presence not found'], 404);
}
// Setzen Sie den neuen Wert und speichern Sie ihn
$presence->setreason($value); // Beispiel: setValue() sollte zu Ihrem Entity passen
$entityManager->persist($presence);
$entityManager->flush();
// Erfolgreiche Antwort zurückgeben
return new JsonResponse(['success' => true]);
}
/**
* @Route("/coursepresence/{id}/participantspresenceexport", name="course_participants_presences_export", methods="GET", requirements={"id"="\d+"})
*
* @IsGranted("ROLE_SPEAKER")
*/
public function courseParticipantsPresencesExport(
Request $request,
CourseOccurrence $courseOccurrence,
OrderItemRepository $repo,
PresenceRepository $presenceRepository,
CourseOccurrenceTimeRepository $occurrenceTimeRepository,
CourseOccurrenceRepository $occurrenceRepository,
$orderby = 'customerLastname',
$order = 'asc',
) {
// Security: Check client ownership via CourseOccurrenceVoter
$this->denyAccessUnlessGranted('view', $courseOccurrence);
$orderItems = $repo->findByCourseOccurrence($courseOccurrence, $orderby, $order);
$course = $courseOccurrence->getCourse()->getId();
$orderItems = $repo->findByCourseOccurrence($courseOccurrence, $orderby, $order);
$presences = $presenceRepository->findByOccurrence($courseOccurrence);
// Summen je Person vorbereiten
$statsByPerson = []; // [personId => ['present'=>int,'absent'=>int,'reasons'=>[name=>count]]]
foreach ($presences as $p) {
$person = $p->getPerson();
if (!$person) {
continue;
}
$pid = $person->getId();
if (!isset($statsByPerson[$pid])) {
$statsByPerson[$pid] = ['present' => 0, 'absent' => 0, 'reasons' => []];
}
if ($p->getPresence()) {
++$statsByPerson[$pid]['present'];
} else {
++$statsByPerson[$pid]['absent'];
$rName = $p->getPresenceReason() ? $p->getPresenceReason()->getName() : '—';
$statsByPerson[$pid]['reasons'][$rName] = ($statsByPerson[$pid]['reasons'][$rName] ?? 0) + 1;
}
}
$response = $this->render('person/export-participants-presences.csv.twig', [
'presences' => $presenceRepository->findByOccurrence($courseOccurrence),
'course' => $course,
'occurrence' => $courseOccurrence,
'orderItems' => $orderItems,
'statsByPerson' => $statsByPerson, // ← neu
]);
$csv = $response->getContent(); // <— nur Body
$encodedCsvContent = mb_convert_encoding($csv, 'ISO-8859-1', 'UTF-8');
$response = new Response($encodedCsvContent);
$response->setStatusCode(200);
$response->headers->set('Content-Type', 'text/csv; charset=ISO-8859-1');
// $response->headers->set('Content-Type', 'text/csv; charset=utf-8');
$response->headers->set('Content-Disposition', 'attachment; filename="Anwesenheit_Kurs.csv"');
return $response;
}
/**
* @Route("/coursepresence/{id}/exportcourseparticipants", name="export_course_participants", methods="GET", requirements={"id"="\d+"})
*
* @IsGranted("ROLE_SPEAKER")
*/
public function courseParticipantsExport(
Request $request,
CourseOccurrence $courseOccurrence,
OrderItemRepository $repo,
$orderby = 'customerLastname',
$order = 'asc',
) {
// Security: Check client ownership via CourseOccurrenceVoter
$this->denyAccessUnlessGranted('view', $courseOccurrence);
$header = $request->get('header', false); // Holen Sie den Wert von 'header'
// Wenn 'header' true ist, setzen Sie ihn auf 1
if ($header) {
$header = '1';
} else {
$header = '0';
}
$course = $courseOccurrence->getCourse()->getId();
$orderItems = $repo->findByCourseOccurrence($courseOccurrence, $orderby, $order);
// Rendern des CSV-Inhalts als String (UTF-8)
$csvContent = $this->renderView('person/export-course-participants.csv.twig', [
'header' => $header,
'course' => $course,
'occurrence' => $courseOccurrence,
'orderItems' => $orderItems,
]);
// Konvertiere den CSV-Inhalt in ISO-8859-1
$encodedCsvContent = mb_convert_encoding($csvContent, 'ISO-8859-1', 'UTF-8');
// Erstelle eine Antwort mit dem konvertierten Inhalt
$response = new Response($encodedCsvContent);
$response->setStatusCode(200);
$response->headers->set('Content-Type', 'text/csv; charset=ISO-8859-1');
// $response->headers->set('Content-Type', 'text/csv; charset=utf-8');
$startDate = $courseOccurrence->getStart();
$formattedDate = $startDate->format('d.m.y');
// Konstruktion des Dateinamens
$courseTitle = $courseOccurrence->getCourse()->getTitle();
$fileName = 'Kurs-Teilnehmer-'.$courseTitle.'-'.$formattedDate.'.csv';
// Setzen des Content-Disposition-Headers
$response->headers->set('Content-Disposition', 'attachment; filename="'.$fileName.'"');
return $response;
}
/**
* @Route("/{id}/reservations", name="course_reservations", methods="GET", requirements={"id"="\d+"})
*/
public function courseReservations(
Request $request,
Course $course,
WaitItemRepository $repo,
TagsPersonRepository $tagsPersonRepository,
PersonRepository $personRepository,
) {
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
$waitItems = $repo->findByCoursePaged($course);
$user = $this->getCurrentUser();
$person = $personRepository->getByUser($user);
return $this->render('course/reservations.html.twig', [
'course' => $course,
'waitItems' => $waitItems->getIterator(),
'tagsPerson' => $tagsPersonRepository->findAll(),
'user' => $user,
]);
}
/**
* @Route("/waititem/{id}/delete", name="waititem_delete", methods="GET|POST")
*/
public function deleteWaitItem(
$id,
WaitItemRepository $waitItemRepository,
TagsPersonRepository $tagsPersonRepository,
EntityManagerInterface $entityManager): Response
{
$waitItem = $waitItemRepository->find($id);
$course = $waitItem->getCourseOccurrence()->getCourse();
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
$waitItems = $waitItemRepository->findByCoursePaged($course);
if (!$waitItem) {
throw $this->createNotFoundException('WaitItem not found');
}
$entityManager->remove($waitItem);
$entityManager->flush();
$this->addFlash('success', 'WaitItem deleted successfully');
return $this->render('course/reservations.html.twig', [
'course' => $course,
'waitItems' => $waitItems->getIterator(),
'tagsPerson' => $tagsPersonRepository->findAll(),
]);
}
/**
* @Route("/{id}/reservations/move", name="course_reservations_move", methods="POST", requirements={"id"="\d+"})
*/
public function moveCourseReservations(
Request $request,
Course $course,
WaitItemRepository $repo): Response
{
// Security: Check client ownership via CourseSecurityVoter
$this->denyAccessUnlessGranted('view', $course);
$em = $this->getDoctrine()->getManager();
$moveIds = $request->request->get('item');
foreach ($moveIds as $id => $value) {
if ($value) {
$waitItem = $repo->find($value);
$orderItem = OrderItem::createFromWaitItem($waitItem);
$participants = $waitItem->getParticipants();
foreach ($participants as $participant) {
if ($participant->getPerson()->getId() === $id) {
$participant->setWaitItem(null);
$participant->setOrderItem($orderItem);
$orderItem->setQuantity($orderItem->getQuantity() + 1);
$waitItem->setQuantity($waitItem->getQuantity() - 1);
break;
}
}
$waitItem->getCourseOccurrence()->bookSlots($orderItem->getQuantity());
$order = $waitItem->getOrder();
$order->addOrderItem($orderItem);
if (0 === $waitItem->getQuantity()) {
$order->removeWaitItem($waitItem);
}
$em->persist($order);
}
}
$this->addFlash('notice', count($moveIds).(count($moveIds) > 1 ? ' Wartelistenplätze verschoben' : ' Wartelistenplatz verschoben'));
$em->flush();
return $this->redirectToRoute('course_reservations', ['id' => $course->getId()]);
}
/**
* @Route("/{id}/participants-zoommembers", name="course_participants_zoommembers", methods="GET", requirements={"id"="\d+"})
*
* @IsGranted("ROLE_SPEAKER")
*/
public function courseParticipantsZommMembers(
Request $request,
CourseOccurrence $courseOccurrence,
OrderItemRepository $repo,
ZoomService $zoomService,
PersonRepository $personRepo,
) {
// $this->denyAccessUnlessGranted('client_allowed', $courseOccurrence);
// Security: Check client ownership via CourseOccurrenceVoter
$this->denyAccessUnlessGranted('view', $courseOccurrence);
$orderItems = $repo->findByCourseOccurrence($courseOccurrence, 'name', 'asc');
foreach ($orderItems as $orderItem) {
foreach ($orderItem->getParticipants() as $participant) {
// dd($participant->getPerson());
if (null != $participant && null != $participant->getPerson()) {
if (null != $participant->getPerson()->getContactEmail()) {
$email = $participant->getPerson()->getContactEmail();
} else {
$email = $orderItem->getOrder()->getCustomerContactEmail();
}
$registrant = $zoomService->addRegistrantToWebinar(
$this->getCurrentClient(), // Client-Kontext für mandantenspezifische Zoom-Config
$orderItem->getCourseOccurrence()->getCode(),
$email,
$participant->getPerson()->getFirstname(),
$participant->getPerson()->getLastname()
);
}
}
}
return $this->redirectToRoute('course_participants', ['id' => $courseOccurrence->getCourse()->getId()]);
}
/**
* @Route("/{id}/participant-zoommember/{participant}", name="course_participant_zoommember", methods="GET", requirements={"id"="\d+"})
*
* @IsGranted("ROLE_SPEAKER")
*/
public function courseParticipantZommMember(
Request $request,
CourseOccurrence $courseOccurrence,
CourseOccurrenceRepository $courseOccurrenceRepo,
ZoomService $zoomService,
PersonRepository $personRepo,
) {
// $this->denyAccessUnlessGranted('client_allowed', $courseOccurrence);
// Security: Check client ownership via CourseOccurrenceVoter
$this->denyAccessUnlessGranted('view', $courseOccurrence);
$participant = $personRepo->find($request->get('participant'));
$courseOccurrence = $courseOccurrenceRepo->find($courseOccurrence->getId());
if (null != $participant->getContactEmail()) {
$email = $participant->getContactEmail();
} else {
$email = $participant->getFamilyMemberOf()->getContactEmail();
}
$registrant = $zoomService->addRegistrantToWebinar(
$courseOccurrence->getCode(),
$email,
$participant->getFirstname(),
$participant->getLastname()
);
$this->addFlash('success', 'Teilnehmer wurde erfolgreich zu Zoom hinzugefügt.');
return $this->redirectToRoute('course_participants', ['id' => $courseOccurrence->getCourse()->getId()]);
}
private function generateUniqueFileName()
{
return md5(uniqid());
}
private function createDescription($field, $option)
{
switch ($option) {
case 'course':
if (!empty($field['certificate'])) {
$field['name'] = $this->generateHTMLForDescription(
$field['name'],
'für den Kurs und das Zertifikat'
);
} else {
$field['name'] = $this->generateHTMLForDescription(
$field['name'],
'für den Kurs'
);
}
break;
case 'certificate':
$field['name'] = $this->generateHTMLForDescription(
$field['name'],
'für das Zertifikat'
);
break;
default:
break;
}
return $field;
}
private function generateHTMLForDescription($name, $text)
{
return '<strong>'.$name.'</strong><span style="font-size: 0.7rem"> ('.$text.')</span>';
}
}

src/Controller/CourseController.php line 1147