src/Controller/ShopController.php line 288

Open in your IDE?
  1. <?php
  2. # src/Controller/ShopController.php
  3. namespace App\Controller;
  5. use App\Entity\ShopProdukt;
  6. use App\Entity\ShopKategorie;
  7. use App\Entity\Bestellung;
  8. use App\Service\PayPalService;
  9. use App\Service\VPNSetupService;
  10. use App\Repository\ShopProduktRepository;
  11. use App\Repository\ShopKategorieRepository;
  12. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Symfony\Component\HttpFoundation\Response;
  15. use Symfony\Component\HttpFoundation\JsonResponse;
  16. use Symfony\Component\Routing\Annotation\Route;
  17. use Doctrine\ORM\EntityManagerInterface;
  18. use Symfony\Component\Security\Csrf\CsrfToken;
  19. use Symfony\Component\Security\Csrf\CsrfTokenManagerInterface;
  21. #[Route('/shop')]
  22. class ShopController extends AbstractController
  23. {
  24.     private ShopProduktRepository $produktRepository;
  25.     private ShopKategorieRepository $kategorieRepository;
  26.     private EntityManagerInterface $entityManager;
  28.     public function __construct(
  29.         ShopProduktRepository $produktRepository,
  30.         ShopKategorieRepository $kategorieRepository,
  31.         EntityManagerInterface $entityManager
  32.     ) {
  33.         $this->produktRepository = $produktRepository;
  34.         $this->kategorieRepository = $kategorieRepository;
  35.         $this->entityManager = $entityManager;
  36.     }
  38.     #[Route('/', name: 'shop_overview', methods: ['GET'])]
  39.     public function shopOverview(): Response
  40.     {
  41.         // Hole alle Produkte und Kategorien aus der Datenbank
  42.         $products = $this->produktRepository->findAll();
  43.         $kategorien = $this->kategorieRepository->findAll();
  45.         return $this->render('shop/overview.html.twig', [
  46.             'products' => $products,
  47.             'kategorien' => $kategorien,
  48.         ]);
  49.     }
  51.     #[Route('/product/{id}', name: 'shop_product_detail', methods: ['GET'])]
  52.     public function productDetail(int $id): Response
  53.     {
  54.         // Suche ein Produkt anhand der ID
  55.         $product = $this->produktRepository->find($id);
  57.         if (!$product) {
  58.             throw $this->createNotFoundException('Produkt nicht gefunden');
  59.         }
  61.         return $this->render('shop/detail.html.twig', [
  62.             'product' => $product,
  63.         ]);
  64.     }
  66.     
  67.     
  69.     #[Route('/cart/add/{id}', name: 'shop_cart_add', methods: ['POST'])]
  70.     public function addToCart(int $id, Request $request): JsonResponse
  71.     {
  72.         $product = $this->produktRepository->find($id);
  73.     
  74.         if (!$product) {
  75.             return new JsonResponse(['error' => 'Produkt nicht gefunden'], 404);
  76.         }
  77.     
  78.         // Kasse aus der Session holen
  79.         $session = $request->getSession();
  80.         $cart = $session->get('cart', []);
  81.     
  82.         // Produkt hinzufügen oder Menge erhöhen
  83.         if (isset($cart[$id])) {
  84.             $cart[$id]['quantity'] += 1;
  85.         } else {
  86.             $cart[$id] = [
  87.                 'product' => $product,
  88.                 'quantity' => 1
  89.             ];
  90.         }
  91.     
  92.         // Warenkorb in der Session speichern
  93.         $session->set('cart', $cart);
  94.     
  95.         return new JsonResponse([
  96.             'cartHtml' => $this->renderView('shop/_cart_items.html.twig', ['cart' => $cart]),
  97.             'total' => $this->calculateTotal($cart),
  98.             'product' => [
  99.                 'name' => $product->getName(),
  100.                 'description' => $product->getBeschreibung(),
  101.                 'price' => number_format($product->getPreis(), 2, ',', '.')
  102.             ]
  103.         ]);
  104.     }
  105.     
  106.     #[Route('/cart/remove/{id}', name: 'shop_cart_remove', methods: ['POST'])]
  107.     public function removeFromCart(int $id, Request $request): JsonResponse
  108.     {
  109.         try {
  110.             // Kasse aus der Session holen
  111.             $session = $request->getSession();
  112.             $cart = $session->get('cart', []);
  113.     
  114.             // Entferne das Produkt oder reduziere die Menge
  115.             if (isset($cart[$id])) {
  116.                 if ($cart[$id]['quantity'] > 1) {
  117.                     $cart[$id]['quantity'] -= 1;
  118.                 } else {
  119.                     unset($cart[$id]);
  120.                 }
  121.             }
  122.     
  123.             // Kasse in der Session speichern
  124.             $session->set('cart', $cart);
  125.     
  126.             // Erfolgsnachricht hinzufügen
  127.             $this->addFlash('success', 'Produkt erfolgreich aus dem Warenkorb entfernt');
  128.     
  129.             return new JsonResponse([
  130.                 'cartHtml' => $this->renderView('shop/_cart_items.html.twig', ['cart' => $cart]),
  131.                 'total' => $this->calculateTotal($cart)
  132.             ]);
  133.         } catch (\Exception $e) {
  134.             // Fehlernachricht hinzufügen
  135.             $this->addFlash('error', 'Fehler beim Entfernen aus dem Warenkorb');
  136.             return new JsonResponse(['error' => 'Fehler beim Entfernen aus dem Warenkorb'], 500);
  137.         }
  138.     }
  139.   ######################  
  141.     #[Route('/checkout/process', name: 'shop_checkout_process', methods: ['POST'])]
  142.     public function checkoutProcess(Request $request): Response
  143.     {
  144.         if (!$this->getUser()) {
  145.             $this->addFlash('error', 'Bitte loggen Sie sich ein, um den Kauf abzuschließen.');
  146.             return $this->redirectToRoute('app_login');
  147.         }
  148.     
  149.         // Hole die Zahlungsmethode aus dem Request (PayPal oder andere Methoden)
  150.         $paymentMethod = $request->request->get('payment_method');
  151.     
  152.         // Warenkorb aus der Session holen
  153.         $session = $request->getSession();
  154.         $cart = $session->get('cart', []);
  155.     
  156.         if (empty($cart)) {
  157.             $this->addFlash('error', 'Der Warenkorb ist leer.');
  158.             return $this->redirectToRoute('shop_overview');
  159.         }
  160.     
  161.         // Bestellung erstellen
  162.         $bestellung = new Bestellung();
  163.         $bestellung->setKunde($this->getUser());
  164.         $bestellung->setBestelldatum(new \DateTime());
  165.         $bestellung->setStatus('pending');
  166.         $bestellung->setGesamtbetrag($this->calculateTotal($cart));
  167.     
  168.         foreach ($cart as $cartItem) {
  169.             $product = $this->produktRepository->find($cartItem['product']->getId());
  170.     
  171.             if (!$product) {
  172.                 throw $this->createNotFoundException('Produkt nicht gefunden.');
  173.             }
  174.     
  175.             $bestellung->addProdukt($product);
  176.         }
  177.     
  178.         $this->entityManager->persist($bestellung);
  179.         $this->entityManager->flush();
  180.     
  181.         // Warenkorb leeren
  182.         $session->remove('cart');
  183.     
  184.         // Weiterleitung zu PayPal oder Stripe basierend auf der Zahlungsmethode
  185.         if ($paymentMethod === 'paypal') {
  186.             return $this->redirectToRoute('paypal_payment', ['order_id' => $bestellung->getId()]);
  187.         } elseif ($paymentMethod === 'stripe') {
  188.             return $this->redirectToRoute('stripe_payment', ['order_id' => $bestellung->getId()]);
  189.         }
  190.     
  191.         // Als Fallback zurück zum Shop, falls keine Methode ausgewählt wurde
  192.         return $this->redirectToRoute('shop_overview');
  193.     }
  194.   
  196.     #[Route('/payment/confirm', name: 'payment_confirm', methods: ['GET'])]
  197.     public function confirmPayment(Request $request, PayPalService $paypalService, VPNSetupService $vpnSetupService): Response
  198.     {
  199.         // Abrufen der PayPal-Bestell-ID vom Rückruf von PayPal
  200.         $paypalOrderId = $request->query->get('token');  // Abrufen des Tokens aus der PayPal-Rückmeldung
  202.         if (!$paypalOrderId) {
  203.             throw $this->createNotFoundException('PayPal-Token nicht gefunden.');
  204.         }
  206.         // Bestellung anhand der PayPal-Order-ID finden
  207.         $bestellung = $this->entityManager->getRepository(Bestellung::class)
  208.             ->findOneBy(['paypalOrderId' => $paypalOrderId]);
  210.         if (!$bestellung) {
  211.             throw $this->createNotFoundException('Bestellung nicht gefunden.');
  212.         }
  214.         // Zahlung bestätigen
  215.         $response = $paypalService->captureOrder($paypalOrderId);
  217.         if ($response->statusCode === 201) {
  218.             // Setze den Bestellstatus auf 'completed'
  219.             $bestellung->setStatus('completed');
  220.             $this->entityManager->flush();
  222.             // Hier wird der VPN-Setup-Service aufgerufen
  223.             try {
  224.                 $vpnSetupService->setupVPNForUser($bestellung->getKunde());  // Kunde aus der Bestellung
  225.                 $this->addFlash('success', 'Zahlung erfolgreich abgeschlossen und VPN eingerichtet!');
  226.             } catch (\Exception $e) {
  227.                 // Wenn das VPN-Setup fehlschlägt, füge eine Fehlermeldung hinzu
  228.                 $this->addFlash('error', 'Zahlung erfolgreich, aber VPN-Setup fehlgeschlagen.');
  229.             }
  231.             // Erfolgreiche Bestellung anzeigen
  232.             return $this->render('shop/order_success.html.twig', ['order' => $bestellung]);
  233.         }
  235.         // Bei Fehler die Nachricht anzeigen
  236.         $this->addFlash('error', 'Zahlung fehlgeschlagen.');
  237.         return $this->redirectToRoute('shop_overview');
  238.     }
  241.     #[Route('/payment/paypal/{order_id}', name: 'paypal_payment')]
  242.     public function paypalPayment(int $order_id, PayPalService $paypalService): Response
  243.     {
  244.         // Bestellung aus der Datenbank holen
  245.         $bestellung = $this->entityManager->getRepository(Bestellung::class)->find($order_id);
  246.     
  247.         if (!$bestellung) {
  248.             throw $this->createNotFoundException('Bestellung nicht gefunden.');
  249.         }
  250.     
  251.         // Gesamtsumme der Bestellung holen
  252.         $totalAmount = $bestellung->getGesamtbetrag();
  253.     
  254.         // PayPal-Order erstellen
  255.         $response = $paypalService->createOrder($totalAmount);
  256.     
  257.         // Speichere die PayPal-Order-ID in der Bestellung
  258.         $bestellung->setPaypalOrderId($response->result->id);
  259.         $this->entityManager->flush();
  260.     
  261.         // Leite den Benutzer zur PayPal-Zahlungsseite weiter
  262.         return $this->redirect($response->result->links[1]->href);
  263.     }
  264.     
  265.     
  267.     #[Route('/checkout/{id?}', name: 'shop_checkout', methods: ['GET', 'POST'])]
  268.     public function checkout(?int $id, Request $request): Response
  269.     {
  270.         // Warenkorb aus der Session holen
  271.         $session = $request->getSession();
  272.         $cart = $session->get('cart', []);
  273.     
  274.         // Wenn eine Produkt-ID angegeben ist, behandeln wir es als einzelnes Produkt
  275.         if ($id) {
  276.             $product = $this->produktRepository->find($id);
  277.     
  278.             if (!$product) {
  279.                 throw $this->createNotFoundException('Produkt nicht gefunden');
  280.             }
  281.     
  282.             // Füge das Produkt in den Warenkorb hinzu, falls es noch nicht existiert
  283.             if (!isset($cart[$id])) {
  284.                 $cart[$id] = [
  285.                     'product' => $product,
  286.                     'quantity' => 1
  287.                 ];
  288.                 $session->set('cart', $cart);
  289.             }
  290.     
  291.             // Produkte nach Kategorie gruppieren
  292.             $allProducts = $this->produktRepository->findAll();
  293.             $similarProducts = [];
  294.             foreach ($allProducts as $similarProduct) {
  295.                 $kategorieId = $similarProduct->getKategorie()->getId();
  296.                 if ($kategorieId !== $product->getKategorie()->getId() && !isset($similarProducts[$kategorieId])) {
  297.                     $similarProducts[$kategorieId] = $similarProduct;
  298.                 }
  299.             }
  300.     
  301.             return $this->render('Shop/checkout.html.twig', [
  302.                 'product' => $product,
  303.                 'cart' => $cart,
  304.                 'similar_products' => array_values($similarProducts),
  305.             ]);
  306.         }
  307.     
  308.         // Allgemeiner Checkout, wenn keine ID vorhanden ist
  309.         if (empty($cart)) {
  310.             $this->addFlash('error', 'Ihr Warenkorb ist leer.');
  311.             return $this->render('Shop/empty_cart.html.twig'); // Ein spezielles Template für leere Warenkörbe
  312.         }
  313.     
  314.         // Gesamtsumme berechnen für den Warenkorb-Checkout
  315.         $total = $this->calculateTotal($cart);
  316.     
  317.         return $this->render('Shop/checkout.html.twig', [
  318.             'cart' => $cart,
  319.             'total' => $total,
  320.             'similar_products' => [] // Keine ähnlichen Produkte im allgemeinen Warenkorb-Checkout
  321.         ]);
  322.     }
  326.     private function calculateTotal(array $cart): float
  327.     {
  328.         $total = 0;
  329.         foreach ($cart as $item) {
  330.             $total += $item['product']->getPreis() * $item['quantity'];
  331.         }
  332.         return $total; // Rückgabe als float
  333.     }
  335.       
  336.     #[Route('/admin/product/update-sort-order', name: 'admin_shop_product_update_sort_order', methods: ['POST'])]
  337.     public function updateSortOrder(Request $request, CsrfTokenManagerInterface $csrfTokenManager): JsonResponse
  338.     {
  339.         $token = $request->request->get('_token');
  340.         if (!$csrfTokenManager->isTokenValid(new CsrfToken('update_sort_order', $token))) {
  341.             return new JsonResponse(['error' => 'Invalid CSRF token'], 400);
  342.         }
  344.         $productId = $request->request->get('id');
  345.         $newSortOrder = (int)$request->request->get('sortOrder');
  347.         // Produkt suchen
  348.         $product = $this->produktRepository->find($productId);
  350.         if (!$product) {
  351.             return new JsonResponse(['error' => 'Produkt nicht gefunden'], 404);
  352.         }
  354.         // Sortierreihenfolge aktualisieren
  355.         $product->setSortOrder($newSortOrder);
  356.         $this->entityManager->flush();
  358.         return new JsonResponse(['success' => true, 'message' => 'Sortierreihenfolge erfolgreich aktualisiert']);
  359.     }
  360.     
  361.     
  362.   
  363.     
  364.     
  365.     #[Route('/payment/stripe/{order_id}', name: 'stripe_payment')]
  366.     public function stripePayment(int $order_id)
  367.     {
  368.         // Logik für Stripe-Zahlung
  369.     }
  370.     
  372. }