src/Controller/FormulaController.php line 53

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Formula;
  6. use App\Entity\Models\FrontModels\ColorDTO;
  7. use App\Form\FormulaType;
  8. use App\Repository\FormulaRepository;
  9. use App\Service\ColorService;
  10. use App\Service\FormulaService;
  11. use FOS\RestBundle\Controller\AbstractFOSRestController;
  12. use JMS\Serializer\SerializationContext;
  13. use FOS\RestBundle\Controller\Annotations as Rest;
  14. use JMS\Serializer\SerializerInterface;
  15. use Monolog\Handler\StreamHandler;
  16. use Monolog\Logger;
  17. use Psr\Log\LoggerInterface;
  18. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpFoundation\Response;
  21. use Symfony\Component\Routing\Annotation\Route;
  22. use JMS\Serializer\SerializerBuilder;
  23. use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
  25. class FormulaController extends AbstractFOSRestController
  26. {
  27.     private $service;
  28.     private $serviceColor;
  30.     private $log ;
  32.     /**
  33.      * FormulaController constructor.
  34.      */
  35.     public function __construct(
  36.         FormulaService $service,
  37.         ColorService $serviceColor,
  38.         LoggerInterface $logger,
  39.         string $projectDir
  40.     )
  41.     {
  42.         $this->service      = $service;
  43.         $this ->serviceColor= $serviceColor;
  44.         $this->projectDir = $projectDir;
  45.         $this->log = $logger;
  46.     }
  49.     /**
  50.      * @Rest\Get("api/obtenerFormulas", name="obtener_formulas_convertidor")
  51.      * @param idColor       Clave del color del que queremos extraer las fórmulas.
  52.      */
  53.     public function obtenerFormulas(Request $request)
  54.     {
  56.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  57.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  58.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  59.             )
  60.         )->build();
  61.         $idColor = $request->get('idColor');
  62.         $idTipo  = $request->get('tipo');
  63.         $plomo  = $request->get('plomo');
  64.         $prueba  = $request->get('prueba');
  65.         $usr= $this->get('security.token_storage')->getToken()->getUser();
  67.         if(isset($idColor)&&isset($idTipo)) {
  68.             $data = $this->service->getAllByColor($idColor,$usr,$idTipo,$plomo);
  69.             $code =  Response::HTTP_OK;
  70.         } elseif (isset($prueba)) {
  71.             // TODO: TERMINAR PROCEDIMINTO
  72.             $data = $this->service->getAllByPrueba();
  73.             $code =  Response::HTTP_OK;
  74.         }else{
  75.             $data = ['error' => 'Faltan parámetros en el criterio de búsqueda'];
  76.             $code = Response::HTTP_FAILED_DEPENDENCY;
  77.         }
  79.         if($data)
  80.         {
  81.             $code = Response::HTTP_OK;
  82.         }else{
  83.             $data = [];
  84.         }
  86.         $serializacion = SerializationContext::create()->setGroups(['detalle','componenteFormula']);
  87.         $response =  new Response($serializer->serialize($data, "json",$serializacion),$code);
  88.         $response->headers->set('Content-Type', 'json');
  89.         $response->prepare($request);
  90.         return $response;
  91.     }
  93.     /**
  94.      * @Rest\Get("/formula", name="formula_index")
  95.      */
  96.     public function index(FormulaRepository $formulaRepository): Response
  97.     {
  98.         return $this->render('formula/index.html.twig', ['formulas' => $formulaRepository->findAll()]);
  99.     }
  104.    /**
  105.     * @Rest\Post("/api/formulasPersonalesUpdate", name="formulasPersonalesUpdate")
  106.     */
  107.     public function createFormulasPersonal(Request $request, SerializerInterface $serializer){
  109.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  110.         if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) {
  111.             $requestObject= json_decode($request->getContent(), true);
  113.             if(isset($requestObject['color'],$requestObject['formula'])) {
  114.                 //Le añadimos los ids de cuenta y usuario, para reutilizar otros metodos
  115.                 $requestObject['color']['cuenta']['id'] = $usr->getId();
  116.                 $requestObject['color']['tipo'] = 2;
  117.                 $requestObject['formula']['cuenta']['id'] = $usr->getId();
  118.                 // $requestObject['formula']['userId'] = 128;
  120.                 //guardamos color si la formula es nueva y no se ha elegido sobreescribir
  121.                 if ($requestObject['formula']['overwritePF'] === false) {
  122.                     try{
  123.                         $color = $this->serviceColor->nuevoColor($requestObject['color']);
  124.                     }catch (\Exception $e){
  125.                         $response =  new Response('KO', Response::HTTP_CONFLICT);
  126.                         /*
  127.                         return [
  128.                             'code' => $e->getCode() ?: 999,
  129.                             'message' => $e->getMessage()?:'API Exception',
  130.                         ];
  131.                         */
  132.                         return $response;
  133.                     }
  135.                     if($color == null){
  136.                         $response =  new Response(Response::HTTP_CONFLICT,Response::HTTP_CONFLICT);
  137.                         return $response;
  138.                     }
  139.                 }
  141.                 //creamos o editamos la formula
  142.                 if ($requestObject['formula']['overwritePF'] === false) {
  143.                     $colorId = $color->getId();
  144.                 } else {
  145.                     $colorId = $requestObject['color']['id'];
  146.                 }
  147.                 $formulaId = $this->service->nuevaFormulaPersonal($requestObject['formula'], $colorId);
  149.                 // Si se está sobreescribiendo la formula, para devolver el mismo color, hay que buscarlo antes
  150.                 if ($requestObject['formula']['overwritePF'] === true) {
  151.                     $color = $this->serviceColor->findByIdPersonal($colorId);
  152.                 }
  153.                 $return = new ColorDTO();
  154.                 $return->setId($color->getId());
  155.                 $return->setCodigo($color->getCodigo());
  156.                 $return->setNombre($color->getNombre());
  157.                 $return->setPosicionCT('');
  158.                 $return->setCliente($color->getClienteFinal()->getNombre()); 
  159.                 $return->setTipo(2);
  160.                 $return->setDisponible(true);
  161.                 $return->setActivo(true);
  162.                 $return->setFormulaId($formulaId);
  164.                 $response =  new Response($serializer->serialize($return, 'json'),Response::HTTP_OK);
  165.                 return $response;
  166.             }else{
  167.                 $response =  new Response(Response::HTTP_BAD_REQUEST);
  168.                 return $response;
  169.             }
  170.         }else{
  171.             $response =  new Response(Response::HTTP_BAD_REQUEST);
  172.             return $response;
  173.         }
  176.     }
  180.     /*
  181.      *     ADMINISTRADOR
  182.      */
  185.     /**
  186.      * @Route("/api/admin/formulaObject", name="formulaById", methods="GET")
  187.      */
  188.     public function getFormulaOficial(Request $request){
  189.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  190.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  191.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  192.             )
  193.         )->build();
  194.         $response =  new Response(Response::HTTP_BAD_REQUEST);
  196.         if ($request->query->get('idFormula') != null && $request->query->get('idFormula') != "") {
  197.             $correcto = $this->service->findById($request->query->get('idFormula') );
  198.         }
  199.         if ($request->query->get('codigoFormula') != null && $request->query->get('codigoFormula') != "") {
  200.             $correcto = $this->service->findByCodigo($request->query->get('codigoFormula') );
  201.         }
  203.         $serializacion = SerializationContext::create()->setGroups(['detalle','componenteFormula','listAdminFormula']);
  204.         $response =  new Response($serializer->serialize($correcto, 'json', $serializacion),Response::HTTP_OK);
  205.         // $response =  new Response($serializer->serialize($correcto, 'json', SerializationContext::create()->setGroups('listAdminFormula')),Response::HTTP_OK);
  207.         //$response =  new Response($serializer->serialize($data, 'json'),Response::HTTP_OK);
  208.         $response->headers->set('Content-Type', 'json'); //xml
  209.         $response->prepare($request);
  211.         return $response;
  212.     }
  214.     /**
  215.      * @Route("/api/admin/formulasOficiales", name="list_formulas_oficiales", methods="GET")
  216.      */
  217.     public function getFormulasOficiales(Request $request){
  218.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  219.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  220.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  221.             )
  222.         )->build();
  223.         $response =  new Response(Response::HTTP_BAD_REQUEST);
  225.         if ($request ->query ->get('idColor')!=null && $request ->query ->get('idColor')!="") {
  227.                 $correcto = $this ->serviceColor ->findById($request ->query ->get('idColor') );
  228.         }
  229.         $serializacion = SerializationContext::create()->setGroups(['detalle','componenteFormula','listAdminFormula']);
  231.         $response =  new Response($serializer->serialize($correcto, 'json',$serializacion),Response::HTTP_OK);
  233.         //$response =  new Response($serializer->serialize($data, 'json'),Response::HTTP_OK);
  234.         $response->headers->set('Content-Type', 'json'); //xml
  235.         $response->prepare($request);
  237.         return $response;
  238.     }
  240.     /**
  241.      * @Route("/api/admin/formulasPrueba", name="formulaByPrueba", methods="GET")
  242.      */
  243.     public function getFormulasPrueba(Request $request){
  244.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  245.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  246.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  247.             )
  248.         )->build();
  249.         $response =  new Response(Response::HTTP_BAD_REQUEST);
  251.         $correcto = $this->service->getAllByPrueba();
  253.         $serializacion = SerializationContext::create()->setGroups(['detalle','componenteFormula','listAdminFormula']);
  254.         $response =  new Response($serializer->serialize($correcto, 'json', $serializacion),Response::HTTP_OK);
  255.         // $response =  new Response($serializer->serialize($correcto, 'json', SerializationContext::create()->setGroups('listAdminFormula')),Response::HTTP_OK);
  257.         //$response =  new Response($serializer->serialize($data, 'json'),Response::HTTP_OK);
  258.         $response->headers->set('Content-Type', 'json'); //xml
  259.         $response->prepare($request);
  261.         return $response;
  262.     }
  264.     /**
  265.      * @Route("/api/admin/formulasPersonales", name="list_getFormulasPersonales", methods="GET")
  266.      */
  267.     public function getFormulasPersonales(Request $request){
  268.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  269.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  270.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  271.             )
  272.         )->build();
  274.         if ($request ->query ->get('idColor')!=null && $request ->query ->get('idColor')!="") {
  276.             $correcto = $this ->serviceColor ->findByIdPersonal($request ->query ->get('idColor') );
  278.         }
  279.         $serializacion = SerializationContext::create()->setGroups(['detalle','componenteFormula','listAdminFormula']);
  281.         $response =  new Response($serializer->serialize($correcto, 'json',$serializacion),Response::HTTP_OK);
  283.         //$response =  new Response($serializer->serialize($data, 'json'),Response::HTTP_OK);
  284.         $response->headers->set('Content-Type', 'json'); //xml
  285.         $response->prepare($request);
  287.         return $response;
  288.     }
  290.     /**
  291.      * @Rest\Post("/api/admin/formulasOficialesAssociate", name="AssociateFormulasOficiales")
  292.      */
  293.     public function asociarFormulasOficiales(Request $request){
  294.         $correcto = null;
  295.         $response =  new Response(Response::HTTP_BAD_REQUEST);
  296.         if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) {
  297.             $datos= json_decode($request->getContent(), true);
  298.             if (isset($datos['colorId']) && isset($datos['formulaId']) && !isset($datos['unlink'])) {
  299.                 //$correcto= null;
  300.                 $correcto = $this ->service ->asociarFormulaOficial($datos);
  301.             } else if (isset($datos['unlink']) ){
  302.                 //Tenemos unlink por lo que es una desasociacion
  303.                 $correcto = $this ->service ->desAsociarFormulaOficial($datos);
  304.             }
  305.         }
  307.         if($correcto != 0){
  308.             $response =  new Response(Response::HTTP_OK);
  309.         }else{
  310.             $response =  new Response(Response::HTTP_BAD_REQUEST);
  311.         }
  312.         $response->prepare($request);
  313.         return $response;
  314.     }
  316.     /**
  317.      * @Rest\Post("/api/admin/formulasOficialesUpate", name="CreateOrUpdateFormulasOficiales")
  318.      */
  319.     public function updateFormulasOficiales(Request $request){
  320.         $correcto = null;
  321.         $response =  new Response(Response::HTTP_BAD_REQUEST);
  322.         if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) {
  323.             $formula= json_decode($request->getContent(), true);
  324.             if(isset($formula['idColor']) && empty($formula['id'])){
  325.                 //$correcto= null;
  326.                 $correcto = $this ->service ->nuevaFormulaOficial($formula);
  327.             }else if(isset($formula['id']) ){
  328.                 //Tenemos Id por lo que es una actulizacion
  329.                 $correcto = $this ->service ->modificaFormulaOficial($formula);
  330.             }
  331.         }
  333.         if($correcto != null){
  334.             $response =  new Response(Response::HTTP_OK);
  335.         }else{
  336.             $response =  new Response(Response::HTTP_BAD_REQUEST);
  337.         }
  338.         $response->prepare($request);
  339.         return $response;
  340.     }
  342.     /**
  343.      * @Route("/api/admin/formulasPersonalesUpdate", name="updateFormulasPersonal_Admin", methods="POST")
  344.      */
  345.     public function updateFormulasPersonal(Request $request){
  346.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  347.         if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) {
  348.             $requestObject= json_decode($request->getContent(), true);
  349.             if(isset($requestObject['idColor'],$requestObject['formula'])) {
  350.                 //Le añadimos los ids de usuario, para reutilizar otros metodos
  351.                 $requestObject['formula']['userId'] = $usr->getId();
  352.                 //guardamos formula
  353.                 $this->service->nuevaFormulaPersonal($requestObject['formula'],$requestObject['idColor']);
  354.                 $response =  new Response(Response::HTTP_OK);
  355.                 return $response;
  356.             }else{
  357.                 $response =  new Response(Response::HTTP_BAD_REQUEST);
  358.                 return $response;
  359.             }
  361.         }else{
  362.             $response =  new Response(Response::HTTP_BAD_REQUEST);
  363.             return $response;
  364.         }
  365.     }
  367.     /**
  368.      * @Route("/api/admin/obtenerFormulasExpertis", name="obtenerFormulas_Expertis", methods="GET")
  369.      */
  370.     public function obtenerFormulasParaExpertis(Request $request) {
  371.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  372.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  373.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  374.             )
  375.         )->build();
  376.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  377.         if($usr != 'anon.') {
  378.             $colores = $this ->serviceColor->getByActivo();
  379.             $serializacion = SerializationContext::create()->setGroups(['detalle','componenteFormula','listAdminFormula']);
  381.             $response =  new Response($serializer->serialize($colores, 'json', $serializacion),Response::HTTP_OK);
  383.             //$response =  new Response($serializer->serialize($data, 'json'),Response::HTTP_OK);
  384.             $response->headers->set('Content-Type', 'json'); //xml
  385.             $response->prepare($request);
  386.             return $response;
  387.         } else {
  388.             $response =  new Response(Response::HTTP_BAD_REQUEST,Response::HTTP_BAD_REQUEST);
  389.             return $response;
  390.         }
  391.     }
  393.     /**
  394.      * @Route("/api/admin/obtenerFormulasCartasExpertis", name="obtenerFormulasCartas_Expertis", methods="GET")
  395.      */
  396.     public function obtenerFormulasCartasParaExpertis(Request $request) {
  397.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  398.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  399.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  400.             )
  401.         )->build();
  402.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  403.         if($usr != 'anon.') {
  404.             $formulasCartas = $this ->service->getExportFormulasCT();
  405.             $response =  new Response($serializer->serialize($formulasCartas, 'json'),Response::HTTP_OK);
  406.             $response->headers->set('Content-Type', 'json'); //xml
  407.             $response->prepare($request);
  408.             return $response;
  409.         } else {
  410.             $response =  new Response(Response::HTTP_BAD_REQUEST,Response::HTTP_BAD_REQUEST);
  411.             return $response;
  412.         }
  413.     }
  415.     /**
  416.      * @Route("/api/admin/generaExportExcel", name="generaExportExcel_Admin", methods="GET")
  417.      */
  418.     public function generaExcelFormula(Request $request){
  419.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  420.         if($usr != 'anon.') {
  421.             $logDir = $this->projectDir;
  422.             $nameLog = $logDir."/var/log/".date_format(new \DateTime(), 'Ymd_His') . "generaExcelFormula.log";
  423.             $this->log = new Logger($nameLog);
  424.             $this->log->pushHandler(new StreamHandler($nameLog, Logger::INFO));
  425.             $this->log->info("El usuario que solicita la exportacion tiene el id: " . $usr->getId());
  428.             $nombreFichero = "Exportacion_de_formulas_".date_format(new \DateTime(), 'Ymd_His');
  429.             try {
  430.                 $this->log->info("DEBUG 1");
  431.                 $excel = $this->service->generaExcelExportFormulas();
  432.                 $this->log->info("DEBUG 2");
  433.                 $writer = new Xlsx($excel);
  434.                 //Definimos su ruta
  435.                 $excelFilepath = $logDir."/var/tmp_upload/".date_format(new \DateTime(), 'Ymd_His').$nombreFichero.".xlsx";
  436.                 //Lo guardamos
  437.                 $writer->save($excelFilepath);
  438.                 $this->log->info("DEBUG 3");
  440.                 $response = new BinaryFileResponse($excelFilepath);
  441.                 $response->headers->set('Content-Type', 'application/vnd.ms-excel'); //xml
  442.                 $response->headers->set('Content-Disposition', 'attachment; filename="' . $nombreFichero . '.xlsx"'); //xml
  443.                 $this->log->info("DEBUG 4");
  444.                 return $response;
  445.             } catch (\Exception $e) {
  446.                 $this->log->error($e->getMessage());
  447.                 $response =  new Response(Response::HTTP_BAD_REQUEST,Response::HTTP_BAD_REQUEST);
  448.                 return $response;
  449.             }
  450.         }else{
  451.             $response =  new Response(Response::HTTP_BAD_REQUEST,Response::HTTP_BAD_REQUEST);
  452.             return $response;
  453.         }
  454.     }
  456.     /**
  457.      * @Route("/api/admin/generaExportExcelCT", name="generaExportExcelCT_Admin", methods="GET")
  458.      */
  459.     public function generaExportExcelCT(Request $request){
  460.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  461.         if($usr != 'anon.') {
  462.             $logDir = $this->projectDir;
  463.             $nameLog = $logDir."/var/log/".date_format(new \DateTime(), 'Ymd_His') . "generaExcelFormula.log";
  464.             $this->log = new Logger($nameLog);
  465.             $this->log->pushHandler(new StreamHandler($nameLog, Logger::INFO));
  466.             $this->log->info("El usuario que solicita la exportacion tiene el id: " . $usr->getId());
  469.             $nombreFichero = "Exportacion_de_formulas_cartas";
  470.             try {
  471.                 $excel = $this->service->generaExcelExportFormulasCT();
  473.                 $writer = new Xlsx($excel);
  474.                 //Definimos su ruta
  475.                 $excelFilepath = $logDir."/var/tmp_upload/".$nombreFichero.".xlsx";
  476.                 //Lo guardamos
  477.                 $writer->save($excelFilepath);
  479.                 $response = new BinaryFileResponse($excelFilepath);
  480.                 $response->headers->set('Content-Type', 'application/vnd.ms-excel'); //xml
  481.                 $response->headers->set('Content-Disposition', 'attachment; filename="' . $nombreFichero . '.xlsx"'); //xml
  482.                 return $response;
  483.             } catch (\Exception $e) {
  484.                 $this->log->error($e->getMessage());
  485.                 $response =  new Response(Response::HTTP_BAD_REQUEST,Response::HTTP_BAD_REQUEST);
  486.                 return $response;
  487.             }
  489.         }else{
  490.             $response =  new Response(Response::HTTP_BAD_REQUEST,Response::HTTP_BAD_REQUEST);
  491.             return $response;
  492.         }
  494.     }
  498.     /**
  499.      * @Route("/api/importFormulaPersonales", name="import_access_personal", methods="POST")
  500.      */
  501.      public function setAccessFormulaPersonal(Request $request){
  503.      }
  504. }