src/Controller/Almacen/ArticuloController.php line 326

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