src/Controller/DeviceApiController.php line 37

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.         private \Doctrine\DBAL\Connection $connection,
  60.     ) {
  61.         header('Content-Type: application/json; charset=UTF-8');
  62.         header("Access-Control-Allow-Origin: *");
  63.         $this->ewsNotificationModel = new EwsNotificationModel();
  64.         $this->weatherStationModel = new WeatherStationModel();
  65.         $this->deviceModel = new DeviceModel();
  66.         $this->reportLogModel = new ReportLogModel();
  67.         $this->templating = $templating;
  68.         $this->emailService = new EmailService();
  69.     }
  71.     /**
  72.      * @Route("/regions", methods={"POST"})
  73.      */
  74.     public function regions(Request $request): JsonResponse
  75.     {
  76.         try {
  77.             $params = json_decode($request->getContent(), true);
  78.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  80.             // check user credentials and expiry
  81.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  82.             if ($response['success'] !== true) {
  83.                 return $this->json($response);
  84.             }
  85.             $search = (isset($params['search']) && !empty($params['search'])) ? $params['search'] : null;
  86.             $result = $this->ncmWeatherApiService->getRegions($search, isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  87.             return $this->json($result);
  88.         } catch (\Exception $ex) {
  89.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  90.         }
  91.     }
  93.     /**
  94.      * @Route("/route-query", methods={"POST"})
  95.      */
  96.     public function routeQuery(Request $request): JsonResponse
  97.     {
  98.         $params = json_decode($request->getContent(), true);
  99.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  101.         // check basic Authorization
  102.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  103.         if ($response['success'] !== true) {
  104.             return $this->json($response);
  105.         }
  107.         // validate required parms
  108.         if (
  109.             !isset($params['date']) || !isset($params['parameters']) || !isset($params['location'])
  110.         ) {
  111.             throw new \Exception('Missing required parameters');
  112.         }
  114.         $locations = $params['location'];
  115.         $parameters = $params['parameters'];
  116.         // Join the locations and parameters strings with ',' for the URL
  117.         $parameterString = $parameters;
  118.         $locationString = implode('+', $locations);
  120.         // Create a DateTime object
  121.         $date = new DateTime($params['date']);
  123.         $dateStrings = [];
  125.         // Format the DateTime object as a string and add it to the array
  126.         for ($i = 0; $i < count($locations); $i++) {
  127.             $dateStrings[] = $date->format(DateTime::ISO8601);
  128.         }
  130.         // Join the date strings with ',' for the URL
  131.         $dateString = implode(',', $dateStrings);
  133.         $response = $this->meteomaticApiService->getRouteQuery(
  134.             $dateString,
  135.             $parameterString,
  136.             $locationString
  137.         );
  139.         // For demonstration purposes, we will just return a JSON response
  140.         return $this->json($response);
  141.     }
  143.     /**
  144.      * @Route("/municipality", methods={"POST"})
  145.      */
  146.     public function getMunicipalityAction(Request $request): JsonResponse
  147.     {
  148.         try {
  149.             $params = json_decode($request->getContent(), true);
  150.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  152.             // check user credentials and expiry
  153.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  154.             if ($response['success'] !== true) {
  155.                 return $this->json($response);
  156.             }
  158.             if (!isset($params['governorate_id'])) {
  159.                 throw new \Exception('Missing required governorate id');
  160.             }
  161.             $governorateId = $params['governorate_id'];
  163.             $result = $this->ewsNotificationModel->getMunicipality($governorateId, $params['lang']);
  165.             return $this->json($result);
  166.         } catch (\Exception $ex) {
  167.             $this->logger->error($ex->getMessage());
  168.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  169.         }
  170.     }
  172.     /**
  173.      * @Route("/governorates", methods={"POST"})
  174.      */
  175.     public function getGovernorateByRegionAction(Request $request): JsonResponse
  176.     {
  177.         try {
  179.             $params = json_decode($request->getContent(), true);
  180.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  182.             // check user credentials and expiry
  183.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  184.             if ($response['success'] !== true) {
  185.                 return $this->json($response);
  186.             }
  188.             // if (!isset($params['region_id'])) {
  189.             //     throw new \Exception('Missing required region id');
  190.             // }
  191.             // $regionId = $params['region_id'];
  192.             $result = $this->ewsNotificationModel->getGovernoratesByRegion($params);
  194.             return $this->json($result);
  195.         } catch (\Exception $ex) {
  196.             $this->logger->error($ex->getMessage());
  197.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  198.         }
  199.     }
  201.     /**
  202.      * @Route("/tidal-amplitude", name="tidal-amplitude", methods={"POST"})
  203.      */
  204.     public function tidalAmplitudeData(Request $request): JsonResponse
  205.     {
  207.         try {
  209.             $params = json_decode($request->getContent(), true);
  210.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  212.             // check user credentials and expiry
  213.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  214.             if ($response['success'] !== true) {
  215.                 return $this->json($response);
  216.             }
  219.             $requiredParameters = ['hour', 'parameter', 'date', 'coordinates', 'model', 'format'];
  220.             foreach ($requiredParameters as $param) {
  221.                 if (!isset($params[$param])) {
  222.                     $missingParams[] = $param;
  223.                 }
  224.             }
  225.             if (!empty($missingParams)) {
  226.                 // Throw an exception with a message that includes the missing parameters
  227.                 $parameterList = implode(", ", $missingParams);
  228.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  229.             }
  231.             $hour = $params['hour'];
  232.             $parameter = $params['parameter'];
  233.             $date = $params['date'];
  234.             $coordinates = $params['coordinates'];
  235.             $model = $params['model'];
  236.             $format = $params['format'];
  240.             $response = $this->meteomaticsWeatherService->getTidalAmplitudes(
  241.                 $hour,
  242.                 $parameter,
  243.                 $date,
  244.                 $coordinates,
  245.                 $model,
  246.                 $format
  247.             );
  249.             // You can return or process the $data as needed
  250.             // For demonstration purposes, we will just return a JSON response
  251.             return $this->json($response);
  252.         } catch (\Exception $ex) {
  253.             $this->logger->error($ex->getMessage());
  254.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  255.         }
  256.     }
  258.     /**
  259.      * @Route("/high-low-tide-times", name="high_low_tide_times", methods={"POST"})
  260.      */
  261.     public function highLowTideTimesData(Request $request): JsonResponse
  262.     {
  264.         try {
  266.             $params = json_decode($request->getContent(), true);
  267.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  269.             // check user credentials and expiry
  270.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  271.             if ($response['success'] !== true) {
  272.                 return $this->json($response);
  273.             }
  276.             $requiredParameters = ['hour', 'date', 'coordinates', 'model', 'format'];
  277.             foreach ($requiredParameters as $param) {
  278.                 if (!isset($params[$param])) {
  279.                     $missingParams[] = $param;
  280.                 }
  281.             }
  282.             if (!empty($missingParams)) {
  283.                 // Throw an exception with a message that includes the missing parameters
  284.                 $parameterList = implode(", ", $missingParams);
  285.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  286.             }
  288.             $hour = $params['hour'];
  289.             $date = $params['date'];
  290.             $coordinates = $params['coordinates'];
  291.             $model = $params['model'];
  292.             $format = $params['format'];
  296.             $response = $this->meteomaticsWeatherService->getHighLowTideTimes(
  297.                 $hour,
  298.                 $date,
  299.                 $coordinates,
  300.                 $model,
  301.                 $format
  302.             );
  304.             // You can return or process the $data as needed
  305.             // For demonstration purposes, we will just return a JSON response
  306.             return $this->json($response);
  307.         } catch (\Exception $ex) {
  308.             $this->logger->error($ex->getMessage());
  309.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  310.         }
  311.     }
  313.     /**
  314.      * @Route("/significant-wave-height", name="significant_wave_height", methods={"POST"})
  315.      */
  316.     public function significantWaveHeightData(Request $request): JsonResponse
  317.     {
  319.         try {
  321.             $params = json_decode($request->getContent(), true);
  322.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  323.             // check user credentials and expiry
  324.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  325.             if ($response['success'] !== true) {
  326.                 return $this->json($response);
  327.             }
  330.             $requiredParameters = ['hour', 'date', 'coordinates', 'format'];
  331.             foreach ($requiredParameters as $param) {
  332.                 if (!isset($params[$param])) {
  333.                     $missingParams[] = $param;
  334.                 }
  335.             }
  336.             if (!empty($missingParams)) {
  337.                 // Throw an exception with a message that includes the missing parameters
  338.                 $parameterList = implode(", ", $missingParams);
  339.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  340.             }
  342.             $hour = $params['hour'];
  343.             $date = $params['date'];
  344.             $coordinates = $params['coordinates'];
  345.             $format = $params['format'];
  349.             $response = $this->meteomaticsWeatherService->getSignificantWaveHeight(
  350.                 $hour,
  351.                 $date,
  352.                 $coordinates,
  353.                 $format
  354.             );
  356.             // You can return or process the $data as needed
  357.             // For demonstration purposes, we will just return a JSON response
  358.             return $this->json($response);
  359.         } catch (\Exception $ex) {
  360.             $this->logger->error($ex->getMessage());
  361.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  362.         }
  363.     }
  365.     /**
  366.      * @Route("/surge-amplitude", name="surge_amplitude", methods={"POST"})
  367.      */
  368.     public function surgeAmplitudeData(Request $request): JsonResponse
  369.     {
  371.         try {
  373.             $params = json_decode($request->getContent(), true);
  374.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  375.             // check user credentials and expiry
  376.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  377.             if ($response['success'] !== true) {
  378.                 return $this->json($response);
  379.             }
  382.             $requiredParameters = ['hour', 'date', 'coordinates', 'model', 'format'];
  383.             foreach ($requiredParameters as $param) {
  384.                 if (!isset($params[$param])) {
  385.                     $missingParams[] = $param;
  386.                 }
  387.             }
  388.             if (!empty($missingParams)) {
  389.                 // Throw an exception with a message that includes the missing parameters
  390.                 $parameterList = implode(", ", $missingParams);
  391.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  392.             }
  394.             $hour = $params['hour'];
  395.             $date = $params['date'];
  396.             $coordinates = $params['coordinates'];
  397.             $model = $params['model'];
  398.             $format = $params['format'];
  402.             $response = $this->meteomaticsWeatherService->getSurgeAmplitude(
  403.                 $hour,
  404.                 $date,
  405.                 $coordinates,
  406.                 $model,
  407.                 $format
  408.             );
  410.             // You can return or process the $data as needed
  411.             // For demonstration purposes, we will just return a JSON response
  412.             return $this->json($response);
  413.         } catch (\Exception $ex) {
  414.             $this->logger->error($ex->getMessage());
  415.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  416.         }
  417.     }
  419.     /**
  420.      * @Route("/fog", name="fog", methods={"POST"})
  421.      */
  422.     public function fogData(Request $request): JsonResponse
  423.     {
  425.         try {
  427.             $params = json_decode($request->getContent(), true);
  428.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  429.             // check user credentials and expiry
  430.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  431.             if ($response['success'] !== true) {
  432.                 return $this->json($response);
  433.             }
  436.             $requiredParameters = ['hour', 'date', 'coordinates', 'format'];
  437.             foreach ($requiredParameters as $param) {
  438.                 if (!isset($params[$param])) {
  439.                     $missingParams[] = $param;
  440.                 }
  441.             }
  442.             if (!empty($missingParams)) {
  443.                 // Throw an exception with a message that includes the missing parameters
  444.                 $parameterList = implode(", ", $missingParams);
  445.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  446.             }
  448.             $hour = $params['hour'];
  449.             $date = $params['date'];
  450.             $coordinates = $params['coordinates'];
  451.             $format = $params['format'];
  455.             $response = $this->meteomaticsWeatherService->getFog(
  456.                 $coordinates,
  457.                 $date
  458.             );
  460.             // You can return or process the $data as needed
  461.             // For demonstration purposes, we will just return a JSON response
  462.             return $this->json($response);
  463.         } catch (\Exception $ex) {
  464.             $this->logger->error($ex->getMessage());
  465.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  466.         }
  467.     }
  469.     /**
  470.      * @Route("/search-ews-notification",  name = "search-ews-notification", methods={"POST"})
  471.      */
  472.     public function searchEwsNotificationAction(Request $request, PaginatorInterface $paginator): JsonResponse
  473.     {
  474.         try {
  477.             // check user credentials and expiry
  478.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  479.             if ($response['success'] !== true) {
  480.                 return $this->json($response);
  481.             }
  483.             $params = json_decode($request->getContent(), true);
  485.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  488.             $lang = (isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  489.             $paginator = (isset($params["paginator"]) ? $paginator : null);
  491.             $result = $this->ewsNotificationModel->searchEwsNotification($params, $lang, $paginator, $this->translator);
  492.             return $this->json($result);
  493.         } catch (\Exception $ex) {
  494.             $this->logger->error($ex->getMessage());
  495.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  496.         }
  497.     }
  498.     /**
  499.      * @Route("/ews-analytics", methods={"POST"})
  500.      */
  501.     public function ewsAnalyticsAction(Request $request): JsonResponse
  502.     {
  503.         try {
  504.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  505.             if ($response['success'] !== true) {
  506.                 return $this->json($response);
  507.             }
  508.             $params = json_decode($request->getContent(), true);
  509.             $lang = ($request->headers->has('lang')) ? $request->headers->get('lang') : "en";
  510.             $result = $this->ewsNotificationModel->ewsAnalytics($params, $this->connection, $lang);
  511.             return $this->json($result);
  512.         } catch (\Exception $ex) {
  513.             $this->logger->error($ex->getMessage());
  514.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  515.         }
  516.     }
  518.     /**
  519.      * @Route("/translations/{locale?}", name="translations", methods={"GET"})
  520.      */
  521.     public function frontendDashboardTranslation(Request $request, $locale = null)
  522.     {
  523.         try {
  524.             $response = [];
  525.             $db = \Pimcore\Db::get();
  527.             if ($locale) {
  528.                 // Fetch translations for the provided locale
  529.                 $selectedLocalities = $db->fetchAllAssociative("
  530.                 SELECT * FROM translations_messages 
  531.                 WHERE `key` LIKE 'publicapp_%' 
  532.                 AND `language` = :locale 
  533.                 ORDER BY `creationDate` ASC
  534.             ", ['locale' => $locale]);
  536.                 foreach ($selectedLocalities as $value) {
  537.                     $keyParts = explode('_', $value['key'], 3);
  538.                     $category = $keyParts[1];
  539.                     $key = $keyParts[2];
  541.                     if (!isset($response[$category])) {
  542.                         $response[$category] = [];
  543.                     }
  545.                     $response[$category][$key] = $value['text'];
  546.                 }
  548.                 return $this->json($response);
  549.             } else {
  550.                 // Fetch translations for both 'ar' and 'en'
  551.                 $selectedLocalities = $db->fetchAllAssociative("
  552.                 SELECT * FROM translations_messages 
  553.                 WHERE `key` LIKE 'publicapp_%' 
  554.                 AND `language` IN ('ar', 'en') 
  555.                 ORDER BY `creationDate` ASC
  556.             ");
  558.                 foreach ($selectedLocalities as $value) {
  559.                     $keyParts = explode('_', $value['key'], 3);
  560.                     $category = $keyParts[1];
  561.                     $key = $keyParts[2];
  562.                     $language = $value['language'];
  564.                     if (!isset($response[$language])) {
  565.                         $response[$language] = [];
  566.                     }
  568.                     if (!isset($response[$language][$category])) {
  569.                         $response[$language][$category] = [];
  570.                     }
  572.                     $response[$language][$category][$key] = $value['text'];
  573.                 }
  575.                 return $this->json($response);
  576.             }
  577.         } catch (\Exception $ex) {
  578.             $this->logger->error($ex->getMessage());
  579.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  580.         }
  581.     }
  583.     /**
  584.      * @Route("/list-ewsnotification", methods={"POST"})
  585.      */
  586.     public function listEwsNotificationAction(Request $request, PaginatorInterface $paginator): JsonResponse
  587.     {
  588.         try {
  589.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  590.             if ($response['success'] !== true) {
  591.                 return $this->json($response);
  592.             }
  594.             $params = json_decode($request->getContent(), true);
  595.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  596.             $params['unpublished'] = false;
  597.             $params['status'] = 'active';
  598.             $result = $this->ewsNotificationModel->notificationListing($params, $paginator = null, $this->translator);
  599.             return $this->json($result);
  600.         } catch (\Exception $ex) {
  601.             $this->logger->error($ex->getMessage());
  602.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  603.         }
  604.     }
  606.     /**
  607.      * @Route("/query", methods={"POST"})
  608.      */
  609.     public function fetchMeteomaticData(Request $request): JsonResponse
  610.     {
  611.         $params = json_decode($request->getContent(), true);
  612.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  614.         // check user credentials and expiry
  615.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  616.         if ($response['success'] !== true) {
  617.             return $this->json($response);
  618.         }
  620.         if (!isset($params['format'])) {
  621.             throw new \InvalidArgumentException('Missing "format" parameter');
  622.         }
  624.         if ($params['format'] == "json") {
  625.             if (
  626.                 !isset($params['startdate']) ||
  627.                 !isset($params['enddate']) ||
  628.                 !isset($params['resolution']) ||
  629.                 !isset($params['parameters']) ||
  630.                 !isset($params['lat']) ||
  631.                 !isset($params['lon']) ||
  632.                 !isset($params['format'])
  633.             ) {
  634.                 throw new \Exception('Missing required parameters');
  635.             }
  636.             // date_default_timezone_set('UTC');
  638.             //$hour = $params['hour'];
  639.             $format = $params['format'];
  640.             $startDate = $params['startdate'];
  641.             $endDate = $params['enddate'];
  642.             $resolution = $params['resolution'];
  643.             $parameters = $params['parameters'];
  644.             $model = $params['model'];
  645.             $lat = $params['lat'];
  646.             $lon = $params['lon'];
  649.             $response = $this->meteomaticApiService->timeSeriesQuery(
  650.                 $startDate,
  651.                 $endDate,
  652.                 $resolution,
  653.                 $parameters,
  654.                 $model,
  655.                 $lat,
  656.                 $lon,
  657.                 $format,
  658.                 $this->translator
  659.             );
  660.         } else {
  661.             $mandatoryParams = ['version', 'request', 'layers', 'crs', 'bbox', 'format', 'width', 'height', 'tiled'];
  662.             foreach ($mandatoryParams as $param) {
  663.                 if (!isset($params[$param]) || empty($params[$param])) {
  664.                     $missingParams[] = $param;
  665.                 }
  666.             }
  668.             if (!empty($missingParams)) {
  669.                 // Throw an exception with a message that includes the missing parameters
  670.                 $parameterList = implode(", ", $missingParams);
  671.                 throw new \InvalidArgumentException(sprintf($this->translator->trans("missing_or_empty_mandatory_parameter: %s"), $parameterList));
  672.             }
  674.             header('Content-Type: image/png');
  675.             $result = $this->meteomaticsWeatherService->getWeatherMap($params['version'], $params['request'], $params['layers'], $params['crs'], $params['bbox'], $params['format'], $params['width'], $params['height'], $params['tiled']);
  677.             echo $result;
  678.             exit;
  679.         }
  681.         // You can return or process the $data as needed
  682.         // For demonstration purposes, we will just return a JSON response
  683.         return $this->json($response);
  684.     }
  686.     /**
  687.      * @Route("/public-query", methods={"POST"})
  688.      */
  689.     public function publicMetarQuery(Request $request): JsonResponse
  690.     {
  691.         try {
  692.             $params = json_decode($request->getContent(), true);
  693.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  695.             //check user credentials and expiry
  696.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  697.             if ($response['success'] !== true) {
  698.                 return $this->json($response);
  699.             }
  701.             if ($response['success'] !== true) {
  702.                 return $this->json($response);
  703.             }
  705.             if (
  706.                 !isset($params['startdate']) ||
  707.                 !isset($params['enddate']) ||
  708.                 !isset($params['resolution']) ||
  709.                 !isset($params['parameters']) ||
  710.                 !isset($params['coordinate']) ||
  711.                 !isset($params['format'])
  712.             ) {
  713.                 throw new \Exception('Missing required parameters');
  714.             }
  715.             // date_default_timezone_set('UTC');
  717.             //$hour = $params['hour'];
  718.             $format = $params['format'];
  719.             $startDate = $params['startdate'];
  720.             $endDate = $params['enddate'];
  721.             $resolution = $params['resolution'];
  722.             $parametersArray = $params['parameters'];
  724.             $coordinate = $params['coordinate'];
  725.             $parameters = implode(',', $parametersArray);
  727.             $model = '';
  728.             if (isset($params['model']) && !empty($params['model'])) {
  729.                 $model = $params['model'];
  730.             }
  731.             $source = '';
  732.             if (isset($params['source']) && !empty($params['source'])) {
  733.                 $source = $params['source'];
  734.             }
  735.             $onInvalid = '';
  736.             if (isset($params['on_invalid']) && !empty($params['on_invalid'])) {
  737.                 $onInvalid = $params['on_invalid'];
  738.             }
  740.             // Convert dates to the desired format (assuming start time is 00:00:00 and end time is 23:59:59)
  741.             $startDate = new DateTime($params['startdate']);
  742.             $endDate = new DateTime($params['enddate']);
  744.             $startDateStr = $startDate->format(DateTime::ISO8601);
  745.             $endDateStr = $endDate->format(DateTime::ISO8601);
  747.             $dateRange = $startDateStr . "--" . $endDateStr . ':' . $resolution;
  748.             $response = $this->meteomaticApiService->publicRouteQuery(
  749.                 $startDate,
  750.                 $endDate,
  751.                 $resolution,
  752.                 $parametersArray,
  753.                 $coordinate,
  754.                 $format,
  755.                 $model,
  756.                 $source,
  757.                 $onInvalid,
  759.             );
  760.             // You can return or process the $data as needed
  761.             // For demonstration purposes, we will just return a JSON response
  762.             return $this->json($response);
  763.         } catch (\Exception $ex) {
  764.             $this->logger->error($ex->getMessage());
  765.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  766.         }
  767.     }
  769.     /**
  770.      * @Route("/get-metar-data", methods={"POST"})
  771.      */
  772.     public function getMetarData(Request $request): Response
  773.     {
  774.         try {
  775.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  776.             if ($response['success'] !== true) {
  777.                 return $this->json($response);
  778.             }
  780.             $params = json_decode($request->getContent(), true);
  781.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  783.             $requiredParameters = ['startDate', 'endDate', 'metar', 'duration'];
  784.             foreach ($requiredParameters as $param) {
  785.                 if (!isset($params[$param])) {
  786.                     $missingParams[] = $param;
  787.                 }
  788.             }
  789.             if (!empty($missingParams)) {
  790.                 // Throw an exception with a message that includes the missing parameters
  791.                 $parameterList = implode(", ", $missingParams);
  792.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  793.             }
  795.             $startDate = $params['startDate'];
  796.             $endDate = $params['endDate'];
  797.             $metar = $params['metar'];
  798.             $duration = $params['duration'];
  799.             $parameters = $params['parameter'] ?? null;
  800.             $genExcel = $request->get('gen_excel', false);
  801.             $metarData = $this->meteomaticsWeatherService->getMetarData($startDate, $endDate, $metar, $duration, $this->translator, $parameters, $genExcel);
  803.             return $this->json(['success' => true, 'message' => $this->translator->trans("excel_file_downloaded_successfully"), 'data' => $metarData]);
  804.         } catch (\Exception $ex) {
  805.             $this->logger->error($ex->getMessage());
  806.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  807.         }
  808.     }
  810.     /**
  811.      * @Route("/get-forecast-cities", methods={"POST"})
  812.      */
  813.     public function getForecastCities(Request $request): Response
  814.     {
  815.         try {
  816.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  817.             if ($response['success'] !== true) {
  818.                 return $this->json($response);
  819.             }
  821.             $params = json_decode($request->getContent(), true);
  822.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  824.             $forecastCityModel = new WeatherForecastCityModel();
  825.             $cities = $forecastCityModel->getWeatherForecastCities();
  827.             return $this->json(['success' => true, 'data' => $cities]);
  828.         } catch (\Exception $ex) {
  829.             $this->logger->error($ex->getMessage());
  830.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  831.         }
  832.     }
  834.     /**
  835.      * @Route("/momra-generate-token", methods={"POST"})
  836.      */
  837.     public function getMomraGenerateToken(Request $request): JsonResponse
  838.     {
  839.         try {
  840.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  841.             if ($response['success'] !== true) {
  842.                 return $this->json($response);
  843.             }
  844.             $result = $this->ncmWeatherApiService->generateMomraToken();
  845.             return $this->json($result);
  846.         } catch (\Exception $ex) {
  847.             $this->logger->error($ex->getMessage());
  848.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  849.         }
  850.     }
  852.     /**
  853.      * @Route("/list-weather-station", methods={"POST"})
  854.      */
  855.     public function listWeatherStation(Request $request, PaginatorInterface $paginator): JsonResponse
  856.     {
  857.         try {
  858.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  859.             if ($response['success'] !== true) {
  860.                 return $this->json($response);
  861.             }
  863.             $params  = json_decode($request->getContent(), true);
  864.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  866.             $result = $this->weatherStationModel->getWeatherStations($paginator = null, null, null, $this->translator);
  867.             return $this->json($result);
  868.         } catch (\Exception $ex) {
  869.             $this->logger->error($ex->getMessage());
  870.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  871.         }
  872.     }
  874.     /**
  875.      * @Route("/get-station-data", methods={"GET"})
  876.      */
  877.     public function getWeatherStationDataAction(Request $request)
  878.     {
  879.         try {
  880.             $params = json_decode($request->getContent(), true);
  881.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  883.             // check user credentials and expiry
  884.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  885.             if ($response['success'] !== true) {
  886.                 return $this->json($response);
  887.             }
  890.             $typeName = $request->get('type_name');
  891.             $parameters = $request->get('parameters');
  892.             $dateTime = $request->get('date_time');
  893.             $bBox = $request->get('b_box');
  896.             if (!$typeName) {
  897.                 throw new \InvalidArgumentException("Missing mandatory parameter: type_name");
  898.             }
  899.             if (!$parameters) {
  900.                 throw new \InvalidArgumentException("Missing mandatory parameter: parameters");
  901.             }
  902.             if (!$dateTime) {
  903.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  904.             }
  905.             if (!$bBox) {
  906.                 throw new \InvalidArgumentException("Missing mandatory parameter: b_box");
  907.             }
  909.             $result = $this->meteomaticsWeatherService->getWeatherStationData($typeName, $parameters, $dateTime, $bBox);
  910.             return $result;
  911.         } catch (\Exception $ex) {
  912.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  913.         }
  914.     }
  916.     /**
  917.      * @Route("/get-push-alert-notification", methods={"POST"})
  918.      */
  919.     public function getPushAlertNotification(Request $request): Response
  920.     {
  921.         try {
  922.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  923.             if ($response['success'] !== true) {
  924.                 return $this->json($response);
  925.             }
  927.             $params = json_decode($request->getContent(), true);
  928.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  930.             $result  = $this->deviceModel->getPushAlertNotification($params, $this->translator);
  932.             return $this->json(['success' => true, 'data' => $result]);
  933.         } catch (\Exception $ex) {
  934.             $this->logger->error($ex->getMessage());
  935.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  936.         }
  937.     }
  939.     /**
  940.      * @Route("/manned-alerts", methods={"POST"})
  941.      */
  942.     public function mannedAlerts(Request $request, PaginatorInterface $paginator): JsonResponse
  943.     {
  944.         try {
  945.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  946.             if ($response['success'] !== true) {
  947.                 return $this->json($response);
  948.             }
  950.             $params = json_decode($request->getContent(), true);
  951.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  953.             if (!isset($params['from_date']) || !isset($params['to_date'])) {
  954.                 // throw new \Exception('Date range is required');
  955.                 return $this->json(['success' => false, 'message' =>  $this->translator->trans('date_range_is_required')]);
  956.             }
  958.             $result = $this->customNotificationService->getMannedAlerts($params, $paginator = null);
  960.             return $this->json($result);
  961.         } catch (\Exception $ex) {
  962.             $this->logger->error($ex->getMessage());
  963.             return $this->json(['success' => false, 'message' =>  $this->translator->trans(USER_ERROR_MESSAGE)]);
  964.         }
  965.     }
  967.     /**
  968.      * @Route("/get-phenomena-list", methods={"POST"})
  969.      */
  970.     public function getPhenomenaList(Request $request): JsonResponse
  971.     {
  972.         try {
  973.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  974.             if ($response['success'] !== true) {
  975.                 return $this->json($response);
  976.             }
  978.             $params = json_decode($request->getContent(), true);
  979.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  982.             $result = $this->ewsNotificationModel->getPhenomenaList();
  983.             return $this->json($result);
  984.         } catch (\Exception $ex) {
  985.             $this->logger->error($ex->getMessage());
  986.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  987.         }
  988.     }
  990.     /**
  991.      * @Route("/get-today-weather-report", methods={"POST"})
  992.      */
  993.     public function getTodayWeatherReport(Request $request): JsonResponse
  994.     {
  995.         try {
  996.             // check user credentials and expiry
  997.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  998.             if ($response['success'] !== true) {
  999.                 return $this->json($response);
  1000.             }
  1002.             // get request params
  1003.             $params = json_decode($request->getContent(), true);
  1005.             // set locale
  1006.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1008.             // get today weather report data
  1009.             $result = $this->reportLogModel->getTodayWeatherReportData($request, $this->translator);
  1010.             return $this->json($result);
  1011.         } catch (\Exception $ex) {
  1012.             $this->logger->error($ex->getMessage());
  1013.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1014.         }
  1015.     }
  1017.     /**
  1018.      * @Route("/get-all-weather-report", methods={"POST"})
  1019.      */
  1020.     public function getAllWeatherReport(Request $request): JsonResponse
  1021.     {
  1022.         try {
  1023.             // check user credentials and expiry
  1024.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1025.             if ($response['success'] !== true) {
  1026.                 return $this->json($response);
  1027.             }
  1029.             // get request params
  1030.             $params = json_decode($request->getContent(), true);
  1032.             // set locale
  1033.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1035.             // get today weather report data
  1036.             $result = $this->reportLogModel->getAllWeatherReportData($request, $this->translator);
  1037.             return $this->json($result);
  1038.         } catch (\Exception $ex) {
  1039.             $this->logger->error($ex->getMessage());
  1040.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1041.         }
  1042.     }
  1044.     /**
  1045.      * @Route("/get-mobile-assets-list", methods={"POST"})
  1046.      */
  1047.     public function getMobileAssetsList(Request $request): JsonResponse
  1048.     {
  1049.         try {
  1050.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1051.             if ($response['success'] !== true) {
  1052.                 return $this->json($response);
  1053.             }
  1054.             $data = [];
  1055.             $list = new \Pimcore\Model\Asset\Listing();
  1056.             $list->setCondition("path LIKE ?", ["/mobile-assets%"]);
  1057.             $list->load();
  1058.             foreach ($list as $key => $value) {
  1059.                 if ($value->getType() == "image") {
  1060.                     $data[] = BASE_URL . $value->getPath() . $value->getFilename();
  1061.                 } elseif ($value->getType() == 'video') {
  1062.                     $data[] = BASE_URL . $value->getPath() . $value->getFilename();
  1063.                 }
  1064.             }
  1065.             $result = ["success" => true, "data" => $data];
  1066.             return $this->json($result);
  1067.         } catch (\Exception $ex) {
  1068.             $this->logger->error($ex->getMessage());
  1069.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1070.         }
  1071.     }
  1073.     /**
  1074.      * @Route("/kingdom-weather-description", methods={"POST"})
  1075.      */
  1076.     public function kingdomWeatherDirect(Request $request): JsonResponse
  1077.     {
  1078.         try {
  1079.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1080.             if ($response['success'] !== true) {
  1081.                 return $this->json($response);
  1082.             }
  1084.             // get request params
  1085.             $params = json_decode($request->getContent(), true);
  1087.             // set locale
  1088.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1090.             return $this->json($this->ncmWeatherApiService->getKingdomWeatherData());
  1091.         } catch (\Exception $ex) {
  1092.             $this->logger->error($ex->getMessage());
  1093.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1094.         }
  1095.     }
  1097.     /**
  1098.      * @Route("/get-hijri-date", name="api_ncm_device_get_hijri_date", methods={"POST"})
  1099.      */
  1100.     public function getHijriDatetime(Request $request): Response
  1101.     {
  1103.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1104.         if ($response['success'] !== true) {
  1105.             return $this->json($response);
  1106.         }
  1107.         $params = json_decode($request->getContent(), true);
  1108.         if (isset($params['location']) && isset($params['rawOffset'])) {
  1109.             $offset = $params['rawOffset'] / 3600;
  1110.             $locations = $params['location'];
  1111.             $parameters = ["sunset:sql"];
  1112.             // Join the locations and parameters strings with ',' for the URL
  1113.             $parameterString = $parameters;
  1114.             $locationString = implode('+', $locations);
  1116.             // Create a DateTime object
  1117.             $date = new DateTime();
  1118.             $dateStrings = [];
  1120.             // Format the DateTime object as a string and add it to the array
  1121.             for ($i = 0; $i < count($locations); $i++) {
  1122.                 $dateStrings[] = $date->format(DateTime::ISO8601);
  1123.             }
  1125.             // Join the date strings with ',' for the URL
  1126.             $dateString = implode(',', $dateStrings);
  1127.             $response = $this->meteomaticApiService->getRouteQuery(
  1128.                 $dateString,
  1129.                 $parameterString,
  1130.                 $locationString
  1131.             );
  1132.             $sunsetTime = "";
  1133.             if ($response['success'] == true) {
  1134.                 $sunsetTime = $response['data']['data'][0]['parameters'][0]['value'];
  1135.                 $response = \App\Lib\Utility::getHijriDatetime($sunsetTime, $offset);
  1136.             }
  1137.         } else {
  1138.             $response = \App\Lib\Utility::getHijriDatetime();
  1139.         }
  1141.         return $this->json(["success" => true, "date" => $response]);
  1142.     }
  1144.     /**
  1145.      * @Route("/get-isolines", methods={"GET"})
  1146.      */
  1147.     public function getIsolinesAction(Request $request): JsonResponse
  1148.     {
  1149.         try {
  1150.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1151.             if ($response['success'] !== true) {
  1152.                 return $this->json($response);
  1153.             }
  1156.             // Get access token
  1158.             $tokenResult = $this->meteomaticApiService->getToken();
  1159.             if (!isset($tokenResult['access_token'])) {
  1160.                 throw new \RuntimeException("Failed to retrieve access token");
  1161.             }
  1162.             $accessToken = $tokenResult['access_token'];
  1165.             $measure = $request->get('measure');
  1166.             $dateTime = $request->get('date_time');
  1167.             $accessToken = $accessToken;
  1170.             if (!$measure) {
  1171.                 throw new \InvalidArgumentException("Missing mandatory parameter: measure");
  1172.             }
  1174.             if (!$dateTime) {
  1175.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  1176.             }
  1177.             if (!$accessToken) {
  1178.                 throw new \InvalidArgumentException("Missing mandatory parameter: access_token");
  1179.             }
  1181.             $result = $this->meteomaticsWeatherService->getIsolines($measure, $dateTime, $accessToken);
  1182.             return $this->json($result);
  1183.         } catch (\Exception $ex) {
  1184.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1185.         }
  1186.     }
  1189.      /**
  1190.      * @Route("/view-ews-notification", methods={"POST"})
  1191.      */
  1192.     public function detailEwsNotificationAction(Request $request): JsonResponse
  1193.     {
  1194.         try {
  1196.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1197.             if ($response['success'] !== true) {
  1198.                 return $this->json($response);
  1199.             }
  1200.             $params = json_decode($request->getContent(), true);
  1201.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1203.             if (!isset($params['id'])) {
  1204.                 return $this->json(['success' => false, 'message' => $this->translator->trans('EWS Alert ID must be provided to proceed.')]);
  1205.             }
  1206.             if (is_array($params['id'])) {
  1207.                 $ids = array_values(array_filter($params['id'], static function ($v) {
  1208.                     return $v !== null && $v !== '' && $v !== false;
  1209.                 }));
  1210.                 if ($ids === []) {
  1211.                     return $this->json(['success' => false, 'message' => $this->translator->trans('EWS Alert ID must be provided to proceed.')]);
  1212.                 }
  1213.             } elseif ($params['id'] === '' || $params['id'] === null) {
  1214.                 return $this->json(['success' => false, 'message' => $this->translator->trans('EWS Alert ID must be provided to proceed.')]);
  1215.             }
  1216.             $result = $this->ewsNotificationModel->viewNotification($params,  $this->translator);
  1217.             return $this->json($result);
  1218.         } catch (\Exception $ex) {
  1219.             $this->logger->error($ex->getMessage());
  1220.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1221.         }
  1222.     }
  1223.     /**
  1224.      * @Route("/search-ews-notification-by-region", methods={"POST"})
  1225.      */
  1226.     public function searchEwsNotificationByRegionAction(Request $request): JsonResponse
  1227.     {
  1228.         try {
  1229.             
  1230.             // $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1231.             // if ($response['success'] !== true) {
  1232.             //     return $this->json($response);
  1233.             // }
  1234.             $params = json_decode($request->getContent(), true);
  1235.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1236.             if (!isset($params['region_id'])) {
  1237.                 return $this->json(['success' => false, 'message' => $this->translator->trans('Region ID must be provided to proceed.')]);
  1238.             }
  1239.             $regionId = $params['region_id'];
  1240.             $result = $this->ewsNotificationModel->searchEwsNotificationByRegion($regionId, $this->translator);
  1241.             return $this->json($result);
  1242.         } catch (\Exception $ex) {
  1243.             $this->logger->error($ex->getMessage());
  1244.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1245.         }
  1246.     }
  1247. }