src/Controller/Api/SensorController.php line 225

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api;
  5. // use OpenApi\Annotations as OA;
  6. use App\Entity\Gpio;
  7. use App\Entity\Sensor;
  8. use App\Entity\SmsLog;
  9. use App\Entity\Trade;
  10. use App\Repository\SmsLogRepository;
  11. use App\Service\ObserverDeployManifest;
  12. use App\Service\SensorRemoteService;
  13. use App\Service\SmsLogger;
  14. use App\Service\WhereEverSmsService;
  15. use FOS\RestBundle\Controller\AbstractFOSRestController;
  16. use FOS\RestBundle\Controller\Annotations as Rest;
  17. use Psr\Log\LoggerInterface;
  18. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
  19. use OpenApi\Annotations as OA;
  20. use Symfony\Component\HttpClient\HttpClient;
  21. use Symfony\Component\HttpFoundation\JsonResponse;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Component\HttpFoundation\Response;
  24. use Symfony\Component\HttpKernel\KernelInterface;
  25. use Symfony\Component\Mercure\HubInterface;
  26. use Symfony\Component\Mercure\Update;
  27. use Symfony\Component\Serializer\Encoder\JsonEncoder;
  28. use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
  29. use Symfony\Component\Serializer\Serializer;
  31. class SensorController extends AbstractFOSRestController
  32. {
  33.     protected $logger;
  34.     protected $serializer;
  35.     private $appKernel;
  36.     private $sensorRemoteService;
  37.     private HubInterface $hub;
  39.     public function __construct(LoggerInterface $logger, KernelInterface $appKernel, SensorRemoteService $sensorRemoteService, HubInterface $hub)
  40.     {
  41.         $encoders = [new JsonEncoder()];
  42.         $normalizers = [new ObjectNormalizer()];
  43.         $this->logger = $logger;
  44.         $this->appKernel = $appKernel;
  46.         $this->serializer = new Serializer($normalizers, $encoders);
  47.         $this->sensorRemoteService = $sensorRemoteService;
  48.         $this->hub = $hub;
  49.     }
  51.     public function index(LoggerInterface $logger)
  52.     {
  53.         return $this->render('api/index.html.twig', [
  54.             'controller_name' => 'ApiController',
  55.         ]);
  56.     }
  58.     /**
  59.      * @Route("/sensor/register", name="sensor_register", methods={"POST"})
  60.      *
  61.      * @OA\Post(
  62.      *     summary="Register new sensor",
  63.      *
  64.      *
  65.      *     @OA\Parameter(
  66.      *         name="body",
  67.      *         description="Post data.",
  68.      *         in="body",
  69.      *         required=true,
  70.      *
  71.      *         @OA\Schema(
  72.      *             type="string",
  73.      *             required={"serial", "createdAt"},
  74.      *
  75.      *             @OA\Property(
  76.      *                 property="serial",
  77.      *                 type="string",
  78.      *                 minLength=1,
  79.      *                 example="10000000b230f68d"
  80.      *             ),
  81.      *             @OA\Property(
  82.      *                 property="createdAt",
  83.      *                 type="datetime",
  84.      *                 minLength=1,
  85.      *                 example="2020-05-10 12:13:01"
  86.      *             )
  87.      *         )
  88.      *     ),
  89.      *
  90.      *     @OA\Response(
  91.      *         response=200,
  92.      *         description="Returns status 200 and the modified contact.",
  93.      *
  94.      *         @OA\Schema(
  95.      *             type="object",
  96.      *             properties={
  97.      *
  98.      *                 @OA\Property(property="id", type="integer"),
  99.      *             }
  100.      *         )
  101.      *     ),
  102.      *
  103.      *     @OA\Response(
  104.      *         response=404,
  105.      *         description="Returns status 404 if there is no contact with the given id."
  106.      *     )
  107.      * )
  108.      *
  109.      * @return View
  110.      */
  111.     public function register(Request $request)
  112.     {
  113.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  114.         $em = $this->getDoctrine()->getManager();
  116.         $parameters = json_decode($request->getContent(), true);
  117.         $serial = $parameters['serial'];
  118.         $createdDate = $parameters['createdAt'];
  119.         $trade = $this->getDoctrine()->getRepository(Trade::class)->find($parameters['tradeId']);
  121.         if ($sensor = $repository->findOneBySerial($serial)) {
  122.             // check if sensor has already a port
  123.             if (!$sensor->getPort()) {
  124.                 $port = $repository->getNextFreePort($trade);
  125.                 $sensor->setPort($port);
  126.                 $em->persist($sensor);
  127.                 $em->flush();
  129.                 //  sensor is already but has a new port so we need to give an state ok back
  130.                 $objContent = [
  131.                     'id' => $sensor->getId(),
  132.                     'serial' => $sensor->getSerial(),
  133.                     'createdAt' => $sensor->getCreatedAt()->format('Y-m-d H:i:s'),
  134.                     'port' => $sensor->getPort(),
  135.                 ];
  136.                 $jsonContent = $this->serializer->serialize($objContent, 'json');
  138.                 $response = new Response($jsonContent);
  139.                 $response->headers->set('Content-Type', 'application/json');
  140.                 $response->setStatusCode(Response::HTTP_CREATED);
  142.                 return $response;
  143.             }
  144.             //  sensor is already registered
  145.             $objContent = [
  146.                 'id' => $sensor->getId(),
  147.                 'serial' => $sensor->getSerial(),
  148.                 'createdAt' => $sensor->getCreatedAt()->format('Y-m-d H:i:s'),
  149.                 'port' => $sensor->getPort(),
  150.             ];
  151.             $jsonContent = $this->serializer->serialize($objContent, 'json');
  153.             $response = new Response($jsonContent);
  154.             // / $response = new Response();
  155.             $response->headers->set('Content-Type', 'application/json');
  156.             $response->setStatusCode(Response::HTTP_CONFLICT);
  157.             // $response->setStatusCode(Response::HTTP_INTERNAL_SERVER_ERROR);
  159.             return $response;
  160.         }
  161.         $sensor = new Sensor();
  162.         $sensor->setSerial($serial);
  163.         $sensor->setCreatedAt(new \DateTime());
  164.         $sensor->setLastOnline(new \DateTime());
  165.         $sensor->setTrade($trade);
  166.         $sensor->setObserverState(false);
  167.         $sensor->setInstalled(0);
  168.         $sensor->setState(Sensor::STATE_ONLINE);
  170.         $port = $repository->getNextFreePort($trade);
  171.         $sensor->setPort($port);
  172.         $em->persist($sensor);
  173.         $em->flush();
  175.         $objContent = [
  176.             'id' => $sensor->getId(),
  177.             'serial' => $sensor->getSerial(),
  178.             'createdAt' => $sensor->getCreatedAt()->format('Y-m-d H:i:s'),
  179.             'port' => $sensor->getPort(),
  180.         ];
  181.         $jsonContent = $this->serializer->serialize($objContent, 'json');
  183.         $response = new Response($jsonContent);
  184.         $response->headers->set('Content-Type', 'application/json');
  185.         $response->setStatusCode(Response::HTTP_CREATED);
  187.         return $response;
  188.     }
  190.     /**
  191.      * @Route("/sensor/lastOnline", name="sensor_lastonline", methods={"PUT"})
  192.      *
  193.      * @OA\Post(
  194.      *     summary="Set last online datetime for sensor.",
  195.      *
  196.      *
  197.      *     @OA\Parameter(
  198.      *         name="body",
  199.      *         description="Post data.",
  200.      *         in="body",
  201.      *         required=true,
  202.      *
  203.      *         @OA\Schema(type="string")
  204.      *     ),
  205.      *
  206.      *     @OA\Response(
  207.      *         response=200,
  208.      *         description="Returns status 200 and the modified contact.",
  209.      *
  210.      *         @OA\Schema(
  211.      *             type="object",
  212.      *             properties={
  213.      *
  214.      *                 @OA\Property(property="id", type="integer"),
  215.      *             }
  216.      *         )
  217.      *     ),
  218.      *
  219.      *     @OA\Response(
  220.      *         response=404,
  221.      *         description="Returns status 404 if there is no contact with the given id."
  222.      *     )
  223.      * )
  224.      */
  225.     public function lastOnlineAction(Request $request): JsonResponse
  226.     {
  227.         $responseArray = ['ok' => 'ok'];
  229.         // return new JsonResponse($responseArray);
  230.         $requestBody = $request->getContent();
  231.         $data = json_decode($requestBody);
  232.         $em = $this->getDoctrine()->getManager();
  233.         $sensor = $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial]);
  234.         if ($sensor) {
  235.             // $this->logger->error('SensorController API: lastOnlineAction: '.$sensor->getId());
  236.             $lastOnlineDateTime = new \DateTime();
  237.             $sensor->setLastOnline($lastOnlineDateTime);
  238.             $sensor->setState(1);
  239.             $em->persist($sensor);
  240.             $em->flush();
  242.             $command = $sensor->getPendingCommand();
  243.             if ($command) {
  244.                 $sensor->setPendingCommand(null);
  245.                 $em->flush();
  246.             }
  248.             $responseArray = ['ok' => 'ok', 'command' => $command];
  249.         } else {
  250.             // $this->logger->error('SensorController API: lastOnlineAction: ERROR: '.$data->serial);
  251.             $responseArray = ['error' => 'Sensor '.$data->serial.' not found'];
  252.         }
  254.         return new JsonResponse($responseArray);
  255.     }
  257.     /**
  258.      * @Route("/sensor/keepAlive", name="sensor_keep_alive", methods={"GET"})
  259.      *
  260.      * KeepAlive-Ping vom Sensor alle 5 Minuten.
  261.      * Aufruf: GET /sensor/keepAlive?serial=SENSOR_SERIAL
  262.      *
  263.      * Ergänzt lastOnlineAction (PUT + JSON-Body): NB-IoT-Sensoren unterstützen
  264.      * je nach Firmware-Stand keinen HTTP-PUT mit JSON-Body. Ein einfacher GET-Request
  265.      * mit Query-Parameter ist auf allen Modulen (z.B. SIM7000, BC66) per AT-Befehl
  266.      * ohne weitere Konfiguration realisierbar.
  267.      */
  268.     public function keepAliveAction(Request $request): JsonResponse
  269.     {
  270.         $serial = $request->query->get('serial');
  272.         if (!$serial) {
  273.             return new JsonResponse(['error' => 'serial fehlt'], Response::HTTP_BAD_REQUEST);
  274.         }
  276.         $em     = $this->getDoctrine()->getManager();
  277.         $sensor = $em->getRepository(Sensor::class)->findOneBy(['serial' => $serial]);
  279.         if (!$sensor) {
  280.             return new JsonResponse(['error' => 'Sensor nicht gefunden: '.$serial], Response::HTTP_NOT_FOUND);
  281.         }
  283.         $now = new \DateTime();
  284.         $sensor->setLastOnline($now);
  285.         $sensor->setState(1);
  286.         $em->flush();
  288.         $this->logger->info('KeepAlive: Sensor '.$serial.' ('.$sensor->getId().')', [
  289.             'sensor_id' => $sensor->getId(),
  290.             'ts'        => $now->format('Y-m-d H:i:s'),
  291.         ]);
  293.         try {
  294.             $this->hub->publish(new Update(
  295.                 'https://acobesmart.com/mqtt_monitor',
  296.                 json_encode([
  297.                     'type'          => 'heartbeat',
  298.                     'source'        => 'http',
  299.                     'sensor_serial' => $serial,
  300.                     'sensor_id'     => $sensor->getId(),
  301.                     'time'          => $now->format('H:i:s'),
  302.                 ], JSON_THROW_ON_ERROR)
  303.             ));
  304.         } catch (\Throwable $e) {
  305.             // Mercure nicht erreichbar — Request läuft weiter
  306.         }
  308.         return new JsonResponse(['ok' => 'ok', 'ts' => $now->format('Y-m-d H:i:s')]);
  309.     }
  311.     /**
  312.      * @Route("/sensor/observerLastOnline", name="observer_lastonline", methods={"PUT"})
  313.      *
  314.      * @OA\Put(
  315.      *     summary="Set last online datetime for sensor.",
  316.      *
  317.      *
  318.      *     @OA\Parameter(
  319.      *         name="body",
  320.      *         description="Post data.",
  321.      *         in="body",
  322.      *         required=true,
  323.      *
  324.      *         @OA\Schema(
  325.      *             type="string",
  326.      *             required={"sensorId"},
  327.      *
  328.      *             @OA\Property(
  329.      *                 property="sensorId",
  330.      *                 type="string",
  331.      *                 minLength=1,
  332.      *                 example=1
  333.      *             ),
  334.      *         )
  335.      *     ),
  336.      *
  337.      *     @OA\Response(
  338.      *         response=200,
  339.      *         description="Returns status 200 and the modified contact.",
  340.      *
  341.      *         @OA\Schema(
  342.      *             type="object",
  343.      *             properties={
  344.      *
  345.      *                 @OA\Property(property="id", type="integer"),
  346.      *             }
  347.      *         )
  348.      *     ),
  349.      *
  350.      *     @OA\Response(
  351.      *         response=404,
  352.      *         description="Returns status 404 if there is no contact with the given id."
  353.      *     )
  354.      * )
  355.      */
  356.     public function observerLastOnlineAction(Request $request): JsonResponse
  357.     {
  358.         $requestBody = $request->getContent();
  359.         $data = json_decode($requestBody);
  360.         $em = $this->getDoctrine()->getManager();
  361.         $sensor = false;
  362.         if ($data->sensorId) {
  363.             $sensor = $em->getRepository(Sensor::class)->find($data->sensorId);
  364.         }
  365.         if ($sensor) {
  366.             $lastOnlineDate = new \DateTime();
  367.             $sensor->setObserverLastOnline($lastOnlineDate);
  368.             // $sensor->setObserverState(1);
  369.             $em->persist($sensor);
  370.             $em->flush();
  371.             $responseArray = ['status' => 'ok'];
  372.         } else {
  373.             $responseArray = ['error' => 'Sensor '.$data->sensorId.' not found'];
  374.         }
  376.         return new JsonResponse($responseArray);
  377.     }
  379.     /**
  380.      * @Route("/sensor/getGpios", name="sensor_get_gpios", methods={"GET"})
  381.      *
  382.      * @OA\Get(
  383.      *     summary="Get registered Gpios",
  384.      *
  385.      *
  386.      *     @OA\Parameter(
  387.      *         name="body",
  388.      *         description="Post data.",
  389.      *         in="body",
  390.      *         required=true,
  391.      *
  392.      *         @OA\Schema(
  393.      *             type="string",
  394.      *             required={"sensorId"},
  395.      *
  396.      *             @OA\Property(
  397.      *                 property="sensorId",
  398.      *                 type="string",
  399.      *                 minLength=1,
  400.      *                 example=1
  401.      *             ),
  402.      *         )
  403.      *     ),
  404.      *
  405.      *     @OA\Response(
  406.      *         response=200,
  407.      *         description="Returns status 200 and the modified contact.",
  408.      *
  409.      *         @OA\Schema(
  410.      *             type="object",
  411.      *             properties={
  412.      *
  413.      *                 @OA\Property(property="id", type="integer"),
  414.      *             }
  415.      *         )
  416.      *     ),
  417.      *
  418.      *     @OA\Response(
  419.      *         response=404,
  420.      *         description="Returns status 404 if there is no contact with the given id."
  421.      *     )
  422.      * )
  423.      */
  424.     public function getGpiosAction(Request $request)
  425.     {
  426.         $this->logger->debug('SensorController API: getGpiosAction');
  427.         $requestBody = $request->getContent();
  428.         $data = json_decode($requestBody);
  429.         $em = $this->getDoctrine()->getManager();
  430.         $sensor = false;
  431.         // echo "HIER: ".$data->serial; exit();
  432.         if ($data->serial) {
  433.             $sensor = $em->getRepository(Sensor::class)->findOneBySerial($data->serial);
  434.         }
  436.         $gpios = [];
  437.         $responseArray = [];
  438.         if ($sensor) {
  439.             $this->logger->debug('SensorController API: sensor found');
  440.             if (true == $sensor->getInstalled()) {
  441.                 $gpios = $sensor->getGpios();
  442.                 foreach ($gpios as $gpio) {
  443.                     if (3000 != $gpio->getNumber()) {
  444.                         $responseArray[(int) $gpio->getNumber()] = $gpio->getTypeReadable();
  445.                     }
  446.                 }
  447.             } else {
  448.                 switch ($sensor->getTrade()->getName()) {
  449.                     case 'Aufzug':
  450.                         // sensor not installed so give first all gpios back for installation
  451.                         $responseArray[Gpio::GPIO_TYPE_POWER] = 'Netz';
  452.                         $responseArray[Gpio::GPIO_TYPE_SECURITY_CIRCUIT_FRONT] = 'Sicherheitskreis vor den Türen';
  453.                         $responseArray[Gpio::GPIO_TYPE_SECURITY_CIRCUIT_BACK] = 'Sicherheitskreis nach den Türen';
  454.                         $responseArray[Gpio::GPIO_TYPE_TRIP_UP] = 'Fahrt auf';
  455.                         $responseArray[Gpio::GPIO_TYPE_TRIP_DOWN] = 'Fahrt ab';
  456.                         $responseArray[Gpio::GPIO_TYPE_SECURITY_CIRCUIT_HOISTWAY_DOOR] = 'Sicherheitskreis Schachttüren';
  457.                         // $responseArray[Gpio::GPIO_TYPE_SECURITY_CIRCUIT_HOISTWAY_DOOR] = 'Reserve';
  458.                         $responseArray[Gpio::GPIO_TYPE_FLUSHNESS] = 'Bündig';
  459.                         $responseArray[Gpio::GPIO_TYPE_CABINLIGHT] = 'Kabinenbeleuchtung';
  460.                         $responseArray[Gpio::GPIO_TYPE_COLLECTIVE_DISORDER] = 'Sammelstörung';
  461.                         $responseArray[Gpio::GPIO_TYPE_SMOKE_EXTRACTION_COLLECTIVE_DISORDER] = 'Tür 1';
  462.                         $responseArray[Gpio::GPIO_TYPE_WATERLEVEL_WARNING] = 'Wasserstandsmelder';
  463.                         $responseArray[Gpio::GPIO_TYPE_DOOR_TWO_CLOSE] = 'Tür 2';
  464.                         $responseArray[Gpio::GPIO_TYPE_DOOR_TWO_OPEN] = 'Tür 2    auf';
  466.                         break;
  468.                     case 'Nea':
  469.                         break;
  471.                     case 'Pumpen':
  472.                         $responseArray[17] = '17';
  473.                         $responseArray[4] = '4';
  474.                         $responseArray[14] = '14';
  475.                         $responseArray[15] = '15';
  476.                         $responseArray[18] = '18';
  477.                         $responseArray[23] = '23';
  478.                         $responseArray[24] = '24';
  479.                         $responseArray[25] = '25';
  480.                         $responseArray[8] = '8';
  481.                         $responseArray[7] = '7';
  482.                         $responseArray[27] = '27';
  483.                         $responseArray[22] = '22';
  484.                         $responseArray[12] = '12';
  485.                         $responseArray[16] = '16';
  486.                         // $responseArray[20] = '20';
  487.                         // $responseArray[21] = '21';
  488.                         $responseArray[26] = '26';
  489.                         $responseArray[19] = '19';
  490.                         $responseArray[13] = '13';
  491.                         $responseArray[6] = '6';
  493.                         break;
  494.                 }
  495.             }
  496.             $jsonContent = $this->serializer->serialize($responseArray, 'json');
  498.             $response = new Response($jsonContent);
  499.             $response->headers->set('Content-Type', 'application/json');
  500.             // $response->setStatusCode(Response::HTTP_CREATED);
  502.             return $response;
  503.         }
  504.         $this->logger->debug('SensorController API: sensor NOT found');
  505.         $responseArray = ['error' => 'Sensor '.$data->serial.' not found'];
  507.         return new JsonResponse($responseArray);
  508.     }
  510.     /**
  511.      * @Route("/sensor/observerVersion", name="observer_version", methods={"PUT"})
  512.      *
  513.      * @OA\Put(
  514.      *     summary="Set version of script running at sensor.",
  515.      *
  516.      *
  517.      *     @OA\Parameter(
  518.      *         name="body",
  519.      *         description="Post data.",
  520.      *         in="body",
  521.      *         required=true,
  522.      *
  523.      *         @OA\Schema(
  524.      *             type="string",
  525.      *             required={"serial", "version"},
  526.      *
  527.      *             @OA\Property(
  528.      *                 property="serial",
  529.      *                 type="string",
  530.      *                 minLength=1,
  531.      *                 example=1
  532.      *             ),
  533.      *             @OA\Property(
  534.      *                 property="version",
  535.      *                 type="string",
  536.      *                 minLength=1,
  537.      *                 example=1
  538.      *             ),
  539.      *         )
  540.      *     ),
  541.      *
  542.      *     @OA\Response(
  543.      *         response=200,
  544.      *         description="Returns status 200 and the modified contact.",
  545.      *
  546.      *         @OA\Schema(
  547.      *             type="object",
  548.      *             properties={
  549.      *
  550.      *                 @OA\Property(property="id", type="integer"),
  551.      *             }
  552.      *         )
  553.      *     ),
  554.      *
  555.      *     @OA\Response(
  556.      *         response=404,
  557.      *         description="Returns status 404 if there is no contact with the given id."
  558.      *     )
  559.      * )
  560.      */
  561.     public function observerVersionAction(Request $request): JsonResponse
  562.     {
  563.         $requestBody = $request->getContent();
  564.         $data = json_decode($requestBody);
  565.         $em = $this->getDoctrine()->getManager();
  566.         $sensorRepo = $em->getRepository(Sensor::class);
  567.         $sensor = $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial]);
  568.         // Manche Observer melden die Version mit angehängtem Zeilenumbruch aus der .version-Datei
  569.         $version = trim($data->version);
  571.         if ($sensor) {
  572.             $sensor->setObserverVersion($version);
  573.             $em->persist($sensor);
  574.             $em->flush();
  575.             $responseArray = ['status' => 'ok'];
  576.         } else {
  577.             $responseArray = ['error' => 'Sensor '.$data->serial.' not found'];
  578.         }
  580.         return new JsonResponse($responseArray);
  581.     }
  583.     /**
  584.      * @Route("/sensor/getSensorId", name="get_sensor_id", methods={"GET"})
  585.      *
  586.      * @OA\Get(
  587.      *     summary="Get internal ID of sensor",
  588.      *
  589.      *
  590.      *     @OA\Parameter(
  591.      *         name="body",
  592.      *         description="Post data.",
  593.      *         in="body",
  594.      *         required=true,
  595.      *
  596.      *         @OA\Schema(
  597.      *             type="string",
  598.      *             required={"serial"},
  599.      *
  600.      *             @OA\Property(
  601.      *                 property="serial",
  602.      *                 type="string",
  603.      *                 minLength=1,
  604.      *                 example=1
  605.      *             ),
  606.      *         )
  607.      *     ),
  608.      *
  609.      *     @OA\Response(
  610.      *         response=200,
  611.      *         description="Returns status 200 and the modified contact.",
  612.      *
  613.      *         @OA\Schema(
  614.      *             type="object",
  615.      *             properties={
  616.      *
  617.      *                 @OA\Property(property="id", type="integer"),
  618.      *             }
  619.      *         )
  620.      *     ),
  621.      *
  622.      *     @OA\Response(
  623.      *         response=404,
  624.      *         description="Returns status 404 if there is no contact with the given id."
  625.      *     )
  626.      * )
  627.      */
  628.     public function getSensorIdAction(Request $request): JsonResponse
  629.     {
  630.         $requestBody = $request->getContent();
  631.         $data = json_decode($requestBody);
  632.         $em = $this->getDoctrine()->getManager();
  633.         $sensorRepo = $em->getRepository(Sensor::class);
  634.         $sensor = $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial]);
  635.         if ($sensor) {
  636.             $responseArray = ['id' => $sensor->getId()];
  637.         } else {
  638.             $responseArray = ['error' => 'Sensor '.$data->serial.' not found'];
  639.         }
  641.         return new JsonResponse($responseArray);
  642.     }
  644.     /**
  645.      * @Route("/sensor/sendSMS/{action}/{sensor}", name="sensor_send_sms", methods={"POST"})
  646.      *
  647.      * @param mixed $action
  648.      * @param mixed $sensor
  649.      */
  650.     public function sendSMS($action, Sensor $sensor)
  651.     {
  652.         if ($sensor->getPhone()) {
  653.             $client = HttpClient::create();
  655.             switch ($action) {
  656.                 case 'test':
  657.                     $query['action'] = 'Test';
  659.                     break;
  661.                 case 'reboot':
  662.                     $query['action'] = 'Reboot';
  664.                     break;
  666.                 case 'restartObserver':
  667.                     $query['action'] = 'Restart';
  669.                     break;
  671.                 case 'reconnect':
  672.                     $query['action'] = 'Reconnect';
  674.                     break;
  675.             }
  676.             $query = ['phone' => $sensor->getPhone(), 'action' => $query['action']];
  678.             $response = $client->request('POST', 'http://acosms.duckdns.org:8878/index.php', [
  679.                 // these values are automatically encoded before including them in the URL
  680.                 'body' => $query,
  681.             ]);
  683.             if ('OK' == trim($response->getContent())) {
  684.                 $response = ['state' => 'OK', 'msg' => 'OK'];
  685.             } else {
  686.                 $response = ['state' => 'error', 'msg' => trim($response->getContent())];
  687.             }
  688.         } else {
  689.             $response = ['state' => 'error', 'msg' => 'No phone number given!'];
  690.         }
  692.         return new JsonResponse($response);
  693.     }
  695.     /** Sicherheits-Deckel gegen Massenversand im Batch. */
  696.     private const SMS_BATCH_MAX = 100;
  698.     /**
  699.      * Reboot-SMS über WhereEver/Jasper an die ICCID des Sensors (günstiger Weg als normale SMS),
  700.      * Abfrage des Zustellstatus (getSmsDetail) und Protokollierung im SMS-Log.
  701.      *
  702.      * @Route("/sensor/rebootSmsWherever/{sensor}", name="sensor_reboot_sms_wherever", methods={"POST"})
  703.      */
  704.     public function rebootSmsWherever(Sensor $sensor, WhereEverSmsService $sms, SmsLogger $smsLogger): JsonResponse
  705.     {
  706.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  708.         return new JsonResponse($this->doCommandSms($sensor, 'Reboot', $sms, $smsLogger));
  709.     }
  711.     /**
  712.      * Steuer-SMS mit frei wählbarem Kommando. Sinnvoll, weil ein Reboot nur bei flüchtigen
  713.      * Störungen hilft: Läuft der Pi noch, sind aber die Observer-Dienste gestorben oder hängt
  714.      * die Einwahl, wirken "Restart" bzw. "Reconnect" gezielter. Zulässige Werte stehen in
  715.      * WhereEverSmsService::COMMANDS; alles andere wird abgewiesen, bevor Kosten entstehen.
  716.      *
  717.      * @Route("/sensor/commandSmsWherever/{sensor}/{command}", name="sensor_command_sms_wherever", methods={"POST"})
  718.      */
  719.     public function commandSmsWherever(Sensor $sensor, string $command, WhereEverSmsService $sms, SmsLogger $smsLogger): JsonResponse
  720.     {
  721.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  723.         return new JsonResponse($this->doCommandSms($sensor, $command, $sms, $smsLogger));
  724.     }
  726.     /**
  727.      * Batch: Reboot-SMS an alle ausgewählten Sensoren (per Checkbox aus der Sensor-Liste).
  728.      *
  729.      * @Route("/sensor/rebootSmsBatch", name="sensor_reboot_sms_batch", methods={"POST"})
  730.      */
  731.     public function rebootSmsBatch(Request $request, WhereEverSmsService $sms, SmsLogger $smsLogger): JsonResponse
  732.     {
  733.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  735.         $payload = json_decode($request->getContent(), true);
  736.         $ids = \is_array($payload['ids'] ?? null) ? $payload['ids'] : [];
  737.         $ids = array_values(array_unique(array_filter(array_map('intval', $ids))));
  738.         // Ohne Angabe bleibt es beim bisherigen Verhalten (Reboot)
  739.         $command = (string) ($payload['command'] ?? 'Reboot');
  741.         if (empty($ids)) {
  742.             return new JsonResponse(['state' => 'error', 'msg' => 'Keine Sensoren ausgewählt.']);
  743.         }
  744.         if (!isset(WhereEverSmsService::COMMANDS[$command])) {
  745.             return new JsonResponse(['state' => 'error', 'msg' => 'Unbekanntes Kommando: '.$command]);
  746.         }
  747.         if (\count($ids) > self::SMS_BATCH_MAX) {
  748.             return new JsonResponse(['state' => 'error', 'msg' => 'Zu viele Sensoren ausgewählt (max. '.self::SMS_BATCH_MAX.').']);
  749.         }
  751.         $repo = $this->getDoctrine()->getRepository(Sensor::class);
  752.         $sent = 0;
  753.         $failed = 0;
  754.         $results = [];
  755.         foreach ($ids as $id) {
  756.             $sensor = $repo->find($id);
  757.             if (null === $sensor) {
  758.                 ++$failed;
  759.                 $results[] = ['id' => $id, 'ok' => false, 'error' => 'Sensor nicht gefunden'];
  761.                 continue;
  762.             }
  763.             $r = $this->doCommandSms($sensor, $command, $sms, $smsLogger);
  764.             $ok = 'OK' === $r['state'];
  765.             $ok ? ++$sent : ++$failed;
  766.             $results[] = [
  767.                 'id' => $id, 'ok' => $ok, 'status' => $r['status'] ?? null,
  768.                 'smsLogId' => $r['smsLogId'] ?? null, 'smsMessageId' => $r['smsMessageId'] ?? null,
  769.                 'error' => $ok ? null : ($r['msg'] ?? null),
  770.             ];
  771.         }
  773.         return new JsonResponse([
  774.             'state' => 'OK',
  775.             'msg' => sprintf('%d gesendet, %d fehlgeschlagen', $sent, $failed),
  776.             'sent' => $sent, 'failed' => $failed, 'results' => $results,
  777.         ]);
  778.     }
  780.     /**
  781.      * Sendet die Steuer-SMS, ermittelt den Sofort-Status und schreibt einen SMS-Log-Eintrag.
  782.      * Gemeinsame Logik von Einzel- und Batch-Versand. Das Kommando landet unverändert im
  783.      * Log (Feld messageText), damit später nachvollziehbar ist, was geschickt wurde.
  784.      *
  785.      * @return array{state: string, msg: string, smsMessageId: mixed, status: string|null, smsLogId: int|null}
  786.      */
  787.     private function doCommandSms(Sensor $sensor, string $command, WhereEverSmsService $sms, SmsLogger $smsLogger): array
  788.     {
  789.         $sentBy = $this->getUser() ? (string) $this->getUser()->getUsername() : null;
  791.         $send = $sms->sendCommand($sensor, $command);
  792.         if (!$send['ok']) {
  793.             $log = $smsLogger->log($sensor, $command, null, 'Fehler', $sentBy);
  795.             return ['state' => 'error', 'msg' => $send['error'] ?? 'Versand fehlgeschlagen', 'smsMessageId' => null, 'status' => null, 'smsLogId' => null !== $log ? $log->getId() : null];
  796.         }
  798.         $status = null;
  799.         if (null !== $send['smsMessageId']) {
  800.             $detail = $sms->getSmsDetail($send['smsMessageId']);
  801.             $status = $detail['ok'] ? $detail['status'] : null;
  802.         }
  803.         $log = $smsLogger->log($sensor, $command, null !== $send['smsMessageId'] ? (string) $send['smsMessageId'] : null, $status, $sentBy);
  805.         return [
  806.             'state' => 'OK',
  807.             'msg' => $command.'-SMS gesendet'.(null !== $status ? ' (Status: '.$status.')' : ''),
  808.             'smsMessageId' => $send['smsMessageId'],
  809.             'status' => $status,
  810.             'smsLogId' => null !== $log ? $log->getId() : null,
  811.         ];
  812.     }
  814.     /**
  815.      * Live-Nachziehen des Zustellstatus für konkrete SMS-Log-Einträge (per Log-ID) — vom Batch-Panel
  816.      * der Sensor-Liste gepollt, damit die Zustellung ohne Seitenreload erscheint. Fragt nur noch
  817.      * offene (Pending/Sent) Einträge bei Jasper nach; terminale Status kommen unverändert zurück.
  818.      *
  819.      * @Route("/sensor/smsStatusBatch", name="sensor_sms_status_batch", methods={"POST"})
  820.      */
  821.     public function smsStatusBatch(Request $request, WhereEverSmsService $sms): JsonResponse
  822.     {
  823.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  825.         $payload = json_decode($request->getContent(), true);
  826.         $logIds = \is_array($payload['logIds'] ?? null)
  827.             ? array_values(array_unique(array_filter(array_map('intval', $payload['logIds']))))
  828.             : [];
  829.         if (empty($logIds)) {
  830.             return new JsonResponse(['state' => 'OK', 'results' => []]);
  831.         }
  833.         $em = $this->getDoctrine()->getManager();
  834.         $logs = $this->getDoctrine()->getRepository(SmsLog::class)->findBy(['id' => $logIds]);
  835.         $updated = false;
  836.         $results = [];
  837.         foreach ($logs as $log) {
  838.             $status = $log->getStatus();
  839.             $open = (null === $status || \in_array($status, SmsLogRepository::OPEN_STATUSES, true));
  840.             if ($open && null !== $log->getSmsMessageId()) {
  841.                 $detail = $sms->getSmsDetail($log->getSmsMessageId());
  842.                 if ($detail['ok'] && null !== $detail['status'] && $detail['status'] !== $status) {
  843.                     $log->setStatus($detail['status']);
  844.                     $status = $detail['status'];
  845.                     $updated = true;
  846.                 }
  847.             }
  848.             $results[] = ['logId' => $log->getId(), 'status' => $status];
  849.         }
  850.         if ($updated) {
  851.             $em->flush();
  852.         }
  854.         return new JsonResponse(['state' => 'OK', 'results' => $results]);
  855.     }
  857.     /**
  858.      * Manuelles Nachziehen des Zustellstatus für die offenen SMS-Logs einer TGA (Aufzug/NEA).
  859.      *
  860.      * @Route("/sensor/smsLogRefresh/{type}/{id}", name="sms_log_refresh", methods={"POST"}, requirements={"type"="elevator|nea"})
  861.      *
  862.      * @param mixed $id
  863.      */
  864.     public function smsLogRefresh(string $type, $id, WhereEverSmsService $sms): JsonResponse
  865.     {
  866.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  868.         $em = $this->getDoctrine()->getManager();
  869.         $repo = $this->getDoctrine()->getRepository(SmsLog::class);
  870.         $since = (new \DateTime())->modify('-2 hours');
  871.         $open = 'elevator' === $type
  872.             ? $repo->findOpenForStatusRefresh(50, $since, (int) $id, null)
  873.             : $repo->findOpenForStatusRefresh(50, $since, null, (int) $id);
  875.         $updated = 0;
  876.         foreach ($open as $log) {
  877.             $detail = $sms->getSmsDetail($log->getSmsMessageId());
  878.             if ($detail['ok'] && null !== $detail['status'] && $detail['status'] !== $log->getStatus()) {
  879.                 $log->setStatus($detail['status']);
  880.                 ++$updated;
  881.             }
  882.         }
  883.         if ($updated > 0) {
  884.             $em->flush();
  885.         }
  887.         return new JsonResponse(['state' => 'OK', 'msg' => $updated.' Status aktualisiert', 'updated' => $updated]);
  888.     }
  890.     /**
  891.      * Zustellstatus einer bereits gesendeten Reboot-SMS erneut abfragen (getSmsDetail).
  892.      *
  893.      * @Route("/sensor/smsStatusWherever/{sensor}/{smsMessageId}", name="sensor_sms_status_wherever", methods={"GET"})
  894.      *
  895.      * @param mixed $smsMessageId
  896.      */
  897.     public function smsStatusWherever(Sensor $sensor, $smsMessageId, WhereEverSmsService $sms): JsonResponse
  898.     {
  899.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  901.         $detail = $sms->getSmsDetail($smsMessageId);
  902.         if (!$detail['ok']) {
  903.             return new JsonResponse(['state' => 'error', 'msg' => $detail['error'] ?? 'Statusabfrage fehlgeschlagen']);
  904.         }
  906.         return new JsonResponse(['state' => 'OK', 'msg' => 'Status: '.($detail['status'] ?? 'unbekannt'), 'status' => $detail['status']]);
  907.     }
  909.     /**
  910.      * @Route("/sensor/update", name="sensor_update", methods={"GET"})
  911.      *
  912.      * @OA\Get(
  913.      *     summary="Get new observer scripts",
  914.      *
  915.      *
  916.      *     @OA\Parameter(
  917.      *         name="body",
  918.      *         description="Get data.",
  919.      *         in="body",
  920.      *         required=true,
  921.      *
  922.      *         @OA\Schema(
  923.      *
  924.      *             @OA\Property(
  925.      *                 property="serial",
  926.      *                 type="string",
  927.      *                 minLength=1,
  928.      *                 example=1
  929.      *             ),
  930.      *             @OA\Property(
  931.      *                 property="scriptType",
  932.      *                 type="string",
  933.      *                 minLength=1,
  934.      *                 example=1
  935.      *             ),
  936.      *         )
  937.      *     ),
  938.      *
  939.      *     @OA\Response(
  940.      *         response=200,
  941.      *         description="Returns status 200 and the modified contact.",
  942.      *
  943.      *         @OA\Schema(
  944.      *             type="object",
  945.      *             properties={
  946.      *
  947.      *                 @OA\Property(property="id", type="integer"),
  948.      *             }
  949.      *         )
  950.      *     ),
  951.      *
  952.      *     @OA\Response(
  953.      *         response=404,
  954.      *         description="Returns status 404 if there is no contact with the given id."
  955.      *     )
  956.      * )
  957.      */
  958.     public function sensorUpdateAction(Request $request, ObserverDeployManifest $manifest)
  959.     {
  960.         $projectDir = $this->appKernel->getProjectDir();
  961.         $baseDir = $projectDir.'/bin/acobesmart_observer/';
  963.         $data = json_decode($request->getContent());
  964.         $scriptType = $data->scriptType ?? null;
  965.         $em = $this->getDoctrine()->getManager();
  966.         $sensor = isset($data->serial)
  967.             ? $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial])
  968.             : null;
  970.         if (!$sensor) {
  971.             return new JsonResponse(['error' => 'Sensor nicht gefunden'], 404);
  972.         }
  974.         // Manifest: treibt das Auto-Update auf dem Pi (safe_update.py).
  975.         if ('manifest' === $scriptType) {
  976.             return new JsonResponse($manifest->build());
  977.         }
  979.         // Rueckwaerts-Kompatible Aliase (alte Pi-Scripts nutzen feste scriptType-Namen).
  980.         $aliases = [
  981.             'aco_observer' => 'aco_observer.py',
  982.             'aco_db_worker' => 'aco_db_worker.py',
  983.             'do_restart' => 'do_restart.py',
  984.             'helper' => 'helper.py',
  985.             'heartbeat' => 'heartbeat.py',
  986.             'onlineCheck' => 'online_check.py',
  987.             'safe_update' => 'safe_update.py',
  988.         ];
  990.         // Sonderfall Version: nicht Teil des Deploy-Manifests (separater .version-Handshake).
  991.         if ('version' === $scriptType) {
  992.             $filePathAbs = $baseDir.'.version';
  993.         } else {
  994.             // Alias -> relativer Pfad; sonst wird scriptType direkt als relativer Pfad
  995.             // interpretiert (neue Pi-Scripts liefern den Manifest-'path').
  996.             $relPath = $aliases[$scriptType] ?? (string) $scriptType;
  997.             $filePathAbs = $manifest->resolveDeliverable($relPath);
  998.             if (null === $filePathAbs) {
  999.                 return new JsonResponse(['error' => 'Unbekannter scriptType'], 400);
  1000.             }
  1001.         }
  1003.         if (!is_file($filePathAbs)) {
  1004.             return new JsonResponse(['error' => 'Datei nicht vorhanden'], 404);
  1005.         }
  1007.         $fileContent = file_get_contents($filePathAbs);
  1009.         $response = new Response($fileContent);
  1010.         $response->headers->set('Cache-Control', 'private');
  1011.         $response->headers->set('Content-type', 'text/plain');
  1012.         $response->headers->set('Content-length', (string) strlen($fileContent));
  1014.         return $response;
  1015.     }
  1017.     /**
  1018.      * Gets a list of sensors.
  1019.      *
  1020.      * @Rest\Get("/sensorsQrPrint")
  1021.      */
  1022.     public function sensorsQrPrintAction(Request $request)
  1023.     {
  1024.         $data = [];
  1025.         $sortField = false;
  1026.         $sortOrder = false;
  1027.         $limit = 20;
  1028.         $currentPage = 1;
  1030.         $pagination = ($request->get('pagination') ? $request->get('pagination') : false);
  1031.         if ($pagination) {
  1032.             $limit = $pagination['perpage'];
  1033.             $currentPage = $pagination['page'];
  1034.         }
  1036.         $sortField = ($request->get('sort') ? $request->get('sort')['field'] : 'updatedAt');
  1037.         $sortOrder = ($request->get('sort') ? $request->get('sort')['sort'] : 'DESC');
  1038.         $query = ($request->get('query') ? $request->get('query') : []);
  1040.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1042.         // findByCompany($user, $states = false, $tankStates = false, $sensorState = false, $limitSort = [], $isInstalled = true)
  1043.         $limitSortQuery = [
  1044.             'sortField' => $sortField,
  1045.             'sortOrder' => $sortOrder,
  1046.             'filter' => $query,
  1047.             'limit' => $limit,
  1048.             'currentPage' => $currentPage,
  1049.         ];
  1050.         $serializedSensors = [];
  1052.         $senorsComplete = $repository->getUninstalled($limitSortQuery, true);
  1054.         $pages = round($senorsComplete / $limit);
  1056.         $sensors = $repository->getUninstalled($limitSortQuery, false);
  1058.         foreach ($sensors as $sensor) {
  1059.             $serializedSensors[] = $this->serializeSensors($sensor, true);
  1060.         }
  1061.         $data['data'] = $serializedSensors;
  1062.         $data['meta'] = [
  1063.             'page' => $currentPage,
  1064.             'pages' => $pages,
  1065.             'perpage' => $limit,
  1066.             'total' => $senorsComplete,
  1067.             'sort' => $sortOrder,
  1068.             'field' => $sortField,
  1069.         ];
  1070.         $response = new Response(json_encode($data), 200);
  1071.         $response->headers->set('Content-Type', 'application/json');
  1073.         return $response;
  1074.     }
  1076.     /**
  1077.      * Server-side Datenquelle für die Sensor-Liste (KTDatatable): liefert {data, meta}.
  1078.      * Spalten: id, serial, phone, sim_number, state/stateLabel, address (Aufzug/NEA).
  1079.      *
  1080.      * @Rest\Get("/sensorsList", name="api_sensors_list")
  1081.      */
  1082.     public function sensorsListAction(Request $request)
  1083.     {
  1084.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  1086.         $limit = 20;
  1087.         $currentPage = 1;
  1088.         $pagination = $request->get('pagination') ?: false;
  1089.         if ($pagination) {
  1090.             $limit = (int) $pagination['perpage'];
  1091.             $currentPage = (int) $pagination['page'];
  1092.         }
  1093.         $sortField = $request->get('sort') ? $request->get('sort')['field'] : 'id';
  1094.         $sortOrder = $request->get('sort') ? $request->get('sort')['sort'] : 'DESC';
  1095.         $query = $request->get('query') ?: [];
  1097.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1098.         $limitSortQuery = [
  1099.             'sortField' => $sortField,
  1100.             'sortOrder' => $sortOrder,
  1101.             'filter' => $query,
  1102.             'limit' => $limit,
  1103.             'currentPage' => $currentPage,
  1104.         ];
  1106.         $total = $repository->getFilteredForList($limitSortQuery, true);
  1107.         $pages = $limit > 0 ? (int) ceil($total / $limit) : 1;
  1108.         $sensors = $repository->getFilteredForList($limitSortQuery, false);
  1110.         // Jüngsten Reboot-SMS-Zustellstatus je angezeigtem Sensor nachladen (nur diese Seite).
  1111.         $sensorIds = array_map(function ($s) { return $s->getId(); }, $sensors);
  1112.         $latestSms = $this->getDoctrine()->getRepository(SmsLog::class)->latestBySensorIds($sensorIds);
  1114.         $rows = [];
  1115.         foreach ($sensors as $sensor) {
  1116.             $elevator = $sensor->getElevator();
  1117.             $nea = $sensor->getNea();
  1118.             $address = null;
  1119.             if (null !== $elevator && null !== $elevator->getAddress()) {
  1120.                 $address = $elevator->getAddress();
  1121.             } elseif (null !== $nea && method_exists($nea, 'getAddress') && null !== $nea->getAddress()) {
  1122.                 $address = $nea->getAddress();
  1123.             }
  1124.             $addressStr = '—';
  1125.             if (null !== $address) {
  1126.                 $addressStr = trim(trim(sprintf('%s %s, %s %s', $address->getStreet(), $address->getStreetNumber(), $address->getPlz(), $address->getLocation())), ' ,') ?: '—';
  1127.             }
  1128.             $labels = $sensor->getStateNames();
  1129.             $sms = $latestSms[$sensor->getId()] ?? null;
  1130.             $rows[] = [
  1131.                 'id' => $sensor->getId(),
  1132.                 'serial' => $sensor->getSerial(),
  1133.                 'phone' => $sensor->getPhone(),
  1134.                 'sim_number' => $sensor->getSimNumber(),
  1135.                 'state' => $sensor->getState(),
  1136.                 'stateLabel' => $labels[$sensor->getState()] ?? (string) $sensor->getState(),
  1137.                 'address' => $addressStr,
  1138.                 'elevatorId' => null !== $elevator ? $elevator->getId() : null,
  1139.                 'neaId' => null !== $nea ? $nea->getId() : null,
  1140.                 'smsStatus' => null !== $sms ? $sms['status'] : null,
  1141.                 'smsLogId' => null !== $sms ? $sms['logId'] : null,
  1142.                 'smsCommand' => null !== $sms ? $sms['command'] : null,
  1143.                 'smsAt' => (null !== $sms && !empty($sms['createdAt'])) ? date('d.m.Y H:i', strtotime((string) $sms['createdAt'])) : null,
  1144.             ];
  1145.         }
  1147.         $data = ['data' => $rows, 'meta' => [
  1148.             'page' => $currentPage, 'pages' => $pages, 'perpage' => $limit,
  1149.             'total' => $total, 'sort' => $sortOrder, 'field' => $sortField,
  1150.         ]];
  1151.         $response = new Response(json_encode($data), 200);
  1152.         $response->headers->set('Content-Type', 'application/json');
  1154.         return $response;
  1155.     }
  1157.     /**
  1158.      * Gets a list of sensors.
  1159.      *
  1160.      * @Rest\Get("/getSignalAndProvider/{tgaHash}")
  1161.      *
  1162.      * @param mixed $tgaHash
  1163.      */
  1164.     public function getSignalAndProvider(Request $request, $tgaHash)
  1165.     {
  1166.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1167.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1168.             $signal = $this->sensorRemoteService->getSignalQuality($sensor);
  1170.             $provider = $this->sensorRemoteService->getProvider($sensor);
  1171.             $response = ['signalQuality' => $this->sensorRemoteService->signalQualityToString($signal).'('.$signal.')', 'provider' => $provider, 'error' => false, 'errorMsg' => ''];
  1172.         } else {
  1173.             $response = ['signalQuality' => '', 'provider' => '', 'error' => true, 'errorMsg' => 'Sensor not found!'];
  1174.         }
  1176.         return new JsonResponse($response);
  1177.     }
  1179.     /**
  1180.      * Gets a list of sensors.
  1181.      *
  1182.      * @Rest\Get("/getSignal/{tgaHash}", name="get_signal")
  1183.      *
  1184.      * @param mixed $tgaHash
  1185.      */
  1186.     public function getSignal(Request $request, $tgaHash)
  1187.     {
  1188.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1189.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1190.             $signal = $this->sensorRemoteService->getSignalQuality($sensor);
  1191.             $response = ['signalQuality' => $this->sensorRemoteService->signalQualityToString($signal).'('.$signal.')', 'error' => false, 'errorMsg' => ''];
  1192.         } else {
  1193.             $response = ['signalQuality' => 'N/A', 'error' => true, 'errorMsg' => 'Sensor not found!'];
  1194.         }
  1196.         return new JsonResponse($response);
  1197.     }
  1199.     /**
  1200.      * Is sensor online.
  1201.      *
  1202.      * @Rest\Get("/isOnline/{tgaHash}", name="is_online")
  1203.      *
  1204.      * @param mixed $tgaHash
  1205.      */
  1206.     public function isOnline(Request $request, $tgaHash)
  1207.     {
  1208.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1209.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1210.             $isOnline = $this->sensorRemoteService->checkSSHConnection($sensor);
  1211.             // updateRunning: laeuft gerade ein Software-Update? -> InstallTool zeigt "Update laeuft"
  1212.             // statt "offline", damit der Monteur den Sensor nicht resettet. updateStatus: letzter
  1213.             // Zustand (v.a. failed_network=Empfangsprobleme), falls die Seite erst nach dem Live-
  1214.             // Event via Mercure geoeffnet/neu geladen wird.
  1215.             $response = [
  1216.                 'isOnline' => $isOnline,
  1217.                 'updateRunning' => $sensor->isUpdateRunning(),
  1218.                 'updateStatus' => $sensor->getUpdateStatus(),
  1219.                 'errorMsg' => '',
  1220.             ];
  1221.         } else {
  1222.             $response = ['isOnline' => false, 'updateRunning' => false, 'updateStatus' => null, 'errorMsg' => 'Sensor not found!'];
  1223.         }
  1225.         return new JsonResponse($response);
  1226.     }
  1228.     /**
  1229.      * Meldung der Update-Scripts (safe_update.py): "running" beim Start, "done"/"failed" am Ende.
  1230.      * Setzt sensor.update_started_at und pusht das InstallTool-Live-Topic.
  1231.      *
  1232.      * @Route("/sensor/updateStatus", name="sensor_update_status", methods={"PUT"})
  1233.      */
  1234.     public function updateStatusAction(Request $request)
  1235.     {
  1236.         $data = json_decode($request->getContent());
  1237.         $em = $this->getDoctrine()->getManager();
  1238.         $sensor = isset($data->serial)
  1239.             ? $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial])
  1240.             : null;
  1241.         if (!$sensor) {
  1242.             return new JsonResponse(['error' => 'Sensor nicht gefunden'], 404);
  1243.         }
  1245.         $status = $data->status ?? '';
  1246.         $attempt = isset($data->attempt) ? (int) $data->attempt : null;
  1247.         $maxAttempts = isset($data->max_attempts) ? (int) $data->max_attempts : null;
  1249.         // running/retry -> Update laeuft: Timer setzen/verlaengern (isUpdateRunning -> "laeuft").
  1250.         // done -> fertig, Feld raus. failed*/sonst -> Timer aus, aber Zustand bleibt persistent,
  1251.         // damit ein spaeter geoeffnetes InstallTool den Ausgang (v.a. Empfangsprobleme) noch zeigt.
  1252.         $running = in_array($status, ['running', 'retry'], true);
  1253.         $sensor->setUpdateStartedAt($running ? new \DateTime() : null);
  1254.         $sensor->setUpdateStatus('done' === $status ? null : ($status ?: null));
  1255.         $em->flush();
  1257.         try {
  1258.             $this->hub->publish(new Update(
  1259.                 'https://acobesmart.com/sensorinstall_'.$this->appKernel->getEnvironment().'_'.$sensor->getId(),
  1260.                 json_encode(['type' => 'update', 'status' => $status, 'attempt' => $attempt, 'max' => $maxAttempts])
  1261.             ));
  1262.         } catch (\Throwable $e) {
  1263.             $this->logger->error('updateStatus mercure: '.$e->getMessage());
  1264.         }
  1266.         return new JsonResponse(['ok' => 'ok']);
  1267.     }
  1269.     /**
  1270.      * Is sensor online.
  1271.      *
  1272.      * @Rest\Get("/clearSensorDatabase/{tgaHash}", name="clear_sensor_database")
  1273.      *
  1274.      * @param mixed $tgaHash
  1275.      */
  1276.     public function clearSensorDatabase(Request $request, $tgaHash)
  1277.     {
  1278.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1279.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1280.             $cleared = $this->sensorRemoteService->clearSensorDatabase($sensor);
  1281.             $this->sensorRemoteService->restartAllScripts($sensor);
  1282.             $response = ['cleared' => $cleared, 'errorMsg' => ''];
  1283.         } else {
  1284.             $response = ['cleared' => false, 'errorMsg' => 'Error on clearing sensor DB.'];
  1285.         }
  1287.         return new JsonResponse($response);
  1288.     }
  1290.     /**
  1291.      * Gets a list of sensors.
  1292.      *
  1293.      * @Rest\Get("/getProvider/{tgaHash}", name="get_provider")
  1294.      *
  1295.      * @param mixed $tgaHash
  1296.      */
  1297.     public function getProvider(Request $request, $tgaHash)
  1298.     {
  1299.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1300.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1301.             $provider = $this->sensorRemoteService->getProvider($sensor);
  1302.             $response = ['provider' => $provider, 'error' => false, 'errorMsg' => ''];
  1303.         } else {
  1304.             $response = ['provider' => 'N/A', 'error' => true, 'errorMsg' => 'Sensor not found!'];
  1305.         }
  1307.         return new JsonResponse($response);
  1308.     }
  1310.     private function serializeSensors(Sensor $sensor)
  1311.     {
  1312.         $serialized = [
  1313.             'id' => $sensor->getId(),
  1314.             'sensorId' => $sensor->getId(),
  1315.             'createdAt' => $sensor->getCreatedAt()->format('d.m.Y H:i:s'),
  1316.             'stateName' => $sensor->getStateName(),
  1317.             'typeOfState' => $sensor->getTypeOfState(),
  1318.             'lastOnline' => ($sensor->getLastOnline() ? $sensor->getLastOnline()->format('d.m.Y H:i:s') : 'N/A'),
  1319.             'observerState' => $sensor->getObserverStateName(),
  1320.             'typeOfObserverState' => $sensor->getTypeOfObserverState(),
  1321.             'observerLastOnline' => ($sensor->getObserverLastOnline() ? $sensor->getObserverLastOnline()->format('d.m.Y H:i:s') : 'N/A'),
  1322.             'observerVersion' => $sensor->getObserverVersion(),
  1323.             'serial' => $sensor->getSerial(),
  1324.             'port' => $sensor->getPort(),
  1325.         ];
  1327.         $actionArray = [];
  1328.         $actionArray['showSensorqrCode'] = $this->generateUrl('show_sensor_qr_coed', ['sensorHash' => $sensor->getTgaHash()]);
  1330.         $serialized['actions'] = $actionArray;
  1332.         return $serialized;
  1333.     }
  1334. }