src/Controller/HistoricoController.php line 109

Open in your IDE?
  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: carlosmb
  5.  * Date: 14/11/2018
  6.  * Time: 10:12
  7.  */
  8. namespace App\Controller;
  10. use App\Entity\Historico;
  11. use App\Form\HistoricoType;
  12. use App\Repository\ComponenteRepository;
  13. use App\Service\ColorService;
  14. use App\Service\ComponenteService;
  15. use App\Service\FormulaService;
  16. use App\Service\UsuarioService;
  17. use FOS\RestBundle\Controller\AbstractFOSRestController;
  18. use FOS\RestBundle\Controller\Annotations as Rest;
  19. use JMS\Serializer\SerializationContext;
  20. use App\Service\HistoricoService;
  21. use phpDocumentor\Reflection\DocBlock\Serializer;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\HttpFoundation\Response;
  24. use JMS\Serializer\SerializerBuilder;
  26. use Monolog\Logger;
  27. use Monolog\Handler\StreamHandler;
  28. class HistoricoController extends AbstractFOSRestController
  29. {
  30.    private $serviceHistorico;
  31.    private $serviceFomula;
  32.    private $serviceComponent;
  33.    private $serviceColor;
  34.    private $serviceUsuario;
  37.    public function __construct(HistoricoService $service,
  38.                                FormulaService $serviceFormula,
  39.                                ComponenteService $serviceComponent,
  40.                                ColorService $serviceColor,
  41.                                 UsuarioService $serviceUsuario
  42.                                 )
  43.     {
  44.         $this->serviceHistorico = $service;
  45.         $this->serviceFomula = $serviceFormula;
  46.         $this->serviceComponent = $serviceComponent;
  47.         $this->serviceColor = $serviceColor;
  48.         $this-> serviceUsuario = $serviceUsuario;
  50.     }
  52.     /**
  53.      * Devuelve los datos del histórico de las pesadas.
  54.      * @Rest\Post("api/obtenerHistorico", name="obtener_historico" )
  55.      * @return $response;
  56.      */
  57.     public function obtenerHistorico(Request $request)
  58.     {
  59.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  60.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  61.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  62.             )
  63.         )->build();
  64.         foreach ($request->request->keys() as $key)
  65.             $request->request->filter($key);
  66.         if(sizeof($request->request->keys()) == 0)
  67.             $data = $this->serviceHistorico->obtenerHistorico();
  68.         else
  69.             $data = $this->serviceHistorico->obtenerHistoricoFiltrado($request->request);
  72.         $serializacion = SerializationContext::create()->setGroups(['listado']);
  73.         $response = new Response( $serializer->serialize($data,'json',$serializacion),Response::HTTP_OK);
  74.         return $response;
  75.     }
  78.     /**
  79.      * Devuelve un objeto con todos los datos de una pesada almacenados en la tabla histórico
  80.      * @Rest\Get("api/obtenerDetalleHistorico", name="obtener_deetalle_historico" )
  81.      * @param id [int] id unico de la lína del histórico a mostrar
  82.      * @return  Historico [obj] objeto de los datos del historico
  83.      */
  85.     public function obtenerDetalleHistorico(Request $request)
  86.     {
  87.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  88.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  89.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  90.             )
  91.         )->build();
  93.         $serializacion = SerializationContext::create()->setGroups(['detalle','formula_group']);
  94.         $id = $request->get('id');
  95.         if($id != null)
  96.             $data = $this->serviceHistorico->obtenerDetalleHistorico($id);
  97.         else
  98.             $data = null;
  99.         //dd($data);
  100.         $response = new Response( $serializer->serialize($data,'json',$serializacion),Response::HTTP_OK);
  101.         return $response;
  102.     }
  104.     /**
  105.      * @Rest\Post("api/guardarHistorico", name = "guardar_historico")
  106.      * Recibe los datos de una pesada y los almacena en el histórico,
  107.      * Siempre y cuando los datos estén correctos.
  108.      */
  109.     public function guardarHistorico(Request $request)
  110.     {
  112.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  115.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  116.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  117.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  118.             )
  119.         )->build();
  120.         $id= null;
  121.         if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) {
  122.             $objectos = json_decode($request->getContent(), true);
  123.             $objectos['userId']=$usr ->getId();
  125.             $id= $this->serviceHistorico->guardarHistorico($objectos);
  126.         }
  128.         $response =  new Response($serializer->serialize($id ->getId(), 'json'),Response::HTTP_OK);
  129.         $response->headers->set('Content-Type', 'json');
  130.         $response->prepare($request);
  132.         return $response;
  135.     }
  137.     /**
  138.      * @Rest\Post("api/actualizarHistorico", name = "actualizar_historico")
  139.      * Actualiza SOLO dos parámetros del histórico; el proyecto al que está vinculado la pesada
  140.      *     y el número de orden de la misnma
  141.      */
  142.     public function actualizarHistorico(Request $request): Response
  143.     {
  144.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  147.         $id= null;
  148.         if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) {
  149.             $objectos = json_decode($request->getContent(), true);
  151.             //dd($objectos);
  152.             if( $this->serviceHistorico->actualizaHistorico($objectos, $usr)){
  153.                 $response =  new Response(Response::HTTP_OK);
  154.                 $response->headers->set('Content-Type', 'json');
  155.                 $response->prepare($request);
  157.             }else{
  158.                 $response =  new Response(Response::HTTP_BAD_REQUEST);
  159.                 $response->headers->set('Content-Type', 'json');
  160.                 $response->prepare($request);
  162.             }
  163.             return $response;
  164.         }
  165.         //return new Response("actuaclización correcta", Response::HTTP_OK);
  166.     }
  168.     /**
  169.      * @Rest\Post("api/historico/gestionOrden", name = "gestiona_orden")
  170.      * Siempre y cuando los datos estén correctos.
  171.      */
  172.     public function actualizaOrden(Request $request){
  173.         try{
  175.             if (0 === strpos($request->headers->get('Content-Type'), 'application/json')) {
  176.                 $cuenta = $this->get('security.token_storage')->getToken()->getUser();
  178.                 $objectos = json_decode($request->getContent(), true);
  180.                 $data = $this->serviceHistorico->actualizaOrden($objectos,$cuenta);
  181.                 if($data==0){
  182.                     //existe una orden con el mismo nombre
  183.                     return new Response(0, Response::HTTP_CONFLICT);
  184.                 }
  185.                 //Devuelve
  186.                 //Context visitingStack not working well
  187.                 $response = new Response($data,Response::HTTP_OK);
  189.                 return $response;
  190.             }else{
  191.                 return new Response('KO', Response::HTTP_BAD_REQUEST);
  192.             }
  193.         }catch (\Exception $e){
  195.             return new Response($e->getMessage(), Response::HTTP_BAD_REQUEST);
  196.         }
  198.         return new Response('KO-Finall', Response::HTTP_BAD_REQUEST);
  199.     }
  202.     /**
  203.      * @Rest\Get("api/historico/numeroOrden", name="obtener_numero_orden")
  204.      *
  205.      */
  206.     public function getNumeroOrden()
  207.     {
  208.         try{
  209.             $cuenta = $this->get('security.token_storage')->getToken()->getUser();
  210.             return new Response($this->serviceHistorico->getNumeroOrden($cuenta), Response::HTTP_OK);
  211.         }catch (\Exception $e){
  212.             $this->log->error($e->getMessage());
  213.             return new Response('KO', Response::HTTP_BAD_REQUEST);
  214.         }
  215.     }
  220.     /**
  221.      * @Rest\Get("api/orden", name = "buscarOrden")
  222.      * Buca las ordenes y los proyectos asignados a una cuenta
  223.      */
  224.     public function buscaOrden(Request $request): Response
  225.     {
  226.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  227.         $sOrden = $request ->query ->get('orden');
  228.         $id= null;
  230.         $response =  new Response(Response::HTTP_BAD_REQUEST);
  231.         $response->headers->set('Content-Type', 'json');
  232.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  233.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  234.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  235.             )
  236.         )->build();
  237.         //dd($sOrden);
  238.         if(isset($sOrden) && $sOrden !=""){
  239.             $data =  $this->serviceHistorico->findOrden($sOrden, $usr);
  240.             //dd($data);
  242.                $serializacion = SerializationContext::create()->setGroups(['listado']);
  245.                 $response =  new Response($serializer->serialize($data,'json',$serializacion),Response::HTTP_OK);
  246.                 $response->headers->set('Content-Type', 'json');
  247.                 $response->prepare($request);
  248.             
  249.         }
  250.         return $response;
  252.     }
  253.     /**
  254.      * @Rest\Get("api/cliente", name = "buscarCliente")
  255.      * Buca las cliente y los proyectos asignados a una cuenta
  256.      */
  257.     public function buscaCliente(Request $request): Response
  258.     {
  260.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  261.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  262.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  263.             )
  264.         )->build();
  266.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  267.         $sCliente="";
  268.         if($request ->query ->get('cliente')) {
  269.             $sCliente = $request ->query ->get('cliente');
  270.         }
  272.         $response =  new Response(Response::HTTP_BAD_REQUEST);
  273.         $response->headers->set('Content-Type', 'json');
  275.         $data =  $this->serviceHistorico->findCliente($sCliente, $usr);
  277.         if(sizeof($data)>0){
  279.             $serializacion = SerializationContext::create()->setGroups(array('listado'));
  280.             $response =  new Response($serializer->serialize(
  281.                 $data,'json', $serializacion),Response::HTTP_OK);
  282.             $response->headers->set('Content-Type', 'json');
  283.             $response->prepare($request);
  284.         }else{
  285.             $response =  new Response($serializer->serialize([],'json'),Response::HTTP_OK);
  286.             $response->headers->set('Content-Type', 'json');
  287.             $response->prepare($request);
  288.         }
  290.         return $response;
  292.     }
  295.     /*
  296.      *          PETICIONES DE ESTADISTICAS
  297.      */
  299.     /**
  300.      * @Rest\Get("api/obtenerEstadisticas", name="obtener_estadisticas_Cliente" )
  301.      * @return  Historico [obj] objeto de los datos del historico
  302.      */
  303.     public function obtenerEstadisticasHistoricosCliente(Request $request){
  304.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  305.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  306.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  307.             )
  308.         )->build();
  309.         $usr = $this->get('security.token_storage')->getToken()->getUser();
  311.         $fecha1 = new \DateTime('2019-01-01');
  312.         $fecha2 = new \DateTime();
  313.         if($request ->query ->get('fechaIni')!=null && $request ->query ->get('fechaIni')!=""){
  314.             $fecha1 = new \DateTime($request ->query ->get('fechaIni'));
  315.         }
  316.         if($request ->query ->get('fechaFin')!=null && $request ->query ->get('fechaFin')!=""){
  317.             $fecha2 = new \DateTime($request ->query ->get('fechaFin'));
  318.         }
  320.         //dd($usr->getCuenta());
  321.         try{
  322.             $data=$this->serviceHistorico->findEstadisticas($usr->getId(),$fecha1, $fecha2);
  323.         }catch (\Exception $e){
  324.             dd($e);
  325.         }
  327.         //dd($data);
  330.         if($data) {
  331.             $response = new Response($serializer->serialize($data,'json'), Response::HTTP_OK);
  332.         }else{
  333.             $response = new Response("KO",Response::HTTP_NO_CONTENT);
  334.         }
  335.         $response->headers->set('Content-Type', 'json');
  336.         return $response;
  338.     }
  341.     /**
  342.      * @Rest\Get("api/admin/obtenerEstadisticas", name="obtener_estadisticas" )
  343.      * @Rest\Get("extra/admin/obtenerEstadisticas", name="obtener_estadisticas1" )
  344.      * @return  Historico [obj] objeto de los datos del historico
  345.      */
  346.     public function obtenerEstadisticasHistoricos(Request $request){
  347.         $serializer = SerializerBuilder::create()->setPropertyNamingStrategy(
  348.             new \JMS\Serializer\Naming\SerializedNameAnnotationStrategy(
  349.                 new \JMS\Serializer\Naming\IdenticalPropertyNamingStrategy()
  350.             )
  351.         )->build();        $id=1;
  352.         if($request ->query ->get('idCuenta')!=null && $request ->query ->get('idCuenta')!="" && $request ->query ->get('idCuenta')!="null"){
  353.             $id =    $request ->query ->get('idCuenta');
  354.         }
  355.         $cuenta = $this->serviceUsuario->findCuentabyId($id);
  356.         $fecha1 = new \DateTime('2018-12-10');
  357.         $fecha2 = new \DateTime('2018-12-31');
  358.         if($request ->query ->get('tipo')!=null && $request ->query ->get('tipo')!="" ){
  359.             $tipo =    $request ->query ->get('tipo');
  360.             $fecha2 = new \DateTime();
  361.             switch ($tipo){
  362.                 case "1":
  363.                     //$fecha1 = new \DateTime(date('Y-m-d', strtotime(date_format(new \DateTime(), 'Y-m-d H:i:s')) - 86400));
  364.                     $fecha1 = new \DateTime(date('Y-m-d', strtotime("-2 day")));
  365.                 break;
  366.                 case "2":
  367.                     //$fecha1 = new \DateTime(date('Y-m-d', strtotime(date_format(new \DateTime(), 'Y-m-d H:i:s')) - (7*86400)));
  368.                     $fecha1 = new \DateTime(date('Y-m-d', strtotime("-7 day")));
  369.                     break;
  370.                 case "3":
  371.                     //$fecha1 = new \DateTime(date('Y-m-d', strtotime(date_format(new \DateTime(), 'Y-m-d H:i:s')) - (30*86400)));
  372.                     $fecha1 = new \DateTime(date('Y-m-d', strtotime("-30 day")));
  373.                     break;
  374.                 case "4":
  376.                     if( (new \DateTime(date('Y-m-d', strtotime("-1 year")))) > $cuenta->getFechaCreacion()){
  377.                         $fecha1 = new \DateTime(date('Y-m-d', strtotime("-1 year")));
  378.                     }else{
  379.                         $fecha1 = $cuenta->getFechaCreacion();
  380.                     }
  381.                     break;
  382.                 default:
  383.                     $fecha1 = new \DateTime(date('Y-m-d', strtotime("-1 year")));
  384.                     break;
  385.             }
  386.         }
  390.         //$data=$this->serviceHistorico->findEstadisticas($id,$tipo)->getEstadistica();
  391.         //dd($id);
  392.         $data=$this->serviceHistorico->findEstadisticas($id,$fecha1, $fecha2);
  393.         //dd($data);
  395.         if($data) {
  396.             //dd($data);
  397.             $response = new Response($serializer->serialize($data,'json'), Response::HTTP_OK);
  398.         }else{
  399.             $response = new Response("",Response::HTTP_NO_CONTENT);
  400.         }
  401.         $response->headers->set('Content-Type', 'json');
  402.         return $response;
  404.     }
  408.     /**
  409.      * @Rest\Get("extra/generarEstadistcas", name="genera_estadisticas" )
  410.      * @return  void
  411.      */
  412.     public function generaEstadisticaEstadisticasHistoricos(Request $request){
  413.         $serializer = $this->serializer;
  415.         $fechaLog="estadistica".date_format(new \DateTime(), 'Ymd_His');;
  416.         $log = new Logger($fechaLog);
  417.         $log->pushHandler(new StreamHandler($fechaLog, Logger::WARNING));
  419.         if($request ->query ->get('key')!=null && $request ->query ->get('key')!=""){
  420.             if($request ->query ->get('key')
  421.                 == 'yBBTbaHO17cvhle98GCEXIsideCLNIAcGY7LwmQcHBzseLWKiEj88je2a0Sr0iC0dapZRBk3i4pqaYc931RZUApntdJK1v1fn4umOXws1iEAH5IhTSnEmu1Ua950eyXY3LC2Ue5u8NtqLF159QonJkwovpT5e8wNdABXEQZBLpJ10c6q89RUgODBs5LsKHhwhbcR8kmFC0PblbC8kpKQrSq154mnHFqHtKrsKMO1TeUpGfZI4FdRElwTIR3ZO6h5'
  422.             ){
  423.                 $elemento= $this->serviceHistorico->generarEstadisticas();
  424.                 $log->warning(json_encode($elemento));
  425.                 $response =  new Response(Response::HTTP_OK);
  426.                 return $response;
  427.             }else{
  428.                 $response =  new Response(Response::HTTP_BAD_REQUEST);
  429.                 return $response;
  430.             }
  432.         }else{
  433.             $response =  new Response(Response::HTTP_BAD_REQUEST);
  434.             return $response;
  435.         }
  437.     }
  444. }