src/Controller/DeviceApiController.php line 46

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\DeviceModel;
  20. use App\Model\ReportLogModel;
  21. use Pimcore\Log\ApplicationLogger;
  22. use Symfony\Component\Templating\EngineInterface;
  23. use App\Service\EmailService;
  24. use App\Service\MeteomaticApiService;
  25. use App\Service\PublicUserPermissionService;
  26. use Lexik\Bundle\JWTAuthenticationBundle\Services\JWTTokenManagerInterface;
  27. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  28. use Knp\Component\Pager\PaginatorInterface;
  29. use App\Model\WeatherForecastCityModel;
  30. use App\Service\CustomNotificationService;
  32. /**
  33.  * User controller is responsible for handling various actions related to user management.
  34.  *
  35.  * @Route("/api/ncm/device")
  36.  */
  37. class DeviceApiController extends FrontendController
  38. {
  39.     private $weatherStationModel;
  40.     private $ewsNotificationModel;
  41.     private $deviceModel;
  42.     private $reportLogModel;
  43.     var $emailService = null;
  46.     public function __construct(
  47.         protected TranslatorInterface $translator,
  48.         private ApplicationLogger $logger,
  49.         private EngineInterface $templating,
  50.         private NCMWeatherAPIService $ncmWeatherApiService,
  51.         private MeteomaticApiService $meteomaticApiService,
  52.         private MeteomaticsWeatherService $meteomaticsWeatherService,
  53.         private BassicAuthService $bassicAuthService,
  54.         private UserPermission $userPermission,
  55.         private TokenStorageInterface $tokenStorageInterface,
  56.         private JWTTokenManagerInterface $jwtManager,
  57.         private PublicUserPermissionService $publicUserPermissionService,
  58.         private CustomNotificationService $customNotificationService
  59.     ) {
  60.         header('Content-Type: application/json; charset=UTF-8');
  61.         header("Access-Control-Allow-Origin: *");
  62.         $this->ewsNotificationModel = new EwsNotificationModel();
  63.         $this->weatherStationModel = new WeatherStationModel();
  64.         $this->deviceModel = new DeviceModel();
  65.         $this->reportLogModel = new ReportLogModel();
  66.         $this->templating = $templating;
  67.         $this->emailService = new EmailService();
  68.     }
  70.     /**
  71.      * @Route("/regions", methods={"POST"})
  72.      */
  73.     public function regions(Request $request): JsonResponse
  74.     {
  75.         try {
  76.             $params = json_decode($request->getContent(), true);
  77.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  79.             // check user credentials and expiry
  80.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  81.             if ($response['success'] !== true) {
  82.                 return $this->json($response);
  83.             }
  84.             $search = (isset($params['search']) && !empty($params['search'])) ? $params['search'] : null;
  85.             $result = $this->ncmWeatherApiService->getRegions($search, isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  86.             return $this->json($result);
  87.         } catch (\Exception $ex) {
  88.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  89.         }
  90.     }
  92.     /**
  93.      * @Route("/route-query", methods={"POST"})
  94.      */
  95.     public function routeQuery(Request $request): JsonResponse
  96.     {
  97.         $params = json_decode($request->getContent(), true);
  98.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  100.         // check basic Authorization
  101.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  102.         if ($response['success'] !== true) {
  103.             return $this->json($response);
  104.         }
  106.         // validate required parms
  107.         if (
  108.             !isset($params['date']) || !isset($params['parameters']) || !isset($params['location'])
  109.         ) {
  110.             throw new \Exception('Missing required parameters');
  111.         }
  113.         $locations = $params['location'];
  114.         $parameters = $params['parameters'];
  115.         // Join the locations and parameters strings with ',' for the URL
  116.         $parameterString = $parameters;
  117.         $locationString = implode('+', $locations);
  119.         // Create a DateTime object
  120.         $date = new DateTime($params['date']);
  122.         $dateStrings = [];
  124.         // Format the DateTime object as a string and add it to the array
  125.         for ($i = 0; $i < count($locations); $i++) {
  126.             $dateStrings[] = $date->format(DateTime::ISO8601);
  127.         }
  129.         // Join the date strings with ',' for the URL
  130.         $dateString = implode(',', $dateStrings);
  132.         $response = $this->meteomaticApiService->getRouteQuery(
  133.             $dateString,
  134.             $parameterString,
  135.             $locationString
  136.         );
  138.         // For demonstration purposes, we will just return a JSON response
  139.         return $this->json($response);
  140.     }
  142.     /**
  143.      * @Route("/municipality", methods={"POST"})
  144.      */
  145.     public function getMunicipalityAction(Request $request): JsonResponse
  146.     {
  147.         try {
  148.             $params = json_decode($request->getContent(), true);
  149.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  151.             // check user credentials and expiry
  152.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  153.             if ($response['success'] !== true) {
  154.                 return $this->json($response);
  155.             }
  157.             if (!isset($params['governorate_id'])) {
  158.                 throw new \Exception('Missing required governorate id');
  159.             }
  160.             $governorateId = $params['governorate_id'];
  162.             $result = $this->ewsNotificationModel->getMunicipality($governorateId, $params['lang']);
  164.             return $this->json($result);
  165.         } catch (\Exception $ex) {
  166.             $this->logger->error($ex->getMessage());
  167.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  168.         }
  169.     }
  171.     /**
  172.      * @Route("/governorates", methods={"POST"})
  173.      */
  174.     public function getGovernorateByRegionAction(Request $request): JsonResponse
  175.     {
  176.         try {
  178.             $params = json_decode($request->getContent(), true);
  179.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  181.             // check user credentials and expiry
  182.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  183.             if ($response['success'] !== true) {
  184.                 return $this->json($response);
  185.             }
  187.             // if (!isset($params['region_id'])) {
  188.             //     throw new \Exception('Missing required region id');
  189.             // }
  190.             // $regionId = $params['region_id'];
  191.             $result = $this->ewsNotificationModel->getGovernoratesByRegion($params);
  193.             return $this->json($result);
  194.         } catch (\Exception $ex) {
  195.             $this->logger->error($ex->getMessage());
  196.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  197.         }
  198.     }
  200.     /**
  201.      * @Route("/tidal-amplitude", name="tidal-amplitude", methods={"POST"})
  202.      */
  203.     public function tidalAmplitudeData(Request $request): JsonResponse
  204.     {
  206.         try {
  208.             $params = json_decode($request->getContent(), true);
  209.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  211.             // check user credentials and expiry
  212.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  213.             if ($response['success'] !== true) {
  214.                 return $this->json($response);
  215.             }
  218.             $requiredParameters = ['hour', 'parameter', 'date', 'coordinates', 'model', 'format'];
  219.             foreach ($requiredParameters as $param) {
  220.                 if (!isset($params[$param])) {
  221.                     $missingParams[] = $param;
  222.                 }
  223.             }
  224.             if (!empty($missingParams)) {
  225.                 // Throw an exception with a message that includes the missing parameters
  226.                 $parameterList = implode(", ", $missingParams);
  227.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  228.             }
  230.             $hour = $params['hour'];
  231.             $parameter = $params['parameter'];
  232.             $date = $params['date'];
  233.             $coordinates = $params['coordinates'];
  234.             $model = $params['model'];
  235.             $format = $params['format'];
  239.             $response = $this->meteomaticsWeatherService->getTidalAmplitudes(
  240.                 $hour,
  241.                 $parameter,
  242.                 $date,
  243.                 $coordinates,
  244.                 $model,
  245.                 $format
  246.             );
  248.             // You can return or process the $data as needed
  249.             // For demonstration purposes, we will just return a JSON response
  250.             return $this->json($response);
  251.         } catch (\Exception $ex) {
  252.             $this->logger->error($ex->getMessage());
  253.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  254.         }
  255.     }
  257.     /**
  258.      * @Route("/high-low-tide-times", name="high_low_tide_times", methods={"POST"})
  259.      */
  260.     public function highLowTideTimesData(Request $request): JsonResponse
  261.     {
  263.         try {
  265.             $params = json_decode($request->getContent(), true);
  266.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  268.             // check user credentials and expiry
  269.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  270.             if ($response['success'] !== true) {
  271.                 return $this->json($response);
  272.             }
  275.             $requiredParameters = ['hour', 'date', 'coordinates', 'model', 'format'];
  276.             foreach ($requiredParameters as $param) {
  277.                 if (!isset($params[$param])) {
  278.                     $missingParams[] = $param;
  279.                 }
  280.             }
  281.             if (!empty($missingParams)) {
  282.                 // Throw an exception with a message that includes the missing parameters
  283.                 $parameterList = implode(", ", $missingParams);
  284.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  285.             }
  287.             $hour = $params['hour'];
  288.             $date = $params['date'];
  289.             $coordinates = $params['coordinates'];
  290.             $model = $params['model'];
  291.             $format = $params['format'];
  295.             $response = $this->meteomaticsWeatherService->getHighLowTideTimes(
  296.                 $hour,
  297.                 $date,
  298.                 $coordinates,
  299.                 $model,
  300.                 $format
  301.             );
  303.             // You can return or process the $data as needed
  304.             // For demonstration purposes, we will just return a JSON response
  305.             return $this->json($response);
  306.         } catch (\Exception $ex) {
  307.             $this->logger->error($ex->getMessage());
  308.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  309.         }
  310.     }
  312.     /**
  313.      * @Route("/significant-wave-height", name="significant_wave_height", methods={"POST"})
  314.      */
  315.     public function significantWaveHeightData(Request $request): JsonResponse
  316.     {
  318.         try {
  320.             $params = json_decode($request->getContent(), true);
  321.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  322.             // check user credentials and expiry
  323.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  324.             if ($response['success'] !== true) {
  325.                 return $this->json($response);
  326.             }
  329.             $requiredParameters = ['hour', 'date', 'coordinates', 'format'];
  330.             foreach ($requiredParameters as $param) {
  331.                 if (!isset($params[$param])) {
  332.                     $missingParams[] = $param;
  333.                 }
  334.             }
  335.             if (!empty($missingParams)) {
  336.                 // Throw an exception with a message that includes the missing parameters
  337.                 $parameterList = implode(", ", $missingParams);
  338.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  339.             }
  341.             $hour = $params['hour'];
  342.             $date = $params['date'];
  343.             $coordinates = $params['coordinates'];
  344.             $format = $params['format'];
  348.             $response = $this->meteomaticsWeatherService->getSignificantWaveHeight(
  349.                 $hour,
  350.                 $date,
  351.                 $coordinates,
  352.                 $format
  353.             );
  355.             // You can return or process the $data as needed
  356.             // For demonstration purposes, we will just return a JSON response
  357.             return $this->json($response);
  358.         } catch (\Exception $ex) {
  359.             $this->logger->error($ex->getMessage());
  360.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  361.         }
  362.     }
  364.     /**
  365.      * @Route("/surge-amplitude", name="surge_amplitude", methods={"POST"})
  366.      */
  367.     public function surgeAmplitudeData(Request $request): JsonResponse
  368.     {
  370.         try {
  372.             $params = json_decode($request->getContent(), true);
  373.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  374.             // check user credentials and expiry
  375.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  376.             if ($response['success'] !== true) {
  377.                 return $this->json($response);
  378.             }
  381.             $requiredParameters = ['hour', 'date', 'coordinates', 'model', 'format'];
  382.             foreach ($requiredParameters as $param) {
  383.                 if (!isset($params[$param])) {
  384.                     $missingParams[] = $param;
  385.                 }
  386.             }
  387.             if (!empty($missingParams)) {
  388.                 // Throw an exception with a message that includes the missing parameters
  389.                 $parameterList = implode(", ", $missingParams);
  390.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  391.             }
  393.             $hour = $params['hour'];
  394.             $date = $params['date'];
  395.             $coordinates = $params['coordinates'];
  396.             $model = $params['model'];
  397.             $format = $params['format'];
  401.             $response = $this->meteomaticsWeatherService->getSurgeAmplitude(
  402.                 $hour,
  403.                 $date,
  404.                 $coordinates,
  405.                 $model,
  406.                 $format
  407.             );
  409.             // You can return or process the $data as needed
  410.             // For demonstration purposes, we will just return a JSON response
  411.             return $this->json($response);
  412.         } catch (\Exception $ex) {
  413.             $this->logger->error($ex->getMessage());
  414.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  415.         }
  416.     }
  418.     /**
  419.      * @Route("/fog", name="fog", methods={"POST"})
  420.      */
  421.     public function fogData(Request $request): JsonResponse
  422.     {
  424.         try {
  426.             $params = json_decode($request->getContent(), true);
  427.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  428.             // check user credentials and expiry
  429.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  430.             if ($response['success'] !== true) {
  431.                 return $this->json($response);
  432.             }
  435.             $requiredParameters = ['hour', 'date', 'coordinates', 'format'];
  436.             foreach ($requiredParameters as $param) {
  437.                 if (!isset($params[$param])) {
  438.                     $missingParams[] = $param;
  439.                 }
  440.             }
  441.             if (!empty($missingParams)) {
  442.                 // Throw an exception with a message that includes the missing parameters
  443.                 $parameterList = implode(", ", $missingParams);
  444.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  445.             }
  447.             $hour = $params['hour'];
  448.             $date = $params['date'];
  449.             $coordinates = $params['coordinates'];
  450.             $format = $params['format'];
  454.             $response = $this->meteomaticsWeatherService->getFog(
  455.                 $coordinates,
  456.                 $date
  457.             );
  459.             // You can return or process the $data as needed
  460.             // For demonstration purposes, we will just return a JSON response
  461.             return $this->json($response);
  462.         } catch (\Exception $ex) {
  463.             $this->logger->error($ex->getMessage());
  464.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  465.         }
  466.     }
  468.     /**
  469.      * @Route("/search-ews-notification",  name = "search-ews-notification", methods={"POST"})
  470.      */
  471.     public function searchEwsNotificationAction(Request $request, PaginatorInterface $paginator): JsonResponse
  472.     {
  473.         try {
  476.             // check user credentials and expiry
  477.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  478.             if ($response['success'] !== true) {
  479.                 return $this->json($response);
  480.             }
  482.             $params = json_decode($request->getContent(), true);
  484.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  487.             $lang = (isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  489.             $result = $this->ewsNotificationModel->searchEwsNotification($params, $lang, $paginator = null, $this->translator);
  490.             return $this->json($result);
  491.         } catch (\Exception $ex) {
  492.             $this->logger->error($ex->getMessage());
  493.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  494.         }
  495.     }
  497.     /**
  498.      * @Route("/translations/{locale?}", name="translations", methods={"GET"})
  499.      */
  500.     public function frontendDashboardTranslation(Request $request, $locale = null)
  501.     {
  502.         try {
  503.             $response = [];
  504.             $db = \Pimcore\Db::get();
  506.             if ($locale) {
  507.                 // Fetch translations for the provided locale
  508.                 $selectedLocalities = $db->fetchAllAssociative("
  509.                 SELECT * FROM translations_messages 
  510.                 WHERE `key` LIKE 'publicapp_%' 
  511.                 AND `language` = :locale 
  512.                 ORDER BY `creationDate` ASC
  513.             ", ['locale' => $locale]);
  515.                 foreach ($selectedLocalities as $value) {
  516.                     $keyParts = explode('_', $value['key'], 3);
  517.                     $category = $keyParts[1];
  518.                     $key = $keyParts[2];
  520.                     if (!isset($response[$category])) {
  521.                         $response[$category] = [];
  522.                     }
  524.                     $response[$category][$key] = $value['text'];
  525.                 }
  527.                 return $this->json($response);
  528.             } else {
  529.                 // Fetch translations for both 'ar' and 'en'
  530.                 $selectedLocalities = $db->fetchAllAssociative("
  531.                 SELECT * FROM translations_messages 
  532.                 WHERE `key` LIKE 'publicapp_%' 
  533.                 AND `language` IN ('ar', 'en') 
  534.                 ORDER BY `creationDate` ASC
  535.             ");
  537.                 foreach ($selectedLocalities as $value) {
  538.                     $keyParts = explode('_', $value['key'], 3);
  539.                     $category = $keyParts[1];
  540.                     $key = $keyParts[2];
  541.                     $language = $value['language'];
  543.                     if (!isset($response[$language])) {
  544.                         $response[$language] = [];
  545.                     }
  547.                     if (!isset($response[$language][$category])) {
  548.                         $response[$language][$category] = [];
  549.                     }
  551.                     $response[$language][$category][$key] = $value['text'];
  552.                 }
  554.                 return $this->json($response);
  555.             }
  556.         } catch (\Exception $ex) {
  557.             $this->logger->error($ex->getMessage());
  558.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  559.         }
  560.     }
  562.     /**
  563.      * @Route("/list-ewsnotification", methods={"POST"})
  564.      */
  565.     public function listEwsNotificationAction(Request $request, PaginatorInterface $paginator): JsonResponse
  566.     {
  567.         try {
  568.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  569.             if ($response['success'] !== true) {
  570.                 return $this->json($response);
  571.             }
  573.             $params = json_decode($request->getContent(), true);
  574.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  575.             $params['unpublished'] = false;
  576.             $params['status'] = 'active';
  577.             $result = $this->ewsNotificationModel->notificationListing($params, $paginator = null, $this->translator);
  578.             return $this->json($result);
  579.         } catch (\Exception $ex) {
  580.             $this->logger->error($ex->getMessage());
  581.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  582.         }
  583.     }
  585.     /**
  586.      * @Route("/query", methods={"POST"})
  587.      */
  588.     public function fetchMeteomaticData(Request $request): JsonResponse
  589.     {
  590.         $params = json_decode($request->getContent(), true);
  591.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  593.         // check user credentials and expiry
  594.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  595.         if ($response['success'] !== true) {
  596.             return $this->json($response);
  597.         }
  599.         if (!isset($params['format'])) {
  600.             throw new \InvalidArgumentException('Missing "format" parameter');
  601.         }
  603.         if ($params['format'] == "json") {
  604.             if (
  605.                 !isset($params['startdate']) ||
  606.                 !isset($params['enddate']) ||
  607.                 !isset($params['resolution']) ||
  608.                 !isset($params['parameters']) ||
  609.                 !isset($params['lat']) ||
  610.                 !isset($params['lon']) ||
  611.                 !isset($params['format'])
  612.             ) {
  613.                 throw new \Exception('Missing required parameters');
  614.             }
  615.             // date_default_timezone_set('UTC');
  617.             //$hour = $params['hour'];
  618.             $format = $params['format'];
  619.             $startDate = $params['startdate'];
  620.             $endDate = $params['enddate'];
  621.             $resolution = $params['resolution'];
  622.             $parameters = $params['parameters'];
  623.             $model = $params['model'];
  624.             $lat = $params['lat'];
  625.             $lon = $params['lon'];
  628.             $response = $this->meteomaticApiService->timeSeriesQuery(
  629.                 $startDate,
  630.                 $endDate,
  631.                 $resolution,
  632.                 $parameters,
  633.                 $model,
  634.                 $lat,
  635.                 $lon,
  636.                 $format,
  637.                 $this->translator
  638.             );
  639.         } else {
  640.             $mandatoryParams = ['version', 'request', 'layers', 'crs', 'bbox', 'format', 'width', 'height', 'tiled'];
  641.             foreach ($mandatoryParams as $param) {
  642.                 if (!isset($params[$param]) || empty($params[$param])) {
  643.                     $missingParams[] = $param;
  644.                 }
  645.             }
  647.             if (!empty($missingParams)) {
  648.                 // Throw an exception with a message that includes the missing parameters
  649.                 $parameterList = implode(", ", $missingParams);
  650.                 throw new \InvalidArgumentException(sprintf($this->translator->trans("missing_or_empty_mandatory_parameter: %s"), $parameterList));
  651.             }
  653.             header('Content-Type: image/png');
  654.             $result = $this->meteomaticsWeatherService->getWeatherMap($params['version'], $params['request'], $params['layers'], $params['crs'], $params['bbox'], $params['format'], $params['width'], $params['height'], $params['tiled']);
  656.             echo $result;
  657.             exit;
  658.         }
  660.         // You can return or process the $data as needed
  661.         // For demonstration purposes, we will just return a JSON response
  662.         return $this->json($response);
  663.     }
  665.     /**
  666.      * @Route("/public-query", methods={"POST"})
  667.      */
  668.     public function publicMetarQuery(Request $request): JsonResponse
  669.     {
  670.         try {
  671.             $params = json_decode($request->getContent(), true);
  672.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  674.             //check user credentials and expiry
  675.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  676.             if ($response['success'] !== true) {
  677.                 return $this->json($response);
  678.             }
  680.             if ($response['success'] !== true) {
  681.                 return $this->json($response);
  682.             }
  684.             if (
  685.                 !isset($params['startdate']) ||
  686.                 !isset($params['enddate']) ||
  687.                 !isset($params['resolution']) ||
  688.                 !isset($params['parameters']) ||
  689.                 !isset($params['coordinate']) ||
  690.                 !isset($params['format'])
  691.             ) {
  692.                 throw new \Exception('Missing required parameters');
  693.             }
  694.             // date_default_timezone_set('UTC');
  696.             //$hour = $params['hour'];
  697.             $format = $params['format'];
  698.             $startDate = $params['startdate'];
  699.             $endDate = $params['enddate'];
  700.             $resolution = $params['resolution'];
  701.             $parametersArray = $params['parameters'];
  703.             $coordinate = $params['coordinate'];
  704.             $parameters = implode(',', $parametersArray);
  706.             $model = '';
  707.             if (isset($params['model']) && !empty($params['model'])) {
  708.                 $model = $params['model'];
  709.             }
  710.             $source = '';
  711.             if (isset($params['source']) && !empty($params['source'])) {
  712.                 $source = $params['source'];
  713.             }
  714.             $onInvalid = '';
  715.             if (isset($params['on_invalid']) && !empty($params['on_invalid'])) {
  716.                 $onInvalid = $params['on_invalid'];
  717.             }
  719.             // Convert dates to the desired format (assuming start time is 00:00:00 and end time is 23:59:59)
  720.             $startDate = new DateTime($params['startdate']);
  721.             $endDate = new DateTime($params['enddate']);
  723.             $startDateStr = $startDate->format(DateTime::ISO8601);
  724.             $endDateStr = $endDate->format(DateTime::ISO8601);
  726.             $dateRange = $startDateStr . "--" . $endDateStr . ':' . $resolution;
  727.             $response = $this->meteomaticApiService->publicRouteQuery(
  728.                 $startDate,
  729.                 $endDate,
  730.                 $resolution,
  731.                 $parametersArray,
  732.                 $coordinate,
  733.                 $format,
  734.                 $model,
  735.                 $source,
  736.                 $onInvalid,
  738.             );
  739.             // You can return or process the $data as needed
  740.             // For demonstration purposes, we will just return a JSON response
  741.             return $this->json($response);
  742.         } catch (\Exception $ex) {
  743.             $this->logger->error($ex->getMessage());
  744.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  745.         }
  746.     }
  748.     /**
  749.      * @Route("/get-metar-data", methods={"POST"})
  750.      */ 
  751.     public function getMetarData(Request $request): Response
  752.     {
  753.         try {
  754.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  755.             if ($response['success'] !== true) {
  756.                 return $this->json($response);
  757.             }
  759.             $params = json_decode($request->getContent(), true);
  760.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  762.             $requiredParameters = ['startDate', 'endDate', 'metar', 'duration'];
  763.             foreach ($requiredParameters as $param) {
  764.                 if (!isset($params[$param])) {
  765.                     $missingParams[] = $param;
  766.                 }
  767.             }
  768.             if (!empty($missingParams)) {
  769.                 // Throw an exception with a message that includes the missing parameters
  770.                 $parameterList = implode(", ", $missingParams);
  771.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  772.             }
  774.             $startDate = $params['startDate'];
  775.             $endDate = $params['endDate'];
  776.             $metar = $params['metar'];
  777.             $duration = $params['duration'];
  778.             $parameters = $params['parameter'] ?? null;
  779.             $genExcel = $request->get('gen_excel', false);
  780.             $metarData = $this->meteomaticsWeatherService->getMetarData($startDate, $endDate, $metar, $duration, $this->translator, $parameters, $genExcel);
  782.             return $this->json(['success' => true, 'message' => $this->translator->trans("excel_file_downloaded_successfully"), 'data' => $metarData]);
  783.         } catch (\Exception $ex) {
  784.             $this->logger->error($ex->getMessage());
  785.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  786.         }
  787.     }
  789.     /**
  790.      * @Route("/get-airport-stations", methods={"POST"})
  791.      */
  792.     public function getAirportStations(Request $request): JsonResponse
  793.     {
  794.         try {
  795.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  796.             if ($response['success'] !== true) {
  797.                 return $this->json($response);
  798.             }
  800.             $params = json_decode($request->getContent(), true);
  801.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  803.             $result = $this->ncmWeatherApiService->getAirportStations($params['ccode'] ?? null);
  805.             return $this->json(['success' => true, 'data' => $result]);
  807.         } catch (\Exception $ex) {
  808.             $this->logger->error($ex->getMessage());
  809.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  810.         }
  812.     }
  814.     /**
  815.      * @Route("/get-forecast-cities", methods={"POST"})
  816.      */
  817.     public function getForecastCities(Request $request): Response
  818.     {
  819.         try {
  820.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  821.             if ($response['success'] !== true) {
  822.                 return $this->json($response);
  823.             }
  825.             $params = json_decode($request->getContent(), true);
  826.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  828.             $forecastCityModel = new WeatherForecastCityModel();
  829.             $cities = $forecastCityModel->getWeatherForecastCities();
  831.             return $this->json(['success' => true, 'data' => $cities]);
  832.         } catch (\Exception $ex) {
  833.             $this->logger->error($ex->getMessage());
  834.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  835.         }
  836.     }
  838.     /**
  839.      * @Route("/momra-generate-token", methods={"POST"})
  840.      */
  841.     public function getMomraGenerateToken(Request $request): JsonResponse
  842.     {
  843.         try {
  844.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  845.             if ($response['success'] !== true) {
  846.                 return $this->json($response);
  847.             }
  848.             $result = $this->ncmWeatherApiService->generateMomraToken();
  849.             return $this->json($result);
  850.         } catch (\Exception $ex) {
  851.             $this->logger->error($ex->getMessage());
  852.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  853.         }
  854.     }
  856.     /**
  857.      * @Route("/list-weather-station", methods={"POST"})
  858.      */
  859.     public function listWeatherStation(Request $request, PaginatorInterface $paginator): JsonResponse
  860.     {
  861.         try {
  862.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  863.             if ($response['success'] !== true) {
  864.                 return $this->json($response);
  865.             }
  867.             $params  = json_decode($request->getContent(), true);
  868.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  869.             $search = (isset($params['search']) && !empty($params['search'])) ? $params['search'] : null;
  870.             $id = (isset($params['id']) && !empty($params['id'])) ? $params['id'] : null;
  871.             $result = $this->weatherStationModel->getWeatherStations($paginator = null, null, null, $this->translator, $search, $id);
  872.             return $this->json($result);
  873.         } catch (\Exception $ex) {
  874.             $this->logger->error($ex->getMessage());
  875.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  876.         }
  877.     }
  879.     /**
  880.      * @Route("/get-station-data", methods={"GET"})
  881.      */
  882.     public function getWeatherStationDataAction(Request $request)
  883.     {
  884.         try {
  885.             $params = json_decode($request->getContent(), true);
  886.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  888.             // check user credentials and expiry
  889.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  890.             if ($response['success'] !== true) {
  891.                 return $this->json($response);
  892.             }
  895.             $typeName = $request->get('type_name');
  896.             $parameters = $request->get('parameters');
  897.             $dateTime = $request->get('date_time');
  898.             $bBox = $request->get('b_box');
  901.             if (!$typeName) {
  902.                 throw new \InvalidArgumentException("Missing mandatory parameter: type_name");
  903.             }
  904.             if (!$parameters) {
  905.                 throw new \InvalidArgumentException("Missing mandatory parameter: parameters");
  906.             }
  907.             if (!$dateTime) {
  908.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  909.             }
  910.             if (!$bBox) {
  911.                 throw new \InvalidArgumentException("Missing mandatory parameter: b_box");
  912.             }
  914.             $result = $this->meteomaticsWeatherService->getWeatherStationData($typeName, $parameters, $dateTime, $bBox);
  915.             return $result;
  916.         } catch (\Exception $ex) {
  917.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  918.         }
  919.     }
  921.     /**
  922.      * @Route("/get-push-alert-notification", methods={"POST"})
  923.      */
  924.     public function getPushAlertNotification(Request $request): Response
  925.     {
  926.         try {
  927.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  928.             if ($response['success'] !== true) {
  929.                 return $this->json($response);
  930.             }
  932.             $params = json_decode($request->getContent(), true);
  933.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  935.             $result  = $this->deviceModel->getPushAlertNotification($params, $this->translator);
  937.             return $this->json(['success' => true, 'data' => $result]);
  938.         } catch (\Exception $ex) {
  939.             $this->logger->error($ex->getMessage());
  940.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  941.         }
  942.     }
  944.     /**
  945.      * @Route("/manned-alerts", methods={"POST"})
  946.      */
  947.     public function mannedAlerts(Request $request, PaginatorInterface $paginator): JsonResponse
  948.     {
  949.         try {
  950.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  951.             if ($response['success'] !== true) {
  952.                 return $this->json($response);
  953.             }
  955.             $params = json_decode($request->getContent(), true);
  956.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  958.             if (!isset($params['from_date']) || !isset($params['to_date'])) {
  959.                 // throw new \Exception('Date range is required');
  960.                 return $this->json(['success' => false, 'message' =>  $this->translator->trans('date_range_is_required')]);
  961.             }
  963.             $result = $this->customNotificationService->getMannedAlerts($params, $paginator = null);
  965.             return $this->json($result);
  966.         } catch (\Exception $ex) {
  967.             $this->logger->error($ex->getMessage());
  968.             return $this->json(['success' => false, 'message' =>  $this->translator->trans(USER_ERROR_MESSAGE)]);
  969.         }
  970.     }
  972.     /**
  973.      * @Route("/get-phenomena-list", methods={"POST"})
  974.      */
  975.     public function getPhenomenaList(Request $request): JsonResponse
  976.     {
  977.         try {
  978.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  979.             if ($response['success'] !== true) {
  980.                 return $this->json($response);
  981.             }
  983.             $params = json_decode($request->getContent(), true);
  984.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  987.             $result = $this->ewsNotificationModel->getPhenomenaList();
  988.             return $this->json($result);
  989.         } catch (\Exception $ex) {
  990.             $this->logger->error($ex->getMessage());
  991.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  992.         }
  993.     }
  995.     /**
  996.      * @Route("/get-today-weather-report", methods={"POST"})
  997.      */
  998.     public function getTodayWeatherReport(Request $request): JsonResponse
  999.     {
  1000.         try {
  1001.             // check user credentials and expiry
  1002.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1003.             if ($response['success'] !== true) {
  1004.                 return $this->json($response);
  1005.             }
  1007.             // get request params
  1008.             $params = json_decode($request->getContent(), true);
  1010.             // set locale
  1011.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1013.             // get today weather report data
  1014.             $result = $this->reportLogModel->getTodayWeatherReportData($request, $this->translator);
  1015.             return $this->json($result);
  1016.         } catch (\Exception $ex) {
  1017.             $this->logger->error($ex->getMessage());
  1018.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1019.         }
  1020.     }
  1022.     /**
  1023.      * @Route("/get-all-weather-report", methods={"POST"})
  1024.      */
  1025.     public function getAllWeatherReport(Request $request): JsonResponse
  1026.     {
  1027.         try {
  1028.             // check user credentials and expiry
  1029.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1030.             if ($response['success'] !== true) {
  1031.                 return $this->json($response);
  1032.             }
  1034.             // get request params
  1035.             $params = json_decode($request->getContent(), true);
  1037.             // set locale
  1038.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1040.             // get today weather report data
  1041.             $result = $this->reportLogModel->getAllWeatherReportData($request, $this->translator);
  1042.             return $this->json($result);
  1043.         } catch (\Exception $ex) {
  1044.             $this->logger->error($ex->getMessage());
  1045.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1046.         }
  1047.     }
  1049.     /**
  1050.      * @Route("/get-mobile-assets-list", methods={"POST"})
  1051.      */
  1052.     public function getMobileAssetsList(Request $request): JsonResponse
  1053.     {
  1054.         try {
  1055.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1056.             if ($response['success'] !== true) {
  1057.                 return $this->json($response);
  1058.             }
  1059.             $data = [];
  1060.             $list = new \Pimcore\Model\Asset\Listing();
  1061.             $list->setCondition("path LIKE ?", ["/mobile-assets%"]);
  1062.             $list->load();
  1063.             foreach ($list as $key => $value) {
  1064.                 if ($value->getType() == "image") {
  1065.                     $data[] = BASE_URL . $value->getPath() . $value->getFilename();
  1066.                 } elseif ($value->getType() == 'video') {
  1067.                     $data[] = BASE_URL . $value->getPath() . $value->getFilename();
  1068.                 }
  1069.             }
  1070.             $result = ["success" => true, "data" => $data];
  1071.             return $this->json($result);
  1072.         } catch (\Exception $ex) {
  1073.             $this->logger->error($ex->getMessage());
  1074.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1075.         }
  1076.     }
  1078.     /**
  1079.      * @Route("/kingdom-weather-description", methods={"POST"})
  1080.      */
  1081.     public function kingdomWeatherDirect(Request $request): JsonResponse
  1082.     {
  1083.         try {
  1084.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1085.             if ($response['success'] !== true) {
  1086.                 return $this->json($response);
  1087.             }
  1089.             // get request params
  1090.             $params = json_decode($request->getContent(), true);
  1092.             // set locale
  1093.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1095.             return $this->json($this->ncmWeatherApiService->getKingdomWeatherData());
  1096.         } catch (\Exception $ex) {
  1097.             $this->logger->error($ex->getMessage());
  1098.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1099.         }
  1100.     }
  1102.     /**
  1103.      * @Route("/get-hijri-date", name="api_ncm_device_get_hijri_date", methods={"POST"})
  1104.      */
  1105.     public function getHijriDatetime(Request $request): Response
  1106.     {
  1108.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1109.         if ($response['success'] !== true) {
  1110.             return $this->json($response);
  1111.         }
  1112.         $params = json_decode($request->getContent(), true);
  1113.         if (isset($params['location']) && isset($params['rawOffset'])) {
  1114.             $offset = $params['rawOffset'] / 3600;
  1115.             $locations = $params['location'];
  1116.             $parameters = ["sunset:sql"];
  1117.             // Join the locations and parameters strings with ',' for the URL
  1118.             $parameterString = $parameters;
  1119.             $locationString = implode('+', $locations);
  1121.             // Create a DateTime object
  1122.             $date = new DateTime();
  1123.             $dateStrings = [];
  1125.             // Format the DateTime object as a string and add it to the array
  1126.             for ($i = 0; $i < count($locations); $i++) {
  1127.                 $dateStrings[] = $date->format(DateTime::ISO8601);
  1128.             }
  1130.             // Join the date strings with ',' for the URL
  1131.             $dateString = implode(',', $dateStrings);
  1132.             $response = $this->meteomaticApiService->getRouteQuery(
  1133.                 $dateString,
  1134.                 $parameterString,
  1135.                 $locationString
  1136.             );
  1137.             $sunsetTime = "";
  1138.             if ($response['success'] == true) {
  1139.                 $sunsetTime = $response['data']['data'][0]['parameters'][0]['value'];
  1140.                 $response = \App\Lib\Utility::getHijriDatetime($sunsetTime, $offset);
  1141.             }
  1142.         } else {
  1143.             $response = \App\Lib\Utility::getHijriDatetime();
  1144.         }
  1146.         return $this->json(["success" => true, "date" => $response]);
  1147.     }
  1149.     /**
  1150.      * @Route("/get-isolines", methods={"GET"})
  1151.      */
  1152.     public function getIsolinesAction(Request $request): JsonResponse
  1153.     {
  1154.         try {
  1155.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1156.             if ($response['success'] !== true) {
  1157.                 return $this->json($response);
  1158.             }
  1161.             // Get access token
  1163.             $tokenResult = $this->meteomaticApiService->getToken();
  1164.             if (!isset($tokenResult['access_token'])) {
  1165.                 throw new \RuntimeException("Failed to retrieve access token");
  1166.             }
  1167.             $accessToken = $tokenResult['access_token'];
  1170.             $measure = $request->get('measure');
  1171.             $dateTime = $request->get('date_time');
  1172.             $accessToken = $accessToken;
  1175.             if (!$measure) {
  1176.                 throw new \InvalidArgumentException("Missing mandatory parameter: measure");
  1177.             }
  1179.             if (!$dateTime) {
  1180.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  1181.             }
  1182.             if (!$accessToken) {
  1183.                 throw new \InvalidArgumentException("Missing mandatory parameter: access_token");
  1184.             }
  1186.             $result = $this->meteomaticsWeatherService->getIsolines($measure, $dateTime, $accessToken);
  1187.             return $this->json($result);
  1188.         } catch (\Exception $ex) {
  1189.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1190.         }
  1191.     }
  1192. }