src/Controller/Almacen/ArticuloController.php line 333

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. /**
  21.  * @Route("/almacen/articulo")
  22.  */
  23. class ArticuloController extends AbstractController
  24. {
  25.     /**
  26.      * @Route("/", name="app_almacen_articulo_index", methods={"GET"})
  27.      */
  28.     public function index(ArticuloRepository $articuloRepositoryEntityManagerInterface $em): Response
  29.     {
  30.         $aplicaciones $em->getRepository(AplicacionArticulo::class)->findAll();
  31.         return $this->render('almacen/articulo/index.html.twig', [
  32.             
  33.             'articulos' => $articuloRepository->findBy(['activo' => true], ['descripcion' => 'ASC']),
  34.            // 'articulos' => $articuloRepository->findAll(),
  35.             'aplicaciones' => $aplicaciones,
  36.         ]);
  37.     }
  38.     /**
  39.      * @Route("/add/{id}/aplicacion", name="app_almacen_articulo_add_aplicacion", methods={"POST"})
  40.      */
  41.     public function addAplicacion(Articulo $articuloRequest $requestEntityManagerInterface $em): Response
  42.     {
  43.         try
  44.         {
  45.             $aplicacion $request->request->get('aplicacion');
  46.             if ($aplicacion
  47.             {
  48.                 $aplicacion $em->getRepository(AplicacionArticulo::class)->find($aplicacion);
  49.                 if ($aplicacion
  50.                 {
  51.                     $articulo->addAplicacione($aplicacion);
  52.                     $em->flush();
  53.                 }
  54.                 return new JsonResponse(['ok' => true'aplicacion' => $articulo->getListaAplicaciones()]) ;
  55.             }
  56.         }
  57.         catch(\Exception $e){
  58.                                 return new JsonResponse(['ok' => false]);
  59.         }
  60.             
  61.     }
  62.     /**
  63.      * @Route("/change/{id}/status", name="app_almacen_articulo_change_status", methods={"POST"})
  64.      */
  65.     public function changeStatus(Articulo $articulo): Response
  66.     {
  67.         $em $this->getDoctrine()->getManager();
  68.         $articulo->setActivo(!$articulo->isActivo());
  69.         $em->flush();
  70.         return new JsonResponse(['ok' => true]);
  71.         return $this->render('almacen/articulo/index.html.twig', [
  72.             'articulos' => $articuloRepository->findAll(),
  73.         ]); 
  74.     }
  75.     private function getSelectDeposito()
  76.     {
  77.         return $this->createFormBuilder()
  78.                     ->add('deposito'EntityType::class, 
  79.                                 [
  80.                                     'class' => Deposito::class,
  81.                                 ]
  82.                             )
  83.                     ->add('aplicacion'EntityType::class, 
  84.                                 [
  85.                                     'class' => AplicacionArticulo::class,
  86.                                     'required' => true,
  87.                                 ]
  88.                                 )
  89.                     ->add('cargar'SubmitType::class)
  90.                     ->getForm();
  91.     }
  92.     /**
  93.      * @Route("/importar", name="app_almacen_articulo_importar_index", methods={"GET", "POST"})
  94.      */
  95.     public function importarArticulos(Request $requestUnidadMedidaRepository $unidadMedidaRepository): Response
  96.     {
  97.         $form2 $this->createFormBuilder()
  98.                     ->add('archivo'FileType::class)
  99.                     ->add('cargar'SubmitType::class)
  100.                     ->add('aplicacion'EntityType::class, 
  101.                                 [
  102.                                     'class' => AplicacionArticulo::class,
  103.                                     'required' => false,
  104.                                 ]
  105.                                 )
  106.                     ->getForm();
  107.         $form2->handleRequest($request);
  108.         $aux = array();
  109.         
  110.         if ($form2->isSubmitted() && $form2->isValid()) 
  111.         {
  112.             $aplicacion $form2->get('aplicacion')->getData();
  113.             $em $this->getDoctrine()->getManager();
  114.             $file $form2->get('archivo')->getData();   
  115.             
  116.             if (($handle fopen($file->getPathname(), "r")) !== false
  117.             {
  118.                 while (($data fgetcsv($handle1000';')) !== false
  119.                 {
  120.                         $um null;
  121.                         if (isset($data[2]) && ($data[2]))
  122.                         {
  123.                             $nameum strtoupper(utf8_encode($data[2]));
  124.                             $um $unidadMedidaRepository->findWithName($nameum);
  125.                         }
  126.                         
  127.                         $codigo = isset($data[0]) ? utf8_encode($data[0]) : null;
  128.                         $art null;
  129.                         if ($codigo
  130.                         {
  131.                             $art $em->getRepository(Articulo::class)->findOneBy(['codigo' => $codigo]);
  132.                         }
  133.                         if (!$art
  134.                         {
  135.                                 $art = new Articulo();
  136.                                 $art->setDescripcion(utf8_encode($data[1]))
  137.                                     ->setUnidaMedida($um)
  138.                                     ->setCodigo(utf8_encode($data[0]));
  139.                                 if ($aplicacion)
  140.                                 {
  141.                                     $art->addAplicacione($aplicacion);
  142.                                 }
  143.                                 $em->persist($art);
  144.                         }
  145.                         else
  146.                         {
  147.                                 if ($aplicacion)
  148.                                 {
  149.                                     $art->addAplicacione($aplicacion);
  150.                                 }
  151.                         }
  152.                        
  153.                 }
  154.                 $em->flush();
  155.                 fclose($handle);
  156.            
  157.             }
  158.         }
  159.         return $this->render('almacen/articulo/import.html.twig', [
  160.             'form' => $form2->createView(),
  161.         ]);
  162.     }
  163.     /**
  164.      * @Route("/{art}/{depo}/config", name="app_almacen_articulo_config_stocks", methods={"POST"})
  165.      */
  166.     public function procesarLimitesStocks(Articulo $artDeposito $depoRequest $request): Response
  167.     {
  168.         try
  169.         {
  170.             $em $this->getDoctrine()->getManager();
  171.             $repository $em->getRepository(ArticuloDeposito::class);
  172.             $artDepo $repository->findArticuloDeposito($art$depo);
  173.             if (!$artDepo
  174.             {
  175.                 $artDepo = new ArticuloDeposito();
  176.                 $artDepo->setArticulo($art)
  177.                         ->setDeposito($depo);
  178.                 $em->persist($artDepo);
  179.             }
  180.             $fields $request->request->all();
  181.             $artDepo->setStockMinimo($fields['smin'] ? $fields['smin'] : null)
  182.                     ->setStockMaximo($fields['smax'] ? $fields['smax'] : null)
  183.                     ->setStock($fields['stock'] ? $fields['stock'] : null);
  184.             $em->flush();
  185.             return new JsonResponse(['ok' => true]);
  186.         }
  187.         catch(\Exception $e){
  188.                                 return new JsonResponse(['ok' => false'msg' => 'No se pudo actuliazr la informacion.']);
  189.         }
  190.     }
  191.     /**
  192.      * @Route("/configurar", name="app_almacen_articulo_configurar", methods={"GET", "POST"})
  193.      */
  194.     public function configurar(ArticuloRepository $articuloRepositoryRequest $request): Response
  195.     {
  196.         $form $this->getSelectDeposito();
  197.         $articulos = array();
  198.         if ($request->isMethod('POST')) 
  199.         {
  200.             $form->handleRequest($request);
  201.             if ($form->isValid())
  202.             {
  203.                 $data $form->getData();
  204.                 $em $this->getDoctrine()->getManager();
  205.                 $repository $em->getRepository(ArticuloDeposito::class);
  206.                 $config $repository->articulosPorDeposito($data['deposito'], $data['aplicacion']);
  207.                 $aux = array();
  208.                 foreach ($config as $d)
  209.                 {
  210.                     $aux[$d['idArt']] = $d;
  211.                 }
  212.                 $articulos $em->getRepository(Articulo::class)->articulosActivos($data['aplicacion']);
  213.                 //throw new \Exception(print_r($config, true));
  214.                 foreach($articulos as $k => $v
  215.                 {
  216.                     $smin $smax $stock null;
  217.                    // $key = array_search($v['idArt'], array_column($config, 'idArt'));
  218.                     if (array_key_exists($v['idArt'], $aux))
  219.                     {
  220.                         $a $aux[$v['idArt']];
  221.                         $smin $a['minimo'];
  222.                         $smax $a['maximo'];
  223.                         $stock $a['stock'];
  224.                     }
  225.                     else
  226.                     {
  227.                        // throw new \Exception(print_r(array_column($config, 'idArt'), true));
  228.                     }
  229.                     $articulos[$k]['minimo'] = $smin;
  230.                     $articulos[$k]['maximo'] = $smax;
  231.                     $articulos[$k]['stock'] = $stock;
  232.                 }
  233.                 return $this->render('almacen/articulo/config.html.twig', [
  234.                     'articulos' => $articulos,
  235.                     'form' =>$form->createView(),
  236.                     'deposito' => $data['deposito']
  237.                     
  238.                 ]);
  239.             }
  240.         }
  241.         return $this->render('almacen/articulo/config.html.twig', [
  242.             'form' =>$form->createView(),
  243.         ]);
  244.     }
  245.     /**
  246.      * @Route("/new", name="app_almacen_articulo_new", methods={"GET", "POST"})
  247.      */
  248.     public function new(Request $requestArticuloRepository $articuloRepository): Response
  249.     {
  250.         $articulo = new Articulo();
  251.         $form $this->createForm(ArticuloType::class, $articulo);
  252.         $form->handleRequest($request);
  253.         if ($form->isSubmitted() && $form->isValid()) {
  254.             $articuloRepository->add($articulotrue);
  255.             return $this->redirectToRoute('app_almacen_articulo_index', [], Response::HTTP_SEE_OTHER);
  256.         }
  257.         return $this->renderForm('almacen/articulo/new.html.twig', [
  258.             'articulo' => $articulo,
  259.             'form' => $form,
  260.         ]);
  261.     }
  262.     /**
  263.      * @Route("/{id}", name="app_almacen_articulo_show", methods={"GET"})
  264.      */
  265.     public function show(Articulo $articulo): Response
  266.     {
  267.         return $this->render('almacen/articulo/show.html.twig', [
  268.             'articulo' => $articulo,
  269.         ]);
  270.     }
  271.     /**
  272.      * @Route("/{id}/edit", name="app_almacen_articulo_edit", methods={"GET", "POST"})
  273.      */
  274.     public function edit(Request $requestArticulo $articuloArticuloRepository $articuloRepository): Response
  275.     {
  276.         $form $this->createForm(ArticuloType::class, $articulo);
  277.         $form->handleRequest($request);
  278.         if ($form->isSubmitted() && $form->isValid()) {
  279.             $articuloRepository->add($articulotrue);
  280.             return $this->redirectToRoute('app_almacen_articulo_index', [], Response::HTTP_SEE_OTHER);
  281.         }
  282.         return $this->renderForm('almacen/articulo/edit.html.twig', [
  283.             'articulo' => $articulo,
  284.             'form' => $form,
  285.         ]);
  286.     }
  287.     /**
  288.      * @Route("/{id}", name="app_almacen_articulo_delete", methods={"POST"})
  289.      */
  290.     public function delete(Request $requestArticulo $articuloArticuloRepository $articuloRepository): Response
  291.     {
  292.         if ($this->isCsrfTokenValid('delete'.$articulo->getId(), $request->request->get('_token'))) {
  293.             $articuloRepository->remove($articulotrue);
  294.         }
  295.         return $this->redirectToRoute('app_almacen_articulo_index', [], Response::HTTP_SEE_OTHER);
  296.     }
  297. }