src/Controller/ProductoController.php line 59

Open in your IDE?
  1. <?php
  2. namespace App\Controller;
  3. use Doctrine\Common\Collections\ArrayCollection;
  4. use Doctrine\ORM\EntityManagerInterface;
  5. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  6. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  7. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  8. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  9. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  10. use Symfony\Component\HttpFoundation\Response;
  11. use Symfony\Component\HttpFoundation\Request;
  12. use Symfony\Component\HttpFoundation\InputBag;
  13. use Symfony\Component\Routing\Annotation\Route;
  14. use Symfony\Component\HttpFoundation\File\File;
  15. use Symfony\Component\Form\Extension\Core\Type\FileType;
  16. use Symfony\Component\String\Slugger\SluggerInterface;
  17. use App\Entity\Producto;
  18. use App\Entity\Categoria;
  19. use App\Entity\Imagen;
  20. use App\Form\ProductoType;
  21. use App\Form\ProductoCategoriaType;
  22. use App\Form\ProductoCategoriasType;
  23. use App\Entity\Parametro;
  24. use App\Service\ProductoService;
  25. class ProductoController extends AbstractController
  26. {
  27.     private $entityManager;
  28.     //Servicios
  29.     private $productoService;
  30.     //Repositorios
  31.     private $publicacionRepository;
  32.     private $productoRepository;
  33.     private $categoriaRepository;
  34.     private $parametroRepository;
  35.     //Parametros    
  36.     private $urlImagenes;
  37.     public function __construct(EntityManagerInterface $entityManagerParameterBagInterface $parameterBag\App\Service\ProductoService $productoService)
  38.     {
  39.         //Doctrine
  40.         $this->entityManager $entityManager;
  41.         $this->productoService $productoService;
  42.         $this->productoRepository $this->entityManager->getRepository(Producto::class);
  43.         $this->categoriaRepository $this->entityManager->getRepository(Categoria::class);
  44.         $this->parametroRepository $this->entityManager->getRepository(Parametro::class);
  45.         //Parametros
  46.         $this->urlImagenes $parameterBag->get('imagenes_directory');
  47.     }
  48.     /**
  49.      * @Route("/producto", name="producto")
  50.      */
  51.     public function index(): Response
  52.     {
  53.         //Obtengo todos los Productos que esten disponibles 
  54.         $productos $this->productoRepository->findByActivos();
  55.         //Obtengo todas las categorias existentes
  56.         $categorias $this->categoriaRepository->findBy([], ['nombre' => 'ASC']);
  57.         //Retorno a la vista
  58.         return $this->render(
  59.             'Producto/index.html.twig',
  60.             [
  61.                 'productos' => $productos,
  62.                 'categorias' => $categorias,
  63.             ]
  64.         );
  65.     }
  66.     /**
  67.      * @Route("/productos/categoria/{idCategoria}", name="producto_de_categoria")
  68.      */
  69.     public function listarProductosCategorias($idCategoria): Response
  70.     {
  71.         //Obtengo la categoria del producto
  72.         $categoria $this->categoriaRepository->find($idCategoria);
  73.         //Obtengo todos los producto
  74.         $productos $this->productoRepository->findByActivos();
  75.         //Obtengo todos los productos de una categoria
  76.         $productosCategoria $categoria->getProductos();
  77.         //Defino la coleccion
  78.         $productosActivosCategoria = new ArrayCollection();
  79.         // Itero sobre los productos de la categoría
  80.         foreach ($productosCategoria as $producto) {
  81.             // Verifico si el producto está activo
  82.             if (in_array($producto$productos)) {
  83.                 // Agrego el producto a la nueva colección
  84.                 $productosActivosCategoria->add($producto);
  85.             }
  86.         }
  87.         //Obtengo todas las categorias existentes
  88.         $categorias $this->categoriaRepository->findBy([], ['nombre' => 'ASC']);
  89.         //Retorno a la vista
  90.         return $this->render(
  91.             'Producto/index.html.twig',
  92.             [
  93.                 'productos' => $productosActivosCategoria,
  94.                 'categorias' => $categorias,
  95.             ]
  96.         );
  97.     }
  98.     /**
  99.      * Require ROLE_ADMIN for only this controller method.
  100.      *
  101.      * @Route("/app/gestionProductos", name="producto_abm")
  102.      *
  103.      * @IsGranted("ROLE_ADMIN")
  104.      */
  105.     //Funcion para listar todos los productos disponibles
  106.     public function listarProductosAbm(): Response
  107.     {
  108.         //Obtengo todos los Productos que esten disponibles 
  109.         $productos $this->productoRepository->findAll();
  110.         //Retorno a la vista
  111.         return $this->render(
  112.             'Producto/gestionar.html.twig',
  113.             [
  114.                 'productos' => $productos,
  115.             ]
  116.         );
  117.     }
  118.     /**
  119.      * @Route("/producto/ver/{idProducto}", name="producto_ver")
  120.      */
  121.     public function verProducto($idProducto): Response
  122.     {
  123.         //Obtengo el producto a mostrar
  124.         $producto $this->productoRepository->find($idProducto);
  125.         //Obtengo la configuracion de ventas
  126.         $flagVentas $this->parametroRepository->find(1);
  127.         //Retorno a la vista
  128.         return $this->render(
  129.             'Producto/ver.html.twig',
  130.             [
  131.                 'producto' => $producto,
  132.                 'flagVentas' => $flagVentas,
  133.             ]
  134.         );
  135.     }
  136.     /**
  137.      * Require ROLE_ADMIN for only this controller method.
  138.      *
  139.      * @Route("/app/producto/ver/{idProducto}", name="producto_ver_abm")
  140.      *
  141.      * @IsGranted("ROLE_ADMIN")
  142.      */
  143.     //Funcion para listar todos los productos disponibles
  144.     public function verProductoAbm($idProducto): Response
  145.     {
  146.         //Obtengo el producto a mostrar
  147.         $producto $this->productoRepository->find($idProducto);
  148.         //Retorno a la vista
  149.         return $this->render(
  150.             'Producto/verAbm.html.twig',
  151.             [
  152.                 'producto' => $producto,
  153.             ]
  154.         );
  155.     }
  156.     /**
  157.      * Require ROLE_ADMIN for only this controller method.
  158.      *
  159.      * @Route("/app/productos/nuevo", name="producto_nuevo")
  160.      *
  161.      * @IsGranted("ROLE_ADMIN")
  162.      */
  163.     //Funcion para crear un producto
  164.     public function nuevoProducto(Request $requestSluggerInterface $slugger): Response
  165.     {
  166.         //Creo un nuevo Producto 
  167.         $producto = new Producto();
  168.         //Defino el Formulario
  169.         $form $this->createForm(ProductoType::class, $producto);
  170.         //Si se envia el formulario , existe un request
  171.         $form->handleRequest($request);
  172.         //Si se disparo el formulario y es valido
  173.         if ($form->isSubmitted() && $form->isValid()) {
  174.             //Obtengo el producto del formulario
  175.             $producto $form->getData();
  176.             //Le doy persistencia 
  177.             $this->entityManager->persist($producto);
  178.             //Asiento los cambios en la base de datos
  179.             $this->entityManager->flush();
  180.             //Obtengo la imagen que subi del producto  
  181.             $imagenSubida $form->get('imagen')->getData();
  182.             //Obtengo las imagenes que subi 
  183.             $imagenesSubidas $form->get('imagen')->getData();
  184.             //Obtengo la portada
  185.             $portada $form->get('portada')->getData();
  186.             //Si existe portada
  187.             if ($portada) {
  188.                 $this->productoService->productoAdjuntarImagenPortada($producto$portada$slugger);
  189.             }
  190.             //Itero por cada imagen subida
  191.             foreach ($imagenesSubidas as $imagenSubida) {
  192.                 $this->productoService->productoAdjuntarImagen($producto$imagenSubida$slugger);
  193.             }
  194.             //Le doy persistencia 
  195.             $this->entityManager->persist($producto);
  196.             //Asiento los cambios en la base de datos
  197.             $this->entityManager->flush();
  198.             //Aviso
  199.             $this->addFlash('exito''El producto se creo correctamente');
  200.             //Redirecciono        
  201.             return $this->redirectToRoute('producto_ver', array('idProducto' => $producto->getId()));
  202.         }
  203.         //Retorno la vista
  204.         return $this->render(
  205.             'Producto/nuevo.html.twig',
  206.             [
  207.                 'form' => $form->createView(),
  208.             ]
  209.         );
  210.     }
  211.     /**
  212.      * Require ROLE_ADMIN for only this controller method.
  213.      * 
  214.      * @Route("/app/productos/editar/{idProducto}", name="producto_editar", methods={"GET","HEAD","POST"})
  215.      * 
  216.      * @IsGranted("ROLE_ADMIN")
  217.      */
  218.     //Funcion para editar los datos de un producto
  219.     public function editarProducto($idProductoRequest $requestSluggerInterface $slugger): Response
  220.     {
  221.         //Obtengo el producto seleccionado
  222.         $producto $this->productoRepository->find($idProducto);
  223.         //Defino el Formulario
  224.         $form $this->createForm(ProductoType::class, $producto);
  225.         //Si se envia el formulario , existe un request
  226.         $form->handleRequest($request);
  227.         //Si se disparo el formulario y es valido
  228.         if ($form->isSubmitted() && $form->isValid()) {
  229.             //Obtengo el producto del formulario
  230.             $producto $form->getData();
  231.             //Obtengo la imagen que subi del producto  
  232.             $imagenSubida $form->get('imagen')->getData();
  233.             //Obtengo las imagenes que subi 
  234.             $imagenesSubidas $form->get('imagen')->getData();
  235.             //Obtengo la portada
  236.             $portada $form->get('portada')->getData();
  237.             //Si existe portada
  238.             if ($portada) {
  239.                 $this->productoService->productoAdjuntarImagenPortada($producto$portada$slugger);
  240.             }
  241.             //Itero por cada imagen subida
  242.             foreach ($imagenesSubidas as $imagenSubida) {
  243.                 $this->productoService->productoAdjuntarImagen($producto$imagenSubida$slugger);
  244.             }
  245.             //aviso
  246.             $this->addFlash('exito''Se edito el producto correctamente');
  247.             //Le doy persistencia 
  248.             $this->entityManager->persist($producto);
  249.             //Asiento los cambios en la base de datos
  250.             $this->entityManager->flush();
  251.             //Redirecciono
  252.             return $this->redirectToRoute('producto_ver', array('idProducto' => $producto->getId()));
  253.         }
  254.         //Redirecciono a la vista      
  255.         return $this->render(
  256.             'Producto/editar.html.twig',
  257.             [
  258.                 'form' => $form->createView(),
  259.                 'producto' => $producto,
  260.             ]
  261.         );
  262.     }
  263.     /**
  264.      * Require ROLE_ADMIN for only this controller method.
  265.      * 
  266.      * @Route("/app/productos/categorizar/{idProducto}", name="producto_categoria", methods={"GET","HEAD","POST"})
  267.      * 
  268.      * @IsGranted("ROLE_ADMIN")
  269.      */
  270.     //Funcion para editar los datos de un producto
  271.     public function categorizarProducto($idProductoRequest $requestSluggerInterface $slugger): Response
  272.     {
  273.         //Obtengo el producto seleccionado
  274.         $producto $this->productoRepository->find($idProducto);
  275.         //Obtengo las categorias
  276.         $categorias $this->categoriaRepository->findAll();
  277.         //Defino el Formulario
  278.         $form $this->createForm(ProductoCategoriaType::class, $producto);
  279.         //Si se envia el formulario , existe un request
  280.         $form->handleRequest($request);
  281.         //Si se disparo el formulario y es valido
  282.         if ($form->isSubmitted() && $form->isValid()) {
  283.             //Obtengo el producto del formulario
  284.             $producto $form->getData();
  285.             //Le doy persistencia 
  286.             $this->entityManager->persist($producto);
  287.             //Asiento los cambios en la base de datos
  288.             $this->entityManager->flush();
  289.             //Aviso
  290.             $this->addFlash('aviso''Se actualizaron las categorias del Producto ' $producto->getNombre());
  291.             //Redirecciono 
  292.             return $this->redirectToRoute('producto_ver', array('idProducto' => $producto->getId()));
  293.         }
  294.         //Redirecciono a la vista      
  295.         return $this->render(
  296.             'Producto/categorizar.html.twig',
  297.             [
  298.                 'form' => $form->createView(),
  299.                 'producto' => $producto,
  300.             ]
  301.         );
  302.     }
  303.     /**
  304.      * Require ROLE_ADMIN for only this controller method.
  305.      * 
  306.      * @Route("/app/productos/galeria/{idProducto}", name="producto_imagenes", methods={"GET","HEAD","POST"})
  307.      * 
  308.      * @IsGranted("ROLE_ADMIN")
  309.      */
  310.     public function editarImagenesProducto($idProductoRequest $requestSluggerInterface $slugger): Response
  311.     {
  312.         //Obtengo el producto seleccionado
  313.         $producto $this->productoRepository->find($idProducto);
  314.         //Redirecciono a la vista      
  315.         return $this->render(
  316.             'Producto/editarImagenes.html.twig',
  317.             [
  318.                 'producto' => $producto,
  319.             ]
  320.         );
  321.     }
  322. }