src/Controller/Api/SensorController.php line 232

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/sshkey", name="sensor_ssh_key", methods={"PUT"})
  512.      *
  513.      * Nimmt den vom Pi gemeldeten oeffentlichen SSH-Schluessel entgegen (Observer >= 1.5.7,
  514.      * ensureSshKey in heartbeat.py) und speichert ihn NUR am Sensor-Datensatz - es wird
  515.      * nirgends automatisch etwas freigeschaltet (Freischaltung: app:sensor-authorize-keys
  516.      * + manuelles Anhaengen an authorized_keys). Strenge Format-Pruefung, da der Endpoint
  517.      * wie alle Sensor-Endpoints unauthentifiziert ist.
  518.      */
  519.     public function sshKeyAction(Request $request): JsonResponse
  520.     {
  521.         $data = json_decode($request->getContent());
  522.         if (null === $data || empty($data->serial) || empty($data->pubkey)) {
  523.             return new JsonResponse(['error' => 'serial and pubkey required'], Response::HTTP_BAD_REQUEST);
  524.         }
  526.         $pubkey = trim((string) $data->pubkey);
  527.         if (strlen($pubkey) > 1000
  528.             || !preg_match('/^(ssh-rsa|ssh-ed25519) AAAA[A-Za-z0-9+\/=]+( [^\s]{1,64})?$/', $pubkey)) {
  529.             return new JsonResponse(['error' => 'invalid pubkey format'], Response::HTTP_BAD_REQUEST);
  530.         }
  532.         $keyStatus = isset($data->keyStatus) ? substr(trim((string) $data->keyStatus), 0, 32) : null;
  534.         $em = $this->getDoctrine()->getManager();
  535.         $sensor = $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial]);
  536.         if (!$sensor) {
  537.             return new JsonResponse(['error' => 'Sensor not found'], Response::HTTP_NOT_FOUND);
  538.         }
  540.         $sensor->setSshPublicKey($pubkey);
  541.         $sensor->setSshKeyStatus($keyStatus);
  542.         $sensor->setSshKeyReportedAt(new \DateTime());
  543.         $em->persist($sensor);
  544.         $em->flush();
  546.         return new JsonResponse(['status' => 'ok']);
  547.     }
  549.     /**
  550.      * @Route("/sensor/observerVersion", name="observer_version", methods={"PUT"})
  551.      *
  552.      * @OA\Put(
  553.      *     summary="Set version of script running at sensor.",
  554.      *
  555.      *
  556.      *     @OA\Parameter(
  557.      *         name="body",
  558.      *         description="Post data.",
  559.      *         in="body",
  560.      *         required=true,
  561.      *
  562.      *         @OA\Schema(
  563.      *             type="string",
  564.      *             required={"serial", "version"},
  565.      *
  566.      *             @OA\Property(
  567.      *                 property="serial",
  568.      *                 type="string",
  569.      *                 minLength=1,
  570.      *                 example=1
  571.      *             ),
  572.      *             @OA\Property(
  573.      *                 property="version",
  574.      *                 type="string",
  575.      *                 minLength=1,
  576.      *                 example=1
  577.      *             ),
  578.      *         )
  579.      *     ),
  580.      *
  581.      *     @OA\Response(
  582.      *         response=200,
  583.      *         description="Returns status 200 and the modified contact.",
  584.      *
  585.      *         @OA\Schema(
  586.      *             type="object",
  587.      *             properties={
  588.      *
  589.      *                 @OA\Property(property="id", type="integer"),
  590.      *             }
  591.      *         )
  592.      *     ),
  593.      *
  594.      *     @OA\Response(
  595.      *         response=404,
  596.      *         description="Returns status 404 if there is no contact with the given id."
  597.      *     )
  598.      * )
  599.      */
  600.     public function observerVersionAction(Request $request): JsonResponse
  601.     {
  602.         $requestBody = $request->getContent();
  603.         $data = json_decode($requestBody);
  604.         $em = $this->getDoctrine()->getManager();
  605.         $sensorRepo = $em->getRepository(Sensor::class);
  606.         $sensor = $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial]);
  607.         // Manche Observer melden die Version mit angehängtem Zeilenumbruch aus der .version-Datei
  608.         $version = trim($data->version);
  610.         if ($sensor) {
  611.             $sensor->setObserverVersion($version);
  612.             $em->persist($sensor);
  613.             $em->flush();
  614.             $responseArray = ['status' => 'ok'];
  615.         } else {
  616.             $responseArray = ['error' => 'Sensor '.$data->serial.' not found'];
  617.         }
  619.         return new JsonResponse($responseArray);
  620.     }
  622.     /**
  623.      * @Route("/sensor/getSensorId", name="get_sensor_id", methods={"GET"})
  624.      *
  625.      * @OA\Get(
  626.      *     summary="Get internal ID of sensor",
  627.      *
  628.      *
  629.      *     @OA\Parameter(
  630.      *         name="body",
  631.      *         description="Post data.",
  632.      *         in="body",
  633.      *         required=true,
  634.      *
  635.      *         @OA\Schema(
  636.      *             type="string",
  637.      *             required={"serial"},
  638.      *
  639.      *             @OA\Property(
  640.      *                 property="serial",
  641.      *                 type="string",
  642.      *                 minLength=1,
  643.      *                 example=1
  644.      *             ),
  645.      *         )
  646.      *     ),
  647.      *
  648.      *     @OA\Response(
  649.      *         response=200,
  650.      *         description="Returns status 200 and the modified contact.",
  651.      *
  652.      *         @OA\Schema(
  653.      *             type="object",
  654.      *             properties={
  655.      *
  656.      *                 @OA\Property(property="id", type="integer"),
  657.      *             }
  658.      *         )
  659.      *     ),
  660.      *
  661.      *     @OA\Response(
  662.      *         response=404,
  663.      *         description="Returns status 404 if there is no contact with the given id."
  664.      *     )
  665.      * )
  666.      */
  667.     public function getSensorIdAction(Request $request): JsonResponse
  668.     {
  669.         $requestBody = $request->getContent();
  670.         $data = json_decode($requestBody);
  671.         $em = $this->getDoctrine()->getManager();
  672.         $sensorRepo = $em->getRepository(Sensor::class);
  673.         $sensor = $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial]);
  674.         if ($sensor) {
  675.             $responseArray = ['id' => $sensor->getId()];
  676.         } else {
  677.             $responseArray = ['error' => 'Sensor '.$data->serial.' not found'];
  678.         }
  680.         return new JsonResponse($responseArray);
  681.     }
  683.     /**
  684.      * @Route("/sensor/sendSMS/{action}/{sensor}", name="sensor_send_sms", methods={"POST"})
  685.      *
  686.      * @param mixed $action
  687.      * @param mixed $sensor
  688.      */
  689.     public function sendSMS($action, Sensor $sensor)
  690.     {
  691.         if ($sensor->getPhone()) {
  692.             $client = HttpClient::create();
  694.             switch ($action) {
  695.                 case 'test':
  696.                     $query['action'] = 'Test';
  698.                     break;
  700.                 case 'reboot':
  701.                     $query['action'] = 'Reboot';
  703.                     break;
  705.                 case 'restartObserver':
  706.                     $query['action'] = 'Restart';
  708.                     break;
  710.                 case 'reconnect':
  711.                     $query['action'] = 'Reconnect';
  713.                     break;
  714.             }
  715.             $query = ['phone' => $sensor->getPhone(), 'action' => $query['action']];
  717.             $response = $client->request('POST', 'http://acosms.duckdns.org:8878/index.php', [
  718.                 // these values are automatically encoded before including them in the URL
  719.                 'body' => $query,
  720.             ]);
  722.             if ('OK' == trim($response->getContent())) {
  723.                 $response = ['state' => 'OK', 'msg' => 'OK'];
  724.             } else {
  725.                 $response = ['state' => 'error', 'msg' => trim($response->getContent())];
  726.             }
  727.         } else {
  728.             $response = ['state' => 'error', 'msg' => 'No phone number given!'];
  729.         }
  731.         return new JsonResponse($response);
  732.     }
  734.     /** Sicherheits-Deckel gegen Massenversand im Batch. */
  735.     private const SMS_BATCH_MAX = 100;
  737.     /**
  738.      * Reboot-SMS über WhereEver/Jasper an die ICCID des Sensors (günstiger Weg als normale SMS),
  739.      * Abfrage des Zustellstatus (getSmsDetail) und Protokollierung im SMS-Log.
  740.      *
  741.      * @Route("/sensor/rebootSmsWherever/{sensor}", name="sensor_reboot_sms_wherever", methods={"POST"})
  742.      */
  743.     public function rebootSmsWherever(Sensor $sensor, WhereEverSmsService $sms, SmsLogger $smsLogger): JsonResponse
  744.     {
  745.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  747.         return new JsonResponse($this->doCommandSms($sensor, 'Reboot', $sms, $smsLogger));
  748.     }
  750.     /**
  751.      * Steuer-SMS mit frei wählbarem Kommando. Sinnvoll, weil ein Reboot nur bei flüchtigen
  752.      * Störungen hilft: Läuft der Pi noch, sind aber die Observer-Dienste gestorben oder hängt
  753.      * die Einwahl, wirken "Restart" bzw. "Reconnect" gezielter. Zulässige Werte stehen in
  754.      * WhereEverSmsService::COMMANDS; alles andere wird abgewiesen, bevor Kosten entstehen.
  755.      *
  756.      * @Route("/sensor/commandSmsWherever/{sensor}/{command}", name="sensor_command_sms_wherever", methods={"POST"})
  757.      */
  758.     public function commandSmsWherever(Sensor $sensor, string $command, WhereEverSmsService $sms, SmsLogger $smsLogger): JsonResponse
  759.     {
  760.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  762.         return new JsonResponse($this->doCommandSms($sensor, $command, $sms, $smsLogger));
  763.     }
  765.     /**
  766.      * Batch: Reboot-SMS an alle ausgewählten Sensoren (per Checkbox aus der Sensor-Liste).
  767.      *
  768.      * @Route("/sensor/rebootSmsBatch", name="sensor_reboot_sms_batch", methods={"POST"})
  769.      */
  770.     public function rebootSmsBatch(Request $request, WhereEverSmsService $sms, SmsLogger $smsLogger): JsonResponse
  771.     {
  772.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  774.         $payload = json_decode($request->getContent(), true);
  775.         $ids = \is_array($payload['ids'] ?? null) ? $payload['ids'] : [];
  776.         $ids = array_values(array_unique(array_filter(array_map('intval', $ids))));
  777.         // Ohne Angabe bleibt es beim bisherigen Verhalten (Reboot)
  778.         $command = (string) ($payload['command'] ?? 'Reboot');
  780.         if (empty($ids)) {
  781.             return new JsonResponse(['state' => 'error', 'msg' => 'Keine Sensoren ausgewählt.']);
  782.         }
  783.         if (!isset(WhereEverSmsService::COMMANDS[$command])) {
  784.             return new JsonResponse(['state' => 'error', 'msg' => 'Unbekanntes Kommando: '.$command]);
  785.         }
  786.         if (\count($ids) > self::SMS_BATCH_MAX) {
  787.             return new JsonResponse(['state' => 'error', 'msg' => 'Zu viele Sensoren ausgewählt (max. '.self::SMS_BATCH_MAX.').']);
  788.         }
  790.         $repo = $this->getDoctrine()->getRepository(Sensor::class);
  791.         $sent = 0;
  792.         $failed = 0;
  793.         $results = [];
  794.         foreach ($ids as $id) {
  795.             $sensor = $repo->find($id);
  796.             if (null === $sensor) {
  797.                 ++$failed;
  798.                 $results[] = ['id' => $id, 'ok' => false, 'error' => 'Sensor nicht gefunden'];
  800.                 continue;
  801.             }
  802.             $r = $this->doCommandSms($sensor, $command, $sms, $smsLogger);
  803.             $ok = 'OK' === $r['state'];
  804.             $ok ? ++$sent : ++$failed;
  805.             $results[] = [
  806.                 'id' => $id, 'ok' => $ok, 'status' => $r['status'] ?? null,
  807.                 'smsLogId' => $r['smsLogId'] ?? null, 'smsMessageId' => $r['smsMessageId'] ?? null,
  808.                 'error' => $ok ? null : ($r['msg'] ?? null),
  809.             ];
  810.         }
  812.         return new JsonResponse([
  813.             'state' => 'OK',
  814.             'msg' => sprintf('%d gesendet, %d fehlgeschlagen', $sent, $failed),
  815.             'sent' => $sent, 'failed' => $failed, 'results' => $results,
  816.         ]);
  817.     }
  819.     /**
  820.      * Sendet die Steuer-SMS, ermittelt den Sofort-Status und schreibt einen SMS-Log-Eintrag.
  821.      * Gemeinsame Logik von Einzel- und Batch-Versand. Das Kommando landet unverändert im
  822.      * Log (Feld messageText), damit später nachvollziehbar ist, was geschickt wurde.
  823.      *
  824.      * @return array{state: string, msg: string, smsMessageId: mixed, status: string|null, smsLogId: int|null}
  825.      */
  826.     private function doCommandSms(Sensor $sensor, string $command, WhereEverSmsService $sms, SmsLogger $smsLogger): array
  827.     {
  828.         $sentBy = $this->getUser() ? (string) $this->getUser()->getUsername() : null;
  830.         $send = $sms->sendCommand($sensor, $command);
  831.         if (!$send['ok']) {
  832.             $log = $smsLogger->log($sensor, $command, null, 'Fehler', $sentBy);
  834.             return ['state' => 'error', 'msg' => $send['error'] ?? 'Versand fehlgeschlagen', 'smsMessageId' => null, 'status' => null, 'smsLogId' => null !== $log ? $log->getId() : null];
  835.         }
  837.         $status = null;
  838.         if (null !== $send['smsMessageId']) {
  839.             $detail = $sms->getSmsDetail($send['smsMessageId']);
  840.             $status = $detail['ok'] ? $detail['status'] : null;
  841.         }
  842.         $log = $smsLogger->log($sensor, $command, null !== $send['smsMessageId'] ? (string) $send['smsMessageId'] : null, $status, $sentBy);
  844.         return [
  845.             'state' => 'OK',
  846.             'msg' => $command.'-SMS gesendet'.(null !== $status ? ' (Status: '.$status.')' : ''),
  847.             'smsMessageId' => $send['smsMessageId'],
  848.             'status' => $status,
  849.             'smsLogId' => null !== $log ? $log->getId() : null,
  850.         ];
  851.     }
  853.     /**
  854.      * Live-Nachziehen des Zustellstatus für konkrete SMS-Log-Einträge (per Log-ID) — vom Batch-Panel
  855.      * der Sensor-Liste gepollt, damit die Zustellung ohne Seitenreload erscheint. Fragt nur noch
  856.      * offene (Pending/Sent) Einträge bei Jasper nach; terminale Status kommen unverändert zurück.
  857.      *
  858.      * @Route("/sensor/smsStatusBatch", name="sensor_sms_status_batch", methods={"POST"})
  859.      */
  860.     public function smsStatusBatch(Request $request, WhereEverSmsService $sms): JsonResponse
  861.     {
  862.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  864.         $payload = json_decode($request->getContent(), true);
  865.         $logIds = \is_array($payload['logIds'] ?? null)
  866.             ? array_values(array_unique(array_filter(array_map('intval', $payload['logIds']))))
  867.             : [];
  868.         if (empty($logIds)) {
  869.             return new JsonResponse(['state' => 'OK', 'results' => []]);
  870.         }
  872.         $em = $this->getDoctrine()->getManager();
  873.         $logs = $this->getDoctrine()->getRepository(SmsLog::class)->findBy(['id' => $logIds]);
  874.         $updated = false;
  875.         $results = [];
  876.         foreach ($logs as $log) {
  877.             $status = $log->getStatus();
  878.             $open = (null === $status || \in_array($status, SmsLogRepository::OPEN_STATUSES, true));
  879.             if ($open && null !== $log->getSmsMessageId()) {
  880.                 $detail = $sms->getSmsDetail($log->getSmsMessageId());
  881.                 if ($detail['ok'] && null !== $detail['status'] && $detail['status'] !== $status) {
  882.                     $log->setStatus($detail['status']);
  883.                     $status = $detail['status'];
  884.                     $updated = true;
  885.                 }
  886.             }
  887.             $results[] = ['logId' => $log->getId(), 'status' => $status];
  888.         }
  889.         if ($updated) {
  890.             $em->flush();
  891.         }
  893.         return new JsonResponse(['state' => 'OK', 'results' => $results]);
  894.     }
  896.     /**
  897.      * Manuelles Nachziehen des Zustellstatus für die offenen SMS-Logs einer TGA (Aufzug/NEA).
  898.      *
  899.      * @Route("/sensor/smsLogRefresh/{type}/{id}", name="sms_log_refresh", methods={"POST"}, requirements={"type"="elevator|nea"})
  900.      *
  901.      * @param mixed $id
  902.      */
  903.     public function smsLogRefresh(string $type, $id, WhereEverSmsService $sms): JsonResponse
  904.     {
  905.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  907.         $em = $this->getDoctrine()->getManager();
  908.         $repo = $this->getDoctrine()->getRepository(SmsLog::class);
  909.         $since = (new \DateTime())->modify('-2 hours');
  910.         $open = 'elevator' === $type
  911.             ? $repo->findOpenForStatusRefresh(50, $since, (int) $id, null)
  912.             : $repo->findOpenForStatusRefresh(50, $since, null, (int) $id);
  914.         $updated = 0;
  915.         foreach ($open as $log) {
  916.             $detail = $sms->getSmsDetail($log->getSmsMessageId());
  917.             if ($detail['ok'] && null !== $detail['status'] && $detail['status'] !== $log->getStatus()) {
  918.                 $log->setStatus($detail['status']);
  919.                 ++$updated;
  920.             }
  921.         }
  922.         if ($updated > 0) {
  923.             $em->flush();
  924.         }
  926.         return new JsonResponse(['state' => 'OK', 'msg' => $updated.' Status aktualisiert', 'updated' => $updated]);
  927.     }
  929.     /**
  930.      * Zustellstatus einer bereits gesendeten Reboot-SMS erneut abfragen (getSmsDetail).
  931.      *
  932.      * @Route("/sensor/smsStatusWherever/{sensor}/{smsMessageId}", name="sensor_sms_status_wherever", methods={"GET"})
  933.      *
  934.      * @param mixed $smsMessageId
  935.      */
  936.     public function smsStatusWherever(Sensor $sensor, $smsMessageId, WhereEverSmsService $sms): JsonResponse
  937.     {
  938.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  940.         $detail = $sms->getSmsDetail($smsMessageId);
  941.         if (!$detail['ok']) {
  942.             return new JsonResponse(['state' => 'error', 'msg' => $detail['error'] ?? 'Statusabfrage fehlgeschlagen']);
  943.         }
  945.         return new JsonResponse(['state' => 'OK', 'msg' => 'Status: '.($detail['status'] ?? 'unbekannt'), 'status' => $detail['status']]);
  946.     }
  948.     /**
  949.      * @Route("/sensor/update", name="sensor_update", methods={"GET"})
  950.      *
  951.      * @OA\Get(
  952.      *     summary="Get new observer scripts",
  953.      *
  954.      *
  955.      *     @OA\Parameter(
  956.      *         name="body",
  957.      *         description="Get data.",
  958.      *         in="body",
  959.      *         required=true,
  960.      *
  961.      *         @OA\Schema(
  962.      *
  963.      *             @OA\Property(
  964.      *                 property="serial",
  965.      *                 type="string",
  966.      *                 minLength=1,
  967.      *                 example=1
  968.      *             ),
  969.      *             @OA\Property(
  970.      *                 property="scriptType",
  971.      *                 type="string",
  972.      *                 minLength=1,
  973.      *                 example=1
  974.      *             ),
  975.      *         )
  976.      *     ),
  977.      *
  978.      *     @OA\Response(
  979.      *         response=200,
  980.      *         description="Returns status 200 and the modified contact.",
  981.      *
  982.      *         @OA\Schema(
  983.      *             type="object",
  984.      *             properties={
  985.      *
  986.      *                 @OA\Property(property="id", type="integer"),
  987.      *             }
  988.      *         )
  989.      *     ),
  990.      *
  991.      *     @OA\Response(
  992.      *         response=404,
  993.      *         description="Returns status 404 if there is no contact with the given id."
  994.      *     )
  995.      * )
  996.      */
  997.     public function sensorUpdateAction(Request $request, ObserverDeployManifest $manifest)
  998.     {
  999.         $projectDir = $this->appKernel->getProjectDir();
  1000.         $baseDir = $projectDir.'/bin/acobesmart_observer/';
  1002.         $data = json_decode($request->getContent());
  1003.         $scriptType = $data->scriptType ?? null;
  1004.         $em = $this->getDoctrine()->getManager();
  1005.         $sensor = isset($data->serial)
  1006.             ? $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial])
  1007.             : null;
  1009.         if (!$sensor) {
  1010.             return new JsonResponse(['error' => 'Sensor nicht gefunden'], 404);
  1011.         }
  1013.         // Manifest: treibt das Auto-Update auf dem Pi (safe_update.py).
  1014.         if ('manifest' === $scriptType) {
  1015.             return new JsonResponse($manifest->build());
  1016.         }
  1018.         // Rueckwaerts-Kompatible Aliase (alte Pi-Scripts nutzen feste scriptType-Namen).
  1019.         $aliases = [
  1020.             'aco_observer' => 'aco_observer.py',
  1021.             'aco_db_worker' => 'aco_db_worker.py',
  1022.             'do_restart' => 'do_restart.py',
  1023.             'helper' => 'helper.py',
  1024.             'heartbeat' => 'heartbeat.py',
  1025.             'onlineCheck' => 'online_check.py',
  1026.             'safe_update' => 'safe_update.py',
  1027.         ];
  1029.         // Sonderfall Version: nicht Teil des Deploy-Manifests (separater .version-Handshake).
  1030.         if ('version' === $scriptType) {
  1031.             $filePathAbs = $baseDir.'.version';
  1032.         } else {
  1033.             // Alias -> relativer Pfad; sonst wird scriptType direkt als relativer Pfad
  1034.             // interpretiert (neue Pi-Scripts liefern den Manifest-'path').
  1035.             $relPath = $aliases[$scriptType] ?? (string) $scriptType;
  1036.             $filePathAbs = $manifest->resolveDeliverable($relPath);
  1037.             if (null === $filePathAbs) {
  1038.                 return new JsonResponse(['error' => 'Unbekannter scriptType'], 400);
  1039.             }
  1040.         }
  1042.         if (!is_file($filePathAbs)) {
  1043.             return new JsonResponse(['error' => 'Datei nicht vorhanden'], 404);
  1044.         }
  1046.         $fileContent = file_get_contents($filePathAbs);
  1048.         $response = new Response($fileContent);
  1049.         $response->headers->set('Cache-Control', 'private');
  1050.         $response->headers->set('Content-type', 'text/plain');
  1051.         $response->headers->set('Content-length', (string) strlen($fileContent));
  1053.         return $response;
  1054.     }
  1056.     /**
  1057.      * Gets a list of sensors.
  1058.      *
  1059.      * @Rest\Get("/sensorsQrPrint")
  1060.      */
  1061.     public function sensorsQrPrintAction(Request $request)
  1062.     {
  1063.         $data = [];
  1064.         $sortField = false;
  1065.         $sortOrder = false;
  1066.         $limit = 20;
  1067.         $currentPage = 1;
  1069.         $pagination = ($request->get('pagination') ? $request->get('pagination') : false);
  1070.         if ($pagination) {
  1071.             $limit = $pagination['perpage'];
  1072.             $currentPage = $pagination['page'];
  1073.         }
  1075.         $sortField = ($request->get('sort') ? $request->get('sort')['field'] : 'updatedAt');
  1076.         $sortOrder = ($request->get('sort') ? $request->get('sort')['sort'] : 'DESC');
  1077.         $query = ($request->get('query') ? $request->get('query') : []);
  1079.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1081.         // findByCompany($user, $states = false, $tankStates = false, $sensorState = false, $limitSort = [], $isInstalled = true)
  1082.         $limitSortQuery = [
  1083.             'sortField' => $sortField,
  1084.             'sortOrder' => $sortOrder,
  1085.             'filter' => $query,
  1086.             'limit' => $limit,
  1087.             'currentPage' => $currentPage,
  1088.         ];
  1089.         $serializedSensors = [];
  1091.         $senorsComplete = $repository->getUninstalled($limitSortQuery, true);
  1093.         $pages = round($senorsComplete / $limit);
  1095.         $sensors = $repository->getUninstalled($limitSortQuery, false);
  1097.         foreach ($sensors as $sensor) {
  1098.             $serializedSensors[] = $this->serializeSensors($sensor, true);
  1099.         }
  1100.         $data['data'] = $serializedSensors;
  1101.         $data['meta'] = [
  1102.             'page' => $currentPage,
  1103.             'pages' => $pages,
  1104.             'perpage' => $limit,
  1105.             'total' => $senorsComplete,
  1106.             'sort' => $sortOrder,
  1107.             'field' => $sortField,
  1108.         ];
  1109.         $response = new Response(json_encode($data), 200);
  1110.         $response->headers->set('Content-Type', 'application/json');
  1112.         return $response;
  1113.     }
  1115.     /**
  1116.      * Server-side Datenquelle für die Sensor-Liste (KTDatatable): liefert {data, meta}.
  1117.      * Spalten: id, serial, phone, sim_number, state/stateLabel, address (Aufzug/NEA).
  1118.      *
  1119.      * @Rest\Get("/sensorsList", name="api_sensors_list")
  1120.      */
  1121.     public function sensorsListAction(Request $request)
  1122.     {
  1123.         $this->denyAccessUnlessGranted('ROLE_SUPER_ADMIN');
  1125.         $limit = 20;
  1126.         $currentPage = 1;
  1127.         $pagination = $request->get('pagination') ?: false;
  1128.         if ($pagination) {
  1129.             $limit = (int) $pagination['perpage'];
  1130.             $currentPage = (int) $pagination['page'];
  1131.         }
  1132.         $sortField = $request->get('sort') ? $request->get('sort')['field'] : 'id';
  1133.         $sortOrder = $request->get('sort') ? $request->get('sort')['sort'] : 'DESC';
  1134.         $query = $request->get('query') ?: [];
  1136.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1137.         $limitSortQuery = [
  1138.             'sortField' => $sortField,
  1139.             'sortOrder' => $sortOrder,
  1140.             'filter' => $query,
  1141.             'limit' => $limit,
  1142.             'currentPage' => $currentPage,
  1143.         ];
  1145.         $total = $repository->getFilteredForList($limitSortQuery, true);
  1146.         $pages = $limit > 0 ? (int) ceil($total / $limit) : 1;
  1147.         $sensors = $repository->getFilteredForList($limitSortQuery, false);
  1149.         // Jüngsten Reboot-SMS-Zustellstatus je angezeigtem Sensor nachladen (nur diese Seite).
  1150.         $sensorIds = array_map(function ($s) { return $s->getId(); }, $sensors);
  1151.         $latestSms = $this->getDoctrine()->getRepository(SmsLog::class)->latestBySensorIds($sensorIds);
  1153.         $rows = [];
  1154.         foreach ($sensors as $sensor) {
  1155.             $elevator = $sensor->getElevator();
  1156.             $nea = $sensor->getNea();
  1157.             $address = null;
  1158.             if (null !== $elevator && null !== $elevator->getAddress()) {
  1159.                 $address = $elevator->getAddress();
  1160.             } elseif (null !== $nea && method_exists($nea, 'getAddress') && null !== $nea->getAddress()) {
  1161.                 $address = $nea->getAddress();
  1162.             }
  1163.             $addressStr = '—';
  1164.             if (null !== $address) {
  1165.                 $addressStr = trim(trim(sprintf('%s %s, %s %s', $address->getStreet(), $address->getStreetNumber(), $address->getPlz(), $address->getLocation())), ' ,') ?: '—';
  1166.             }
  1167.             $labels = $sensor->getStateNames();
  1168.             $sms = $latestSms[$sensor->getId()] ?? null;
  1169.             $rows[] = [
  1170.                 'id' => $sensor->getId(),
  1171.                 'serial' => $sensor->getSerial(),
  1172.                 'phone' => $sensor->getPhone(),
  1173.                 'sim_number' => $sensor->getSimNumber(),
  1174.                 'state' => $sensor->getState(),
  1175.                 'stateLabel' => $labels[$sensor->getState()] ?? (string) $sensor->getState(),
  1176.                 'address' => $addressStr,
  1177.                 'elevatorId' => null !== $elevator ? $elevator->getId() : null,
  1178.                 'neaId' => null !== $nea ? $nea->getId() : null,
  1179.                 'smsStatus' => null !== $sms ? $sms['status'] : null,
  1180.                 'smsLogId' => null !== $sms ? $sms['logId'] : null,
  1181.                 'smsCommand' => null !== $sms ? $sms['command'] : null,
  1182.                 'smsAt' => (null !== $sms && !empty($sms['createdAt'])) ? date('d.m.Y H:i', strtotime((string) $sms['createdAt'])) : null,
  1183.             ];
  1184.         }
  1186.         $data = ['data' => $rows, 'meta' => [
  1187.             'page' => $currentPage, 'pages' => $pages, 'perpage' => $limit,
  1188.             'total' => $total, 'sort' => $sortOrder, 'field' => $sortField,
  1189.         ]];
  1190.         $response = new Response(json_encode($data), 200);
  1191.         $response->headers->set('Content-Type', 'application/json');
  1193.         return $response;
  1194.     }
  1196.     /**
  1197.      * Gets a list of sensors.
  1198.      *
  1199.      * @Rest\Get("/getSignalAndProvider/{tgaHash}")
  1200.      *
  1201.      * @param mixed $tgaHash
  1202.      */
  1203.     public function getSignalAndProvider(Request $request, $tgaHash)
  1204.     {
  1205.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1206.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1207.             $signal = $this->sensorRemoteService->getSignalQuality($sensor);
  1209.             $provider = $this->sensorRemoteService->getProvider($sensor);
  1210.             $response = ['signalQuality' => $this->sensorRemoteService->signalQualityToString($signal).'('.$signal.')', 'provider' => $provider, 'error' => false, 'errorMsg' => ''];
  1211.         } else {
  1212.             $response = ['signalQuality' => '', 'provider' => '', 'error' => true, 'errorMsg' => 'Sensor not found!'];
  1213.         }
  1215.         return new JsonResponse($response);
  1216.     }
  1218.     /**
  1219.      * Gets a list of sensors.
  1220.      *
  1221.      * @Rest\Get("/getSignal/{tgaHash}", name="get_signal")
  1222.      *
  1223.      * @param mixed $tgaHash
  1224.      */
  1225.     public function getSignal(Request $request, $tgaHash)
  1226.     {
  1227.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1228.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1229.             $signal = $this->sensorRemoteService->getSignalQuality($sensor);
  1230.             $response = ['signalQuality' => $this->sensorRemoteService->signalQualityToString($signal).'('.$signal.')', 'error' => false, 'errorMsg' => ''];
  1231.         } else {
  1232.             $response = ['signalQuality' => 'N/A', 'error' => true, 'errorMsg' => 'Sensor not found!'];
  1233.         }
  1235.         return new JsonResponse($response);
  1236.     }
  1238.     /**
  1239.      * Is sensor online.
  1240.      *
  1241.      * @Rest\Get("/isOnline/{tgaHash}", name="is_online")
  1242.      *
  1243.      * @param mixed $tgaHash
  1244.      */
  1245.     public function isOnline(Request $request, $tgaHash)
  1246.     {
  1247.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1248.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1249.             $isOnline = $this->sensorRemoteService->checkSSHConnection($sensor);
  1250.             // updateRunning: laeuft gerade ein Software-Update? -> InstallTool zeigt "Update laeuft"
  1251.             // statt "offline", damit der Monteur den Sensor nicht resettet. updateStatus: letzter
  1252.             // Zustand (v.a. failed_network=Empfangsprobleme), falls die Seite erst nach dem Live-
  1253.             // Event via Mercure geoeffnet/neu geladen wird.
  1254.             $response = [
  1255.                 'isOnline' => $isOnline,
  1256.                 'updateRunning' => $sensor->isUpdateRunning(),
  1257.                 'updateStatus' => $sensor->getUpdateStatus(),
  1258.                 'errorMsg' => '',
  1259.             ];
  1260.         } else {
  1261.             $response = ['isOnline' => false, 'updateRunning' => false, 'updateStatus' => null, 'errorMsg' => 'Sensor not found!'];
  1262.         }
  1264.         return new JsonResponse($response);
  1265.     }
  1267.     /**
  1268.      * Meldung der Update-Scripts (safe_update.py): "running" beim Start, "done"/"failed" am Ende.
  1269.      * Setzt sensor.update_started_at und pusht das InstallTool-Live-Topic.
  1270.      *
  1271.      * @Route("/sensor/updateStatus", name="sensor_update_status", methods={"PUT"})
  1272.      */
  1273.     public function updateStatusAction(Request $request)
  1274.     {
  1275.         $data = json_decode($request->getContent());
  1276.         $em = $this->getDoctrine()->getManager();
  1277.         $sensor = isset($data->serial)
  1278.             ? $em->getRepository(Sensor::class)->findOneBy(['serial' => $data->serial])
  1279.             : null;
  1280.         if (!$sensor) {
  1281.             return new JsonResponse(['error' => 'Sensor nicht gefunden'], 404);
  1282.         }
  1284.         $status = $data->status ?? '';
  1285.         $attempt = isset($data->attempt) ? (int) $data->attempt : null;
  1286.         $maxAttempts = isset($data->max_attempts) ? (int) $data->max_attempts : null;
  1288.         // running/retry -> Update laeuft: Timer setzen/verlaengern (isUpdateRunning -> "laeuft").
  1289.         // done -> fertig, Feld raus. failed*/sonst -> Timer aus, aber Zustand bleibt persistent,
  1290.         // damit ein spaeter geoeffnetes InstallTool den Ausgang (v.a. Empfangsprobleme) noch zeigt.
  1291.         $running = in_array($status, ['running', 'retry'], true);
  1292.         $sensor->setUpdateStartedAt($running ? new \DateTime() : null);
  1293.         $sensor->setUpdateStatus('done' === $status ? null : ($status ?: null));
  1294.         $em->flush();
  1296.         try {
  1297.             $this->hub->publish(new Update(
  1298.                 'https://acobesmart.com/sensorinstall_'.$this->appKernel->getEnvironment().'_'.$sensor->getId(),
  1299.                 json_encode(['type' => 'update', 'status' => $status, 'attempt' => $attempt, 'max' => $maxAttempts])
  1300.             ));
  1301.         } catch (\Throwable $e) {
  1302.             $this->logger->error('updateStatus mercure: '.$e->getMessage());
  1303.         }
  1305.         return new JsonResponse(['ok' => 'ok']);
  1306.     }
  1308.     /**
  1309.      * Is sensor online.
  1310.      *
  1311.      * @Rest\Get("/clearSensorDatabase/{tgaHash}", name="clear_sensor_database")
  1312.      *
  1313.      * @param mixed $tgaHash
  1314.      */
  1315.     public function clearSensorDatabase(Request $request, $tgaHash)
  1316.     {
  1317.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1318.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1319.             $cleared = $this->sensorRemoteService->clearSensorDatabase($sensor);
  1320.             $this->sensorRemoteService->restartAllScripts($sensor);
  1321.             $response = ['cleared' => $cleared, 'errorMsg' => ''];
  1322.         } else {
  1323.             $response = ['cleared' => false, 'errorMsg' => 'Error on clearing sensor DB.'];
  1324.         }
  1326.         return new JsonResponse($response);
  1327.     }
  1329.     /**
  1330.      * Gets a list of sensors.
  1331.      *
  1332.      * @Rest\Get("/getProvider/{tgaHash}", name="get_provider")
  1333.      *
  1334.      * @param mixed $tgaHash
  1335.      */
  1336.     public function getProvider(Request $request, $tgaHash)
  1337.     {
  1338.         $repository = $this->getDoctrine()->getRepository(Sensor::class);
  1339.         if ($sensor = $repository->findOneByTgaHash($tgaHash)) {
  1340.             $provider = $this->sensorRemoteService->getProvider($sensor);
  1341.             $response = ['provider' => $provider, 'error' => false, 'errorMsg' => ''];
  1342.         } else {
  1343.             $response = ['provider' => 'N/A', 'error' => true, 'errorMsg' => 'Sensor not found!'];
  1344.         }
  1346.         return new JsonResponse($response);
  1347.     }
  1349.     private function serializeSensors(Sensor $sensor)
  1350.     {
  1351.         $serialized = [
  1352.             'id' => $sensor->getId(),
  1353.             'sensorId' => $sensor->getId(),
  1354.             'createdAt' => $sensor->getCreatedAt()->format('d.m.Y H:i:s'),
  1355.             'stateName' => $sensor->getStateName(),
  1356.             'typeOfState' => $sensor->getTypeOfState(),
  1357.             'lastOnline' => ($sensor->getLastOnline() ? $sensor->getLastOnline()->format('d.m.Y H:i:s') : 'N/A'),
  1358.             'observerState' => $sensor->getObserverStateName(),
  1359.             'typeOfObserverState' => $sensor->getTypeOfObserverState(),
  1360.             'observerLastOnline' => ($sensor->getObserverLastOnline() ? $sensor->getObserverLastOnline()->format('d.m.Y H:i:s') : 'N/A'),
  1361.             'observerVersion' => $sensor->getObserverVersion(),
  1362.             'serial' => $sensor->getSerial(),
  1363.             'port' => $sensor->getPort(),
  1364.         ];
  1366.         $actionArray = [];
  1367.         $actionArray['showSensorqrCode'] = $this->generateUrl('show_sensor_qr_coed', ['sensorHash' => $sensor->getTgaHash()]);
  1369.         $serialized['actions'] = $actionArray;
  1371.         return $serialized;
  1372.     }
  1373. }