src/Controller/Almacen/ArticuloController.php line 351

Open in your IDE?
  1. <?php
  2. namespace App\Controller\Almacen;
  3. use App\Entity\Almacen\AplicacionArticulo;
  4. use App\Entity\Almacen\Articulo;
  5. use App\Entity\Almacen\ArticuloDeposito;
  6. use App\Form\Almacen\ArticuloType;
  7. use App\Repository\Almacen\ArticuloRepository;
  8. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  9. use Symfony\Component\HttpFoundation\Request;
  10. use Symfony\Component\HttpFoundation\Response;
  11. use Symfony\Component\HttpFoundation\JsonResponse;
  12. use Symfony\Component\Routing\Annotation\Route;
  13. use Symfony\Bridge\Doctrine\Form\Type\EntityType;
  14. use Symfony\Component\Form\Extension\Core\Type\SubmitType;
  15. use App\Entity\Almacen\Deposito;
  16. use Symfony\Component\Form\Extension\Core\Type\FileType;
  17. use App\Repository\Almacen\UnidadMedidaRepository;
  18. use App\Entity\Almacen\UnidadMedida;
  19. use Doctrine\ORM\EntityManagerInterface;
  20. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  21. /**
  22.  * @Route("/almacen/articulo")
  23.  * @IsGranted("IS_AUTHENTICATED_FULLY")
  24.  */
  25. class ArticuloController extends AbstractController
  26. {
  27.     /**
  28.      * @Route("/", name="app_almacen_articulo_index", methods={"GET"})
  29.      */
  30.     public function index(ArticuloRepository $articuloRepository, EntityManagerInterface $em): Response
  31.     {
  32.         $aplicaciones = $em->getRepository(AplicacionArticulo::class)->findAll();
  33.         return $this->render('almacen/articulo/index.html.twig', [
  34.             
  35.             'articulos' => $articuloRepository->findBy(['activo' => true], ['descripcion' => 'ASC']),
  36.            // 'articulos' => $articuloRepository->findAll(),
  37.             'aplicaciones' => $aplicaciones,
  38.         ]);
  39.     }
  40.     /**
  41.      * @Route("/add/{id}/aplicacion", name="app_almacen_articulo_add_aplicacion", methods={"POST"})
  42.      */
  43.     public function addAplicacion(Articulo $articulo, Request $request, EntityManagerInterface $em): Response
  44.     {
  45.         try
  46.         {
  47.             $aplicacion = $request->request->get('aplicacion');
  48.             if ($aplicacion) 
  49.             {
  50.                 $aplicacion = $em->getRepository(AplicacionArticulo::class)->find($aplicacion);
  51.                 if ($aplicacion) 
  52.                 {
  53.                     $articulo->addAplicacione($aplicacion);
  54.                     $em->flush();
  55.                 }
  56.                 return new JsonResponse(['ok' => true, 'aplicacion' => $articulo->getListaAplicaciones()]) ;
  57.             }
  58.         }
  59.         catch(\Exception $e){
  60.                                 return new JsonResponse(['ok' => false]);
  61.         }
  62.             
  63.     }
  64.     /**
  65.      * @Route("/change/{id}/status", name="app_almacen_articulo_change_status", methods={"POST"})
  66.      */
  67.     public function changeStatus(Articulo $articulo): Response
  68.     {
  69.         $em = $this->getDoctrine()->getManager();
  70.         $articulo->setActivo(!$articulo->isActivo());
  71.         $em->flush();
  72.         return new JsonResponse(['ok' => true]);
  73.         return $this->render('almacen/articulo/index.html.twig', [
  74.             'articulos' => $articuloRepository->findAll(),
  75.         ]); 
  76.     }
  77.     private function getSelectDeposito()
  78.     {
  79.         $form = $this->createFormBuilder()
  80.                     ->add('deposito', EntityType::class, 
  81.                                 [
  82.                                     'class' => Deposito::class,
  83.                                 ]
  84.                             )
  85.                     ->add('aplicacion', EntityType::class, 
  86.                                 [
  87.                                     'class' => AplicacionArticulo::class,
  88.                                     'required' => true,
  89.                                 ]
  90.                                 )
  91.                     ->add('cargar', SubmitType::class);
  92.         
  93.         if ($this->isGranted('ROLE_SUPER_ADMIN')) 
  94.         {
  95.             $form->add('reset', SubmitType::class, [ 'label' => 'Reestaurar Stocks' ]);
  96.         }
  97.         return $form->getForm();
  98.     }
  99.     /**
  100.      * @Route("/importar", name="app_almacen_articulo_importar_index", methods={"GET", "POST"})
  101.      */
  102.     public function importarArticulos(Request $request, UnidadMedidaRepository $unidadMedidaRepository): Response
  103.     {
  104.         $form2 = $this->createFormBuilder()
  105.                     ->add('archivo', FileType::class)
  106.                     ->add('cargar', SubmitType::class)
  107.                     ->add('aplicacion', EntityType::class, 
  108.                                 [
  109.                                     'class' => AplicacionArticulo::class,
  110.                                     'required' => false,
  111.                                 ]
  112.                                 )
  113.                     ->getForm();
  114.         $form2->handleRequest($request);
  115.         $aux = array();
  116.         
  117.         if ($form2->isSubmitted() && $form2->isValid()) 
  118.         {
  119.             $aplicacion = $form2->get('aplicacion')->getData();
  120.             $em = $this->getDoctrine()->getManager();
  121.             $file = $form2->get('archivo')->getData();   
  122.             
  123.             if (($handle = fopen($file->getPathname(), "r")) !== false) 
  124.             {
  125.                 while (($data = fgetcsv($handle, 1000, ';')) !== false) 
  126.                 {
  127.                         $um = null;
  128.                         if (isset($data[2]) && ($data[2]))
  129.                         {
  130.                             $nameum = strtoupper(utf8_encode($data[2]));
  131.                             $um = $unidadMedidaRepository->findWithName($nameum);
  132.                         }
  133.                         
  134.                         $codigo = isset($data[0]) ? utf8_encode($data[0]) : null;
  135.                         $art = null;
  136.                         if ($codigo) 
  137.                         {
  138.                             $art = $em->getRepository(Articulo::class)->findOneBy(['codigo' => $codigo]);
  139.                         }
  140.                         if (!$art) 
  141.                         {
  142.                                 $art = new Articulo();
  143.                                 $art->setDescripcion(utf8_encode($data[1]))
  144.                                     ->setUnidaMedida($um)
  145.                                     ->setCodigo(utf8_encode($data[0]));
  146.                                 if ($aplicacion)
  147.                                 {
  148.                                     $art->addAplicacione($aplicacion);
  149.                                 }
  150.                                 $em->persist($art);
  151.                         }
  152.                         else
  153.                         {
  154.                                 if ($aplicacion)
  155.                                 {
  156.                                     $art->addAplicacione($aplicacion);
  157.                                 }
  158.                         }
  159.                        
  160.                 }
  161.                 $em->flush();
  162.                 fclose($handle);
  163.            
  164.             }
  165.         }
  166.         return $this->render('almacen/articulo/import.html.twig', [
  167.             'form' => $form2->createView(),
  168.         ]);
  169.     }
  170.     /**
  171.      * @Route("/{art}/{depo}/config", name="app_almacen_articulo_config_stocks", methods={"POST"})
  172.      */
  173.     public function procesarLimitesStocks(Articulo $art, Deposito $depo, Request $request): Response
  174.     {
  175.         try
  176.         {
  177.             $em = $this->getDoctrine()->getManager();
  178.             $repository = $em->getRepository(ArticuloDeposito::class);
  179.             $artDepo = $repository->findArticuloDeposito($art, $depo);
  180.             if (!$artDepo) 
  181.             {
  182.                 $artDepo = new ArticuloDeposito();
  183.                 $artDepo->setArticulo($art)
  184.                         ->setDeposito($depo);
  185.                 $em->persist($artDepo);
  186.             }
  187.             $fields = $request->request->all();
  188.             $artDepo->setStockMinimo($fields['smin'] ? $fields['smin'] : null)
  189.                     ->setStockMaximo($fields['smax'] ? $fields['smax'] : null)
  190.                     ->setStock($fields['stock'] ? $fields['stock'] : null);
  191.             $em->flush();
  192.             return new JsonResponse(['ok' => true]);
  193.         }
  194.         catch(\Exception $e){
  195.                                 return new JsonResponse(['ok' => false, 'msg' => 'No se pudo actuliazr la informacion.']);
  196.         }
  197.     }
  198.     /**
  199.      * Reset the stock for articles in a specific deposit.
  200.      *
  201.      * @Route("/reset/stock", name="app_almacen_articulo_reset_stock", methods={"GET", "POST"})
  202.      * @IsGranted("ROLE_SUPER_ADMIN")
  203.      */
  204.     public function resetStock(ArticuloRepository $articuloRepository, Request $request, EntityManagerInterface $em): Response
  205.     {
  206.         $form = $this->getSelectDeposito();
  207.         $form->handleRequest($request);
  208.         $data = $form->getData();
  209.         $articulos = $articuloRepository->objectArticulosActivos($data['aplicacion']);
  210.         $deposito = $data['deposito'];
  211.         foreach ($articulos as $articulo) 
  212.         {
  213.             $articuloDeposito = $em->getRepository(ArticuloDeposito::class)->findArticuloDeposito($articulo, $deposito);
  214.             if ($articuloDeposito) 
  215.             {
  216.                 $articuloDeposito->setStock(0);
  217.             }
  218.             else
  219.             {
  220.                 $articuloDeposito = new ArticuloDeposito();
  221.                 $articuloDeposito->setArticulo($articulo)
  222.                                 ->setDeposito($deposito)
  223.                                 ->setStock(0)
  224.                                 ;
  225.                 $em->persist($articuloDeposito);
  226.             }
  227.         }
  228.         $em->flush();
  229.         return new JsonResponse(['ok' => true]);
  230.     }
  231.     /**
  232.      * @Route("/configurar", name="app_almacen_articulo_configurar", methods={"GET", "POST"})
  233.      */
  234.     public function configurar(ArticuloRepository $articuloRepository, Request $request): Response
  235.     {
  236.         $form = $this->getSelectDeposito();
  237.         $articulos = array();
  238.         if ($request->isMethod('POST')) 
  239.         {
  240.             $form->handleRequest($request);
  241.             if ($form->isValid())
  242.             {
  243.                 $data = $form->getData();
  244.                 $em = $this->getDoctrine()->getManager();
  245.                 $repository = $em->getRepository(ArticuloDeposito::class);
  246.                 $config = $repository->articulosPorDeposito($data['deposito'], $data['aplicacion']);
  247.                 $aux = array();
  248.                 foreach ($config as $d)
  249.                 {
  250.                     $aux[$d['idArt']] = $d;
  251.                 }
  252.                 $articulos = $em->getRepository(Articulo::class)->articulosActivos($data['aplicacion']);
  253.                 //throw new \Exception(print_r($config, true));
  254.                 foreach($articulos as $k => $v) 
  255.                 {
  256.                     $smin = $smax = $stock = null;
  257.                    // $key = array_search($v['idArt'], array_column($config, 'idArt'));
  258.                     if (array_key_exists($v['idArt'], $aux))
  259.                     {
  260.                         $a = $aux[$v['idArt']];
  261.                         $smin = $a['minimo'];
  262.                         $smax = $a['maximo'];
  263.                         $stock = $a['stock'];
  264.                     }
  265.                     else
  266.                     {
  267.                        // throw new \Exception(print_r(array_column($config, 'idArt'), true));
  268.                     }
  269.                     $articulos[$k]['minimo'] = $smin;
  270.                     $articulos[$k]['maximo'] = $smax;
  271.                     $articulos[$k]['stock'] = $stock;
  272.                 }
  273.                 return $this->render('almacen/articulo/config.html.twig', [
  274.                     'articulos' => $articulos,
  275.                     'form' =>$form->createView(),
  276.                     'deposito' => $data['deposito']
  277.                     
  278.                 ]);
  279.             }
  280.         }
  281.         return $this->render('almacen/articulo/config.html.twig', [
  282.             'form' =>$form->createView(),
  283.         ]);
  284.     }
  285.     /**
  286.      * @Route("/new", name="app_almacen_articulo_new", methods={"GET", "POST"})
  287.      */
  288.     public function new(Request $request, ArticuloRepository $articuloRepository): Response
  289.     {
  290.         $articulo = new Articulo();
  291.         $form = $this->createForm(ArticuloType::class, $articulo);
  292.         $form->handleRequest($request);
  293.         if ($form->isSubmitted() && $form->isValid()) {
  294.             $articuloRepository->add($articulo, true);
  295.             return $this->redirectToRoute('app_almacen_articulo_index', [], Response::HTTP_SEE_OTHER);
  296.         }
  297.         return $this->renderForm('almacen/articulo/new.html.twig', [
  298.             'articulo' => $articulo,
  299.             'form' => $form,
  300.         ]);
  301.     }
  302.     /**
  303.      * @Route("/{id}", name="app_almacen_articulo_show", methods={"GET"})
  304.      */
  305.     public function show(Articulo $articulo): Response
  306.     {
  307.         return $this->render('almacen/articulo/show.html.twig', [
  308.             'articulo' => $articulo,
  309.         ]);
  310.     }
  311.     /**
  312.      * @Route("/{id}/edit", name="app_almacen_articulo_edit", methods={"GET", "POST"})
  313.      */
  314.     public function edit(Request $request, Articulo $articulo, ArticuloRepository $articuloRepository): Response
  315.     {
  316.         $form = $this->createForm(ArticuloType::class, $articulo);
  317.         $form->handleRequest($request);
  318.         if ($form->isSubmitted() && $form->isValid()) {
  319.             $articuloRepository->add($articulo, true);
  320.             return $this->redirectToRoute('app_almacen_articulo_index', [], Response::HTTP_SEE_OTHER);
  321.         }
  322.         return $this->renderForm('almacen/articulo/edit.html.twig', [
  323.             'articulo' => $articulo,
  324.             'form' => $form,
  325.         ]);
  326.     }
  327.     /**
  328.      * @Route("/{id}", name="app_almacen_articulo_delete", methods={"POST"})
  329.      */
  330.     public function delete(Request $request, Articulo $articulo, ArticuloRepository $articuloRepository): Response
  331.     {
  332.         if ($this->isCsrfTokenValid('delete'.$articulo->getId(), $request->request->get('_token'))) {
  333.             $articuloRepository->remove($articulo, true);
  334.         }
  335.         return $this->redirectToRoute('app_almacen_articulo_index', [], Response::HTTP_SEE_OTHER);
  336.     }
  337. }