src/Controller/DeviceApiController.php line 39

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use Pimcore\Controller\FrontendController;
  6. use Symfony\Component\HttpFoundation\JsonResponse;
  7. use Symfony\Component\Routing\Annotation\Route;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Contracts\Translation\TranslatorInterface;
  10. use DateTime;
  11. use App\Model\WeatherStationModel;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  13. use App\Service\NCMWeatherAPIService;
  14. use App\Service\BassicAuthService;
  15. use App\Service\MeteomaticsWeatherService;
  16. use App\Service\UserPermission;
  17. use Symfony\Component\HttpFoundation\Response;
  18. use App\Model\EwsNotificationModel;
  19. use App\Model\EwsPortalModel;
  20. use App\Model\DeviceModel;
  21. use App\Model\ReportLogModel;
  22. use Pimcore\Log\ApplicationLogger;
  23. use Symfony\Component\Templating\EngineInterface;
  24. use App\Service\EmailService;
  25. use App\Service\MeteomaticApiService;
  26. use App\Service\PublicUserPermissionService;
  27. use Lexik\Bundle\JWTAuthenticationBundle\Services\JWTTokenManagerInterface;
  28. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  29. use Knp\Component\Pager\PaginatorInterface;
  30. use App\Model\WeatherForecastCityModel;
  31. use App\Service\CustomNotificationService;
  32. use App\Service\RedisCache;
  34. /**
  35.  * User controller is responsible for handling various actions related to user management.
  36.  *
  37.  * @Route("/api/ncm/device")
  38.  */
  39. class DeviceApiController extends FrontendController
  40. {
  41.     private $weatherStationModel;
  42.     private $ewsNotificationModel;
  43.     private $deviceModel;
  44.     private $reportLogModel;
  45.     var $emailService = null;
  48.     public function __construct(
  49.         protected TranslatorInterface $translator,
  50.         private ApplicationLogger $logger,
  51.         private EngineInterface $templating,
  52.         private NCMWeatherAPIService $ncmWeatherApiService,
  53.         private MeteomaticApiService $meteomaticApiService,
  54.         private MeteomaticsWeatherService $meteomaticsWeatherService,
  55.         private BassicAuthService $bassicAuthService,
  56.         private UserPermission $userPermission,
  57.         private TokenStorageInterface $tokenStorageInterface,
  58.         private JWTTokenManagerInterface $jwtManager,
  59.         private PublicUserPermissionService $publicUserPermissionService,
  60.         private CustomNotificationService $customNotificationService,
  61.         private RedisCache $redisCache,
  62.     ) {
  63.         header('Content-Type: application/json; charset=UTF-8');
  64.         // header("Access-Control-Allow-Origin: *");
  65.         $this->ewsNotificationModel = new EwsNotificationModel();
  66.         $this->weatherStationModel = new WeatherStationModel();
  67.         $this->deviceModel = new DeviceModel();
  68.         $this->reportLogModel = new ReportLogModel();
  69.         $this->templating = $templating;
  70.         $this->emailService = new EmailService();
  71.     }
  73.     /**
  74.      * @Route("/regions", methods={"POST"})
  75.      */
  76.     public function regions(Request $request): JsonResponse
  77.     {
  78.         try {
  79.             $params = json_decode($request->getContent(), true);
  80.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  82.             // check user credentials and expiry
  83.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  84.             if ($response['success'] !== true) {
  85.                 return $this->json($response);
  86.             }
  87.             $search = (isset($params['search']) && !empty($params['search'])) ? $params['search'] : null;
  88.             $result = $this->ncmWeatherApiService->getRegions($search, isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  89.             return $this->json($result);
  90.         } catch (\Exception $ex) {
  91.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  92.         }
  93.     }
  95.     /**
  96.      * @Route("/route-query", methods={"POST"})
  97.      */
  98.     public function routeQuery(Request $request): JsonResponse
  99.     {
  100.         $params = json_decode($request->getContent(), true);
  101.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  103.         // check basic Authorization
  104.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  105.         if ($response['success'] !== true) {
  106.             return $this->json($response);
  107.         }
  109.         // validate required parms
  110.         if (
  111.             !isset($params['date']) || !isset($params['parameters']) || !isset($params['location'])
  112.         ) {
  113.             throw new \Exception('Missing required parameters');
  114.         }
  116.         $locations = $params['location'];
  117.         $parameters = $params['parameters'];
  118.         // Join the locations and parameters strings with ',' for the URL
  119.         $parameterString = $parameters;
  120.         $locationString = implode('+', $locations);
  122.         // Create a DateTime object
  123.         $date = new DateTime($params['date']);
  125.         $dateStrings = [];
  127.         // Format the DateTime object as a string and add it to the array
  128.         for ($i = 0; $i < count($locations); $i++) {
  129.             $dateStrings[] = $date->format(DateTime::ISO8601);
  130.         }
  132.         // Join the date strings with ',' for the URL
  133.         $dateString = implode(',', $dateStrings);
  135.         $response = $this->meteomaticApiService->getRouteQuery(
  136.             $dateString,
  137.             $parameterString,
  138.             $locationString
  139.         );
  141.         // For demonstration purposes, we will just return a JSON response
  142.         return $this->json($response);
  143.     }
  145.     /**
  146.      * @Route("/municipality", methods={"POST"})
  147.      */
  148.     public function getMunicipalityAction(Request $request): JsonResponse
  149.     {
  150.         try {
  151.             $params = json_decode($request->getContent(), true);
  152.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  154.             // check user credentials and expiry
  155.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  156.             if ($response['success'] !== true) {
  157.                 return $this->json($response);
  158.             }
  160.             if (!isset($params['governorate_id'])) {
  161.                 throw new \Exception('Missing required governorate id');
  162.             }
  163.             $governorateId = $params['governorate_id'];
  165.             $result = $this->ewsNotificationModel->getMunicipality($governorateId, $params['lang']);
  167.             return $this->json($result);
  168.         } catch (\Exception $ex) {
  169.             $this->logger->error($ex->getMessage());
  170.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  171.         }
  172.     }
  174.     /**
  175.      * @Route("/governorates", methods={"POST"})
  176.      */
  177.     public function getGovernorateByRegionAction(Request $request): JsonResponse
  178.     {
  179.         try {
  180.             $params = json_decode($request->getContent(), true) ?: [];
  181.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  183.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  184.             if ($response['success'] !== true) {
  185.                 return $this->json($response);
  186.             }
  188.             $cacheKey = self::deviceGovernoratesCacheKey($params);
  189.             $ttl = defined('DEVICE_GOVERNORATES_CACHE_TTL') ? DEVICE_GOVERNORATES_CACHE_TTL : 86400;
  191.             try {
  192.                 $cached = $this->redisCache->get($cacheKey);
  193.                 if (is_array($cached) && isset($cached['success']) && $cached['success'] === true && array_key_exists('data', $cached)) {
  194.                     return $this->json($cached);
  195.                 }
  196.             } catch (\Throwable $e) {
  197.             }
  199.             $result = $this->ewsNotificationModel->getGovernoratesByRegion($params);
  201.             try {
  202.                 $this->redisCache->set($cacheKey, $result, $ttl);
  203.             } catch (\Throwable $e) {
  204.             }
  206.             return $this->json($result);
  207.         } catch (\Exception $ex) {
  208.             $this->logger->error($ex->getMessage());
  209.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  210.         }
  211.     }
  213.     /**
  214.      * Redis key: region filter(s) + lang (sort order). No region / region_ids â†’ "__all__".
  215.      */
  216.     private static function deviceGovernoratesCacheKey(array $params): string
  217.     {
  218.         $lang = isset($params['lang']) ? strtolower((string) $params['lang']) : 'en';
  220.         $segments = [];
  221.         if (isset($params['region_id']) && $params['region_id'] !== '' && $params['region_id'] !== null) {
  222.             $segments[] = 'rid=' . (string) $params['region_id'];
  223.         }
  224.         if (isset($params['region_ids']) && !empty($params['region_ids'])) {
  225.             $ids = is_array($params['region_ids']) ? $params['region_ids'] : [$params['region_ids']];
  226.             $ids = array_map('strval', $ids);
  227.             sort($ids, SORT_STRING);
  228.             $segments[] = 'rids=' . implode(',', $ids);
  229.         }
  231.         $regionKey = $segments !== [] ? implode('&', $segments) : '__all__';
  233.         return 'device_governorates:v1:' . md5($regionKey . '|' . $lang);
  234.     }
  236.     /**
  237.      * @Route("/tidal-amplitude", name="tidal-amplitude", methods={"POST"})
  238.      */
  239.     public function tidalAmplitudeData(Request $request): JsonResponse
  240.     {
  242.         try {
  244.             $params = json_decode($request->getContent(), true);
  245.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  247.             // check user credentials and expiry
  248.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  249.             if ($response['success'] !== true) {
  250.                 return $this->json($response);
  251.             }
  254.             $requiredParameters = ['hour', 'parameter', 'date', 'coordinates', 'model', 'format'];
  255.             foreach ($requiredParameters as $param) {
  256.                 if (!isset($params[$param])) {
  257.                     $missingParams[] = $param;
  258.                 }
  259.             }
  260.             if (!empty($missingParams)) {
  261.                 // Throw an exception with a message that includes the missing parameters
  262.                 $parameterList = implode(", ", $missingParams);
  263.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  264.             }
  266.             $hour = $params['hour'];
  267.             $parameter = $params['parameter'];
  268.             $date = $params['date'];
  269.             $coordinates = $params['coordinates'];
  270.             $model = $params['model'];
  271.             $format = $params['format'];
  275.             $response = $this->meteomaticsWeatherService->getTidalAmplitudes(
  276.                 $hour,
  277.                 $parameter,
  278.                 $date,
  279.                 $coordinates,
  280.                 $model,
  281.                 $format
  282.             );
  284.             // You can return or process the $data as needed
  285.             // For demonstration purposes, we will just return a JSON response
  286.             return $this->json($response);
  287.         } catch (\Exception $ex) {
  288.             $this->logger->error($ex->getMessage());
  289.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  290.         }
  291.     }
  293.     /**
  294.      * @Route("/high-low-tide-times", name="high_low_tide_times", methods={"POST"})
  295.      */
  296.     public function highLowTideTimesData(Request $request): JsonResponse
  297.     {
  299.         try {
  301.             $params = json_decode($request->getContent(), true);
  302.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  304.             // check user credentials and expiry
  305.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  306.             if ($response['success'] !== true) {
  307.                 return $this->json($response);
  308.             }
  311.             $requiredParameters = ['hour', 'date', 'coordinates', 'model', 'format'];
  312.             foreach ($requiredParameters as $param) {
  313.                 if (!isset($params[$param])) {
  314.                     $missingParams[] = $param;
  315.                 }
  316.             }
  317.             if (!empty($missingParams)) {
  318.                 // Throw an exception with a message that includes the missing parameters
  319.                 $parameterList = implode(", ", $missingParams);
  320.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  321.             }
  323.             $hour = $params['hour'];
  324.             $date = $params['date'];
  325.             $coordinates = $params['coordinates'];
  326.             $model = $params['model'];
  327.             $format = $params['format'];
  331.             $response = $this->meteomaticsWeatherService->getHighLowTideTimes(
  332.                 $hour,
  333.                 $date,
  334.                 $coordinates,
  335.                 $model,
  336.                 $format
  337.             );
  339.             // You can return or process the $data as needed
  340.             // For demonstration purposes, we will just return a JSON response
  341.             return $this->json($response);
  342.         } catch (\Exception $ex) {
  343.             $this->logger->error($ex->getMessage());
  344.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  345.         }
  346.     }
  348.     /**
  349.      * @Route("/significant-wave-height", name="significant_wave_height", methods={"POST"})
  350.      */
  351.     public function significantWaveHeightData(Request $request): JsonResponse
  352.     {
  354.         try {
  356.             $params = json_decode($request->getContent(), true);
  357.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  358.             // check user credentials and expiry
  359.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  360.             if ($response['success'] !== true) {
  361.                 return $this->json($response);
  362.             }
  365.             $requiredParameters = ['hour', 'date', 'coordinates', 'format'];
  366.             foreach ($requiredParameters as $param) {
  367.                 if (!isset($params[$param])) {
  368.                     $missingParams[] = $param;
  369.                 }
  370.             }
  371.             if (!empty($missingParams)) {
  372.                 // Throw an exception with a message that includes the missing parameters
  373.                 $parameterList = implode(", ", $missingParams);
  374.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  375.             }
  377.             $hour = $params['hour'];
  378.             $date = $params['date'];
  379.             $coordinates = $params['coordinates'];
  380.             $format = $params['format'];
  384.             $response = $this->meteomaticsWeatherService->getSignificantWaveHeight(
  385.                 $hour,
  386.                 $date,
  387.                 $coordinates,
  388.                 $format
  389.             );
  391.             // You can return or process the $data as needed
  392.             // For demonstration purposes, we will just return a JSON response
  393.             return $this->json($response);
  394.         } catch (\Exception $ex) {
  395.             $this->logger->error($ex->getMessage());
  396.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  397.         }
  398.     }
  400.     /**
  401.      * @Route("/surge-amplitude", name="surge_amplitude", methods={"POST"})
  402.      */
  403.     public function surgeAmplitudeData(Request $request): JsonResponse
  404.     {
  406.         try {
  408.             $params = json_decode($request->getContent(), true);
  409.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  410.             // check user credentials and expiry
  411.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  412.             if ($response['success'] !== true) {
  413.                 return $this->json($response);
  414.             }
  417.             $requiredParameters = ['hour', 'date', 'coordinates', 'model', 'format'];
  418.             foreach ($requiredParameters as $param) {
  419.                 if (!isset($params[$param])) {
  420.                     $missingParams[] = $param;
  421.                 }
  422.             }
  423.             if (!empty($missingParams)) {
  424.                 // Throw an exception with a message that includes the missing parameters
  425.                 $parameterList = implode(", ", $missingParams);
  426.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  427.             }
  429.             $hour = $params['hour'];
  430.             $date = $params['date'];
  431.             $coordinates = $params['coordinates'];
  432.             $model = $params['model'];
  433.             $format = $params['format'];
  437.             $response = $this->meteomaticsWeatherService->getSurgeAmplitude(
  438.                 $hour,
  439.                 $date,
  440.                 $coordinates,
  441.                 $model,
  442.                 $format
  443.             );
  445.             // You can return or process the $data as needed
  446.             // For demonstration purposes, we will just return a JSON response
  447.             return $this->json($response);
  448.         } catch (\Exception $ex) {
  449.             $this->logger->error($ex->getMessage());
  450.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  451.         }
  452.     }
  454.     /**
  455.      * @Route("/fog", name="fog", methods={"POST"})
  456.      */
  457.     public function fogData(Request $request): JsonResponse
  458.     {
  460.         try {
  462.             $params = json_decode($request->getContent(), true);
  463.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  464.             // check user credentials and expiry
  465.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  466.             if ($response['success'] !== true) {
  467.                 return $this->json($response);
  468.             }
  471.             $requiredParameters = ['hour', 'date', 'coordinates', 'format'];
  472.             foreach ($requiredParameters as $param) {
  473.                 if (!isset($params[$param])) {
  474.                     $missingParams[] = $param;
  475.                 }
  476.             }
  477.             if (!empty($missingParams)) {
  478.                 // Throw an exception with a message that includes the missing parameters
  479.                 $parameterList = implode(", ", $missingParams);
  480.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  481.             }
  483.             $hour = $params['hour'];
  484.             $date = $params['date'];
  485.             $coordinates = $params['coordinates'];
  486.             $format = $params['format'];
  490.             $response = $this->meteomaticsWeatherService->getFog(
  491.                 $coordinates,
  492.                 $date
  493.             );
  495.             // You can return or process the $data as needed
  496.             // For demonstration purposes, we will just return a JSON response
  497.             return $this->json($response);
  498.         } catch (\Exception $ex) {
  499.             $this->logger->error($ex->getMessage());
  500.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  501.         }
  502.     }
  504.     /**
  505.      * @Route("/search-ews-notification",  name = "search-ews-notification", methods={"POST"})
  506.      */
  507.     public function searchEwsNotificationAction(Request $request, PaginatorInterface $paginator): JsonResponse
  508.     {
  509.         try {
  512.             // check user credentials and expiry
  513.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  514.             if ($response['success'] !== true) {
  515.                 return $this->json($response);
  516.             }
  518.             $params = json_decode($request->getContent(), true);
  520.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  523.             $lang = (isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  525.             $result = $this->ewsNotificationModel->searchEwsNotification($params, $lang, $paginator = null, $this->translator);
  526.             return $this->json($result);
  527.         } catch (\Exception $ex) {
  528.             $this->logger->error($ex->getMessage());
  529.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  530.         }
  531.     }
  533.     /**
  534.      * Proxies to NCM_EWS_API_URL so clients use this app, not ncmews.centricdxb.com directly.
  535.      * POST body is forwarded as JSON; server uses NCM_API_USERNAME / NCM_API_PASSWORD.
  536.      *
  537.      * @Route("/view-ews-notification", name="view-ews-notification", methods={"POST"})
  538.      */
  539.     public function viewEwsNotificationAction(Request $request): JsonResponse
  540.     {
  541.         try {
  542.             $authResponse = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  543.             if ($authResponse['success'] !== true) {
  544.                 return $this->json($authResponse);
  545.             }
  547.             $params = json_decode($request->getContent(), true);
  548.             if (is_array($params)) {
  549.                 $this->translator->setlocale(isset($params['lang']) ? $params['lang'] : DEFAULT_LOCALE);
  550.             }
  552.             $payload = is_array($params) ? $params : [];
  554.             $ewsPortalModel = new EwsPortalModel();
  555.             $result = $ewsPortalModel->viewEwsNotificationRemote($payload);
  557.             if (empty($result['configured'])) {
  558.                 return $this->json(['success' => false, 'message' => 'EWS upstream is not configured'], 503);
  559.             }
  561.             $statusCode = (int) ($result['statusCode'] ?? 502);
  563.             if (is_array($result['body'] ?? null)) {
  564.                 return new JsonResponse($result['body'], $statusCode);
  565.             }
  567.             $body = $result['body'] ?? null;
  568.             if ($body !== null) {
  569.                 return new JsonResponse($body, $statusCode);
  570.             }
  572.             if (!empty($result['rawBody'])) {
  573.                 return new JsonResponse(
  574.                     ['success' => false, 'message' => 'Invalid response from EWS service'],
  575.                     $statusCode > 0 ? $statusCode : 502
  576.                 );
  577.             }
  579.             return $this->json(
  580.                 ['success' => false, 'message' => $result['error'] ?? 'Upstream request failed'],
  581.                 $statusCode > 0 ? $statusCode : 502
  582.             );
  583.         } catch (\Exception $ex) {
  584.             $this->logger->error($ex->getMessage());
  586.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  587.         }
  588.     }
  590.     /**
  591.      * @Route("/translations/{locale?}", name="translations", methods={"GET"})
  592.      */
  593.     public function frontendDashboardTranslation(Request $request, $locale = null)
  594.     {
  595.         try {
  596.             $response = [];
  597.             $db = \Pimcore\Db::get();
  599.             if ($locale) {
  600.                 // Fetch translations for the provided locale
  601.                 $selectedLocalities = $db->fetchAllAssociative("
  602.                 SELECT * FROM translations_messages 
  603.                 WHERE `key` LIKE 'publicapp_%' 
  604.                 AND `language` = :locale 
  605.                 ORDER BY `creationDate` ASC
  606.             ", ['locale' => $locale]);
  608.                 foreach ($selectedLocalities as $value) {
  609.                     $keyParts = explode('_', $value['key'], 3);
  610.                     $category = $keyParts[1];
  611.                     $key = $keyParts[2];
  613.                     if (!isset($response[$category])) {
  614.                         $response[$category] = [];
  615.                     }
  617.                     $response[$category][$key] = $value['text'];
  618.                 }
  620.                 return $this->json($response);
  621.             } else {
  622.                 // Fetch translations for both 'ar' and 'en'
  623.                 $selectedLocalities = $db->fetchAllAssociative("
  624.                 SELECT * FROM translations_messages 
  625.                 WHERE `key` LIKE 'publicapp_%' 
  626.                 AND `language` IN ('ar', 'en') 
  627.                 ORDER BY `creationDate` ASC
  628.             ");
  630.                 foreach ($selectedLocalities as $value) {
  631.                     $keyParts = explode('_', $value['key'], 3);
  632.                     $category = $keyParts[1];
  633.                     $key = $keyParts[2];
  634.                     $language = $value['language'];
  636.                     if (!isset($response[$language])) {
  637.                         $response[$language] = [];
  638.                     }
  640.                     if (!isset($response[$language][$category])) {
  641.                         $response[$language][$category] = [];
  642.                     }
  644.                     $response[$language][$category][$key] = $value['text'];
  645.                 }
  647.                 return $this->json($response);
  648.             }
  649.         } catch (\Exception $ex) {
  650.             $this->logger->error($ex->getMessage());
  651.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  652.         }
  653.     }
  655.     /**
  656.      * @Route("/list-ewsnotification", methods={"POST"})
  657.      */
  658.     public function listEwsNotificationAction(Request $request, PaginatorInterface $paginator): JsonResponse
  659.     {
  660.         try {
  661.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  662.             if ($response['success'] !== true) {
  663.                 return $this->json($response);
  664.             }
  666.             $params = json_decode($request->getContent(), true);
  667.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  668.             $params['unpublished'] = false;
  669.             $params['status'] = 'active';
  670.             $result = $this->ewsNotificationModel->notificationListing($params, $paginator = null, $this->translator);
  671.             return $this->json($result);
  672.         } catch (\Exception $ex) {
  673.             $this->logger->error($ex->getMessage());
  674.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  675.         }
  676.     }
  678.     /**
  679.      * @Route("/query", methods={"POST"})
  680.      */
  681.     public function fetchMeteomaticData(Request $request): JsonResponse
  682.     {
  683.         $params = json_decode($request->getContent(), true);
  684.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  686.         // check user credentials and expiry
  687.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  688.         if ($response['success'] !== true) {
  689.             return $this->json($response);
  690.         }
  692.         if (!isset($params['format'])) {
  693.             throw new \InvalidArgumentException('Missing "format" parameter');
  694.         }
  696.         if ($params['format'] == "json") {
  697.             if (
  698.                 !isset($params['startdate']) ||
  699.                 !isset($params['enddate']) ||
  700.                 !isset($params['resolution']) ||
  701.                 !isset($params['parameters']) ||
  702.                 !isset($params['lat']) ||
  703.                 !isset($params['lon']) ||
  704.                 !isset($params['format'])
  705.             ) {
  706.                 throw new \Exception('Missing required parameters');
  707.             }
  708.             // date_default_timezone_set('UTC');
  710.             //$hour = $params['hour'];
  711.             $format = $params['format'];
  712.             $startDate = $params['startdate'];
  713.             $endDate = $params['enddate'];
  714.             $resolution = $params['resolution'];
  715.             $parameters = $params['parameters'];
  716.             $model = $params['model'];
  717.             $lat = $params['lat'];
  718.             $lon = $params['lon'];
  721.             $response = $this->meteomaticApiService->timeSeriesQuery(
  722.                 $startDate,
  723.                 $endDate,
  724.                 $resolution,
  725.                 $parameters,
  726.                 $model,
  727.                 $lat,
  728.                 $lon,
  729.                 $format,
  730.                 $this->translator
  731.             );
  732.         } else {
  733.             $mandatoryParams = ['version', 'request', 'layers', 'crs', 'bbox', 'format', 'width', 'height', 'tiled'];
  734.             foreach ($mandatoryParams as $param) {
  735.                 if (!isset($params[$param]) || empty($params[$param])) {
  736.                     $missingParams[] = $param;
  737.                 }
  738.             }
  740.             if (!empty($missingParams)) {
  741.                 // Throw an exception with a message that includes the missing parameters
  742.                 $parameterList = implode(", ", $missingParams);
  743.                 throw new \InvalidArgumentException(sprintf($this->translator->trans("missing_or_empty_mandatory_parameter: %s"), $parameterList));
  744.             }
  746.             header('Content-Type: image/png');
  747.             $result = $this->meteomaticsWeatherService->getWeatherMap($params['version'], $params['request'], $params['layers'], $params['crs'], $params['bbox'], $params['format'], $params['width'], $params['height'], $params['tiled']);
  749.             echo $result;
  750.             exit;
  751.         }
  753.         // You can return or process the $data as needed
  754.         // For demonstration purposes, we will just return a JSON response
  755.         return $this->json($response);
  756.     }
  758.     /**
  759.      * @Route("/public-query", methods={"POST"})
  760.      */
  761.     public function publicMetarQuery(Request $request): JsonResponse
  762.     {
  763.         try {
  764.             $params = json_decode($request->getContent(), true);
  765.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  767.             //check user credentials and expiry
  768.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  769.             if ($response['success'] !== true) {
  770.                 return $this->json($response);
  771.             }
  773.             if ($response['success'] !== true) {
  774.                 return $this->json($response);
  775.             }
  777.             if (
  778.                 !isset($params['startdate']) ||
  779.                 !isset($params['enddate']) ||
  780.                 !isset($params['resolution']) ||
  781.                 !isset($params['parameters']) ||
  782.                 !isset($params['coordinate']) ||
  783.                 !isset($params['format'])
  784.             ) {
  785.                 throw new \Exception('Missing required parameters');
  786.             }
  787.             // date_default_timezone_set('UTC');
  789.             //$hour = $params['hour'];
  790.             $format = $params['format'];
  791.             $startDate = $params['startdate'];
  792.             $endDate = $params['enddate'];
  793.             $resolution = $params['resolution'];
  794.             $parametersArray = $params['parameters'];
  796.             $coordinate = $params['coordinate'];
  797.             $parameters = implode(',', $parametersArray);
  799.             $model = '';
  800.             if (isset($params['model']) && !empty($params['model'])) {
  801.                 $model = $params['model'];
  802.             }
  803.             $source = '';
  804.             if (isset($params['source']) && !empty($params['source'])) {
  805.                 $source = $params['source'];
  806.             }
  807.             $onInvalid = '';
  808.             if (isset($params['on_invalid']) && !empty($params['on_invalid'])) {
  809.                 $onInvalid = $params['on_invalid'];
  810.             }
  811.             $isPolygon = $this->parseRequestBoolean($params['is_polygon'] ?? false);
  813.             $startDate = new DateTime($params['startdate']);
  814.             $endDate = new DateTime($params['enddate']);
  816.             $publicQueryCacheKey = $this->buildPublicQueryRedisCacheKey(
  817.                 $startDate,
  818.                 $endDate,
  819.                 $resolution,
  820.                 $parametersArray,
  821.                 $coordinate,
  822.                 $format,
  823.                 $model,
  824.                 $source,
  825.                 $onInvalid,
  826.                 $isPolygon
  827.             );
  828.             $publicQueryTtlSeconds = 3600;
  830.             try {
  831.                 $cachedResponse = $this->redisCache->get($publicQueryCacheKey);
  832.                 if (is_array($cachedResponse)
  833.                     && ($cachedResponse['success'] ?? false) === true
  834.                     && isset($cachedResponse['data'])) {
  835.                     return $this->json($cachedResponse);
  836.                 }
  837.             } catch (\Throwable $e) {
  838.             }
  840.             $response = $this->meteomaticApiService->publicRouteQuery(
  841.                 $startDate,
  842.                 $endDate,
  843.                 $resolution,
  844.                 $parametersArray,
  845.                 $coordinate,
  846.                 $format,
  847.                 $model,
  848.                 $source,
  849.                 $onInvalid,
  850.                 $isPolygon
  851.             );
  853.             try {
  854.                 if (is_array($response) && ($response['success'] ?? false) === true) {
  855.                     $this->redisCache->set($publicQueryCacheKey, $response, $publicQueryTtlSeconds);
  856.                 }
  857.             } catch (\Throwable $e) {
  858.             }
  860.             return $this->json($response);
  861.         } catch (\Exception $ex) {
  862.             $this->logger->error($ex->getMessage());
  863.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  864.         }
  865.     }
  867.     /**
  868.      * @Route("/get-metar-data", methods={"POST"})
  869.      */ 
  870.     public function getMetarData(Request $request): Response
  871.     {
  872.         try {
  873.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  874.             if ($response['success'] !== true) {
  875.                 return $this->json($response);
  876.             }
  878.             $params = json_decode($request->getContent(), true);
  879.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  881.             $requiredParameters = ['startDate', 'endDate', 'metar', 'duration'];
  882.             foreach ($requiredParameters as $param) {
  883.                 if (!isset($params[$param])) {
  884.                     $missingParams[] = $param;
  885.                 }
  886.             }
  887.             if (!empty($missingParams)) {
  888.                 // Throw an exception with a message that includes the missing parameters
  889.                 $parameterList = implode(", ", $missingParams);
  890.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  891.             }
  893.             $startDate = $params['startDate'];
  894.             $endDate = $params['endDate'];
  895.             $metar = $params['metar'];
  896.             $duration = $params['duration'];
  897.             $parameters = $params['parameter'] ?? null;
  898.             $genExcel = $request->get('gen_excel', false);
  899.             $metarData = $this->meteomaticsWeatherService->getMetarData($startDate, $endDate, $metar, $duration, $this->translator, $parameters, $genExcel);
  901.             return $this->json(['success' => true, 'message' => $this->translator->trans("excel_file_downloaded_successfully"), 'data' => $metarData]);
  902.         } catch (\Exception $ex) {
  903.             $this->logger->error($ex->getMessage());
  904.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  905.         }
  906.     }
  908.     /**
  909.      * @Route("/get-airport-stations", methods={"POST"})
  910.      */
  911.     public function getAirportStations(Request $request): JsonResponse
  912.     {
  913.         try {
  914.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  915.             if ($response['success'] !== true) {
  916.                 return $this->json($response);
  917.             }
  919.             $params = json_decode($request->getContent(), true);
  920.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  922.             $result = $this->ncmWeatherApiService->getAirportStations($params['ccode'] ?? null);
  924.             return $this->json(['success' => true, 'data' => $result]);
  926.         } catch (\Exception $ex) {
  927.             $this->logger->error($ex->getMessage());
  928.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  929.         }
  931.     }
  933.     /**
  934.      * @Route("/get-forecast-cities", methods={"POST"})
  935.      */
  936.     public function getForecastCities(Request $request): Response
  937.     {
  938.         try {
  939.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  940.             if ($response['success'] !== true) {
  941.                 return $this->json($response);
  942.             }
  944.             $params = json_decode($request->getContent(), true);
  945.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  947.             $forecastCityModel = new WeatherForecastCityModel();
  948.             $cities = $forecastCityModel->getWeatherForecastCities();
  950.             return $this->json(['success' => true, 'data' => $cities]);
  951.         } catch (\Exception $ex) {
  952.             $this->logger->error($ex->getMessage());
  953.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  954.         }
  955.     }
  957.     /**
  958.      * @Route("/momra-generate-token", methods={"POST"})
  959.      */
  960.     public function getMomraGenerateToken(Request $request): JsonResponse
  961.     {
  962.         try {
  963.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  964.             if ($response['success'] !== true) {
  965.                 return $this->json($response);
  966.             }
  967.             $result = $this->ncmWeatherApiService->generateMomraToken();
  968.             return $this->json($result);
  969.         } catch (\Exception $ex) {
  970.             $this->logger->error($ex->getMessage());
  971.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  972.         }
  973.     }
  975.     /**
  976.      * @Route("/list-weather-station", methods={"POST"})
  977.      */
  978.     public function listWeatherStation(Request $request, PaginatorInterface $paginator): JsonResponse
  979.     {
  980.         try {
  981.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  982.             if ($response['success'] !== true) {
  983.                 return $this->json($response);
  984.             }
  986.             $params  = json_decode($request->getContent(), true);
  987.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  988.             $search = (isset($params['search']) && !empty($params['search'])) ? $params['search'] : null;
  989.             $id = (isset($params['id']) && !empty($params['id'])) ? $params['id'] : null;
  990.             $result = $this->weatherStationModel->getWeatherStations($paginator = null, null, null, $this->translator, $search, $id);
  991.             return $this->json($result);
  992.         } catch (\Exception $ex) {
  993.             $this->logger->error($ex->getMessage());
  994.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  995.         }
  996.     }
  998.     /**
  999.      * @Route("/get-station-data", methods={"GET"})
  1000.      */
  1001.     public function getWeatherStationDataAction(Request $request)
  1002.     {
  1003.         try {
  1004.             $params = json_decode($request->getContent(), true);
  1005.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1007.             // check user credentials and expiry
  1008.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1009.             if ($response['success'] !== true) {
  1010.                 return $this->json($response);
  1011.             }
  1014.             $typeName = $request->get('type_name');
  1015.             $parameters = $request->get('parameters');
  1016.             $dateTime = $request->get('date_time');
  1017.             $bBox = $request->get('b_box');
  1020.             if (!$typeName) {
  1021.                 throw new \InvalidArgumentException("Missing mandatory parameter: type_name");
  1022.             }
  1023.             if (!$parameters) {
  1024.                 throw new \InvalidArgumentException("Missing mandatory parameter: parameters");
  1025.             }
  1026.             if (!$dateTime) {
  1027.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  1028.             }
  1029.             if (!$bBox) {
  1030.                 throw new \InvalidArgumentException("Missing mandatory parameter: b_box");
  1031.             }
  1033.             $result = $this->meteomaticsWeatherService->getWeatherStationData($typeName, $parameters, $dateTime, $bBox);
  1034.             return $result;
  1035.         } catch (\Exception $ex) {
  1036.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1037.         }
  1038.     }
  1040.     /**
  1041.      * @Route("/get-push-alert-notification", methods={"POST"})
  1042.      */
  1043.     public function getPushAlertNotification(Request $request): Response
  1044.     {
  1045.         try {
  1046.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1047.             if ($response['success'] !== true) {
  1048.                 return $this->json($response);
  1049.             }
  1051.             $params = json_decode($request->getContent(), true);
  1052.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1054.             $result  = $this->deviceModel->getPushAlertNotification($params, $this->translator);
  1056.             return $this->json(['success' => true, 'data' => $result]);
  1057.         } catch (\Exception $ex) {
  1058.             $this->logger->error($ex->getMessage());
  1059.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1060.         }
  1061.     }
  1063.     /**
  1064.      * @Route("/manned-alerts", methods={"POST"})
  1065.      */
  1066.     public function mannedAlerts(Request $request, PaginatorInterface $paginator): JsonResponse
  1067.     {
  1068.         try {
  1069.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1070.             if ($response['success'] !== true) {
  1071.                 return $this->json($response);
  1072.             }
  1074.             $params = json_decode($request->getContent(), true);
  1075.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1077.             if (!isset($params['from_date']) || !isset($params['to_date'])) {
  1078.                 // throw new \Exception('Date range is required');
  1079.                 return $this->json(['success' => false, 'message' =>  $this->translator->trans('date_range_is_required')]);
  1080.             }
  1082.             $result = $this->customNotificationService->getMannedAlerts($params, $paginator = null);
  1084.             return $this->json($result);
  1085.         } catch (\Exception $ex) {
  1086.             $this->logger->error($ex->getMessage());
  1087.             return $this->json(['success' => false, 'message' =>  $this->translator->trans(USER_ERROR_MESSAGE)]);
  1088.         }
  1089.     }
  1091.     /**
  1092.      * @Route("/get-phenomena-list", methods={"POST"})
  1093.      */
  1094.     public function getPhenomenaList(Request $request): JsonResponse
  1095.     {
  1096.         try {
  1097.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1098.             if ($response['success'] !== true) {
  1099.                 return $this->json($response);
  1100.             }
  1102.             $params = json_decode($request->getContent(), true);
  1103.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1106.             $result = $this->ewsNotificationModel->getPhenomenaList();
  1107.             return $this->json($result);
  1108.         } catch (\Exception $ex) {
  1109.             $this->logger->error($ex->getMessage());
  1110.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1111.         }
  1112.     }
  1114.     /**
  1115.      * @Route("/get-today-weather-report", methods={"POST"})
  1116.      */
  1117.     public function getTodayWeatherReport(Request $request): JsonResponse
  1118.     {
  1119.         try {
  1120.             // check user credentials and expiry
  1121.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1122.             if ($response['success'] !== true) {
  1123.                 return $this->json($response);
  1124.             }
  1126.             // get request params
  1127.             $params = json_decode($request->getContent(), true);
  1129.             // set locale
  1130.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1132.             // get today weather report data
  1133.             $result = $this->reportLogModel->getTodayWeatherReportData($request, $this->translator);
  1134.             return $this->json($result);
  1135.         } catch (\Exception $ex) {
  1136.             $this->logger->error($ex->getMessage());
  1137.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1138.         }
  1139.     }
  1141.     /**
  1142.      * @Route("/get-all-weather-report", methods={"POST"})
  1143.      */
  1144.     public function getAllWeatherReport(Request $request): JsonResponse
  1145.     {
  1146.         try {
  1147.             // check user credentials and expiry
  1148.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1149.             if ($response['success'] !== true) {
  1150.                 return $this->json($response);
  1151.             }
  1153.             // get request params
  1154.             $params = json_decode($request->getContent(), true);
  1156.             // set locale
  1157.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1159.             // get today weather report data
  1160.             $result = $this->reportLogModel->getAllWeatherReportData($request, $this->translator);
  1161.             return $this->json($result);
  1162.         } catch (\Exception $ex) {
  1163.             $this->logger->error($ex->getMessage());
  1164.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1165.         }
  1166.     }
  1168.     /**
  1169.      * @Route("/get-mobile-assets-list", methods={"POST"})
  1170.      */
  1171.     public function getMobileAssetsList(Request $request): JsonResponse
  1172.     {
  1173.         try {
  1174.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1175.             if ($response['success'] !== true) {
  1176.                 return $this->json($response);
  1177.             }
  1178.             $data = [];
  1179.             $list = new \Pimcore\Model\Asset\Listing();
  1180.             $list->setCondition("path LIKE ?", ["/mobile-assets%"]);
  1181.             $list->load();
  1182.             foreach ($list as $key => $value) {
  1183.                 if ($value->getType() == "image") {
  1184.                     $data[] = BASE_URL . $value->getPath() . $value->getFilename();
  1185.                 } elseif ($value->getType() == 'video') {
  1186.                     $data[] = BASE_URL . $value->getPath() . $value->getFilename();
  1187.                 }
  1188.             }
  1189.             $result = ["success" => true, "data" => $data];
  1190.             return $this->json($result);
  1191.         } catch (\Exception $ex) {
  1192.             $this->logger->error($ex->getMessage());
  1193.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1194.         }
  1195.     }
  1197.     /**
  1198.      * @Route("/kingdom-weather-description", methods={"POST"})
  1199.      */
  1200.     public function kingdomWeatherDirect(Request $request): JsonResponse
  1201.     {
  1202.         try {
  1203.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1204.             if ($response['success'] !== true) {
  1205.                 return $this->json($response);
  1206.             }
  1208.             // get request params
  1209.             $params = json_decode($request->getContent(), true);
  1211.             // set locale
  1212.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1214.             return $this->json($this->ncmWeatherApiService->getKingdomWeatherData());
  1215.         } catch (\Exception $ex) {
  1216.             $this->logger->error($ex->getMessage());
  1217.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1218.         }
  1219.     }
  1221.     /**
  1222.      * @Route("/get-hijri-date", name="api_ncm_device_get_hijri_date", methods={"POST"})
  1223.      */
  1224.     public function getHijriDatetime(Request $request): Response
  1225.     {
  1227.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1228.         if ($response['success'] !== true) {
  1229.             return $this->json($response);
  1230.         }
  1231.         $params = json_decode($request->getContent(), true);
  1232.         if (isset($params['location']) && isset($params['rawOffset'])) {
  1233.             $offset = $params['rawOffset'] / 3600;
  1234.             $locations = $params['location'];
  1235.             $parameters = ["sunset:sql"];
  1236.             // Join the locations and parameters strings with ',' for the URL
  1237.             $parameterString = $parameters;
  1238.             $locationString = implode('+', $locations);
  1240.             // Create a DateTime object
  1241.             $date = new DateTime();
  1242.             $dateStrings = [];
  1244.             // Format the DateTime object as a string and add it to the array
  1245.             for ($i = 0; $i < count($locations); $i++) {
  1246.                 $dateStrings[] = $date->format(DateTime::ISO8601);
  1247.             }
  1249.             // Join the date strings with ',' for the URL
  1250.             $dateString = implode(',', $dateStrings);
  1251.             $response = $this->meteomaticApiService->getRouteQuery(
  1252.                 $dateString,
  1253.                 $parameterString,
  1254.                 $locationString
  1255.             );
  1256.             $sunsetTime = "";
  1257.             if ($response['success'] == true) {
  1258.                 $sunsetTime = $response['data']['data'][0]['parameters'][0]['value'];
  1259.                 $response = \App\Lib\Utility::getHijriDatetime($sunsetTime, $offset);
  1260.             }
  1261.         } else {
  1262.             $response = \App\Lib\Utility::getHijriDatetime();
  1263.         }
  1265.         return $this->json(["success" => true, "date" => $response]);
  1266.     }
  1268.     /**
  1269.      * @Route("/get-isolines", methods={"GET"})
  1270.      */
  1271.     public function getIsolinesAction(Request $request): JsonResponse
  1272.     {
  1273.         try {
  1274.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1275.             if ($response['success'] !== true) {
  1276.                 return $this->json($response);
  1277.             }
  1280.             // Get access token
  1282.             $tokenResult = $this->meteomaticApiService->getToken();
  1283.             if (!isset($tokenResult['access_token'])) {
  1284.                 throw new \RuntimeException("Failed to retrieve access token");
  1285.             }
  1286.             $accessToken = $tokenResult['access_token'];
  1289.             $measure = $request->get('measure');
  1290.             $dateTime = $request->get('date_time');
  1291.             $accessToken = $accessToken;
  1292.             $bbox = $request->get('bbox');
  1295.             if (!$measure) {
  1296.                 throw new \InvalidArgumentException("Missing mandatory parameter: measure");
  1297.             }
  1299.             if (!$dateTime) {
  1300.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  1301.             }
  1302.             if (!$accessToken) {
  1303.                 throw new \InvalidArgumentException("Missing mandatory parameter: access_token");
  1304.             }
  1305.             if (isset($bbox) && !empty($bbox)) {
  1306.                 $bboxString = "&bbox=" . $bbox;
  1307.             } else {
  1308.                 $bboxString = "";
  1309.             }
  1310.             $result = $this->meteomaticsWeatherService->getIsolines($measure, $dateTime, $accessToken, $bboxString);
  1311.             return $this->json($result);
  1312.         } catch (\Exception $ex) {
  1313.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1314.         }
  1315.     }
  1317.     private function buildPublicQueryRedisCacheKey(
  1318.         DateTime $startDate,
  1319.         DateTime $endDate,
  1320.         string $resolution,
  1321.         array $parametersArray,
  1322.         string|array $coordinate,
  1323.         string $format,
  1324.         string $model,
  1325.         string $source,
  1326.         string $onInvalid,
  1327.         bool $isPolygon = false
  1328.     ): string {
  1329.         $startBucket = $startDate->format('Y-m-d-H');
  1330.         $endBucket = $endDate->format('Y-m-d-H');
  1331.         $coordKey = $this->normalizeCoordinateStringForPublicQueryCache($coordinate);
  1332.         $paramsSorted = $parametersArray;
  1333.         sort($paramsSorted, SORT_STRING);
  1334.         $payload = implode('|', [
  1335.             $coordKey,
  1336.             $startBucket,
  1337.             $endBucket,
  1338.             $resolution,
  1339.             implode(',', $paramsSorted),
  1340.             $format,
  1341.             $model,
  1342.             $source,
  1343.             $onInvalid,
  1344.             $isPolygon ? '1' : '0',
  1345.         ]);
  1347.         return 'public_query:v2:' . md5($payload);
  1348.     }
  1350.     private function normalizeCoordinateStringForPublicQueryCache(string|array $coordinate): string
  1351.     {
  1352.         if (is_array($coordinate)) {
  1353.             if (isset($coordinate[0]) && is_array($coordinate[0])) {
  1354.                 $coordinate = implode('+', array_map(
  1355.                     static fn(array $point): string => implode(',', $point),
  1356.                     $coordinate
  1357.                 ));
  1358.             } else {
  1359.                 $coordinate = implode(',', $coordinate);
  1360.             }
  1361.         }
  1363.         $normalized = str_replace(['+', '_', ' '], ',', $coordinate);
  1364.         $parts = preg_split('/,+/', $normalized, -1, PREG_SPLIT_NO_EMPTY);
  1365.         $rounded = [];
  1366.         foreach ($parts as $part) {
  1367.             $part = trim($part);
  1368.             if ($part === '' || !is_numeric($part)) {
  1369.                 continue;
  1370.             }
  1371.             $rounded[] = sprintf('%.3f', round((float) $part, 3));
  1372.         }
  1374.         return implode('_', $rounded);
  1375.     }
  1377.     private function parseRequestBoolean(mixed $value): bool
  1378.     {
  1379.         if (is_bool($value)) {
  1380.             return $value;
  1381.         }
  1382.         if (is_int($value) || is_float($value)) {
  1383.             return (bool) $value;
  1384.         }
  1385.         if (is_string($value)) {
  1386.             return in_array(strtolower(trim($value)), ['1', 'true', 'yes', 'on'], true);
  1387.         }
  1389.         return false;
  1390.     }
  1391. }