src/Service/MeteomaticsWeatherService.php line 1819

Open in your IDE?
  1. <?php
  3. namespace App\Service;
  5. use PDO;
  6. use DateTime;
  7. use GuzzleHttp;
  8. use GuzzleHttp\Client;
  9. use GuzzleHttp\Exception;
  10. use App\Lib\ExcelGenerator;
  11. use App\Service\RedisCache;
  12. use Pimcore\Model\DataObject\Report;
  13. use GuzzleHttp\Exception\RequestException;
  14. use Symfony\Component\HttpFoundation\Response;
  16. class MeteomaticsWeatherService
  17. {
  18. private $apiBaseUrl = MATEOMATICS_API_URL;
  19. private $username;
  20. private $password;
  21. private $redisCache;
  23. public function __construct(RedisCache $redisCache)
  24. {
  25. $this->username = MATEOMATICS_API_USERNAME;
  26. $this->password = MATEOMATICS_API_PASSWORD;
  27. $this->redisCache = $redisCache;
  28. }
  30. /**
  31. * Query Meteomatics API for time series data and return the parsed response
  32. *
  33. * @param DateTime $startDate The start date of the time series data
  34. * @param DateTime $endDate The end date of the time series data
  35. * @param string $resolution The time resolution of the data (e.g. PT1H for hourly data)
  36. * @param float $lat The latitude of the location to query data for
  37. * @param float $lon The longitude of the location to query data for
  38. * @param int $hour The number of hours ahead to forecast (e.g. 1 for one hour ahead)
  39. * @param string $format The format to request the data in (e.g. json)
  40. * @return array The parsed response data
  41. */
  42. public function timeSeriesQueryMeteocache(DateTime $startDate, DateTime $endDate, $resolution, $lat, $lon, $hour, $format)
  43. {
  44. try {
  45. $startDateStr = $startDate->format(DateTime::ISO8601);
  46. $endDateStr = $endDate->format(DateTime::ISO8601);
  47. $parameters = [
  48. 'wind_speed_10m:kmh',
  49. 'wind_dir_10m:d',
  50. 't_2m:C',
  51. 'precip_3h:mm',
  52. 'weather_symbol_' . $hour . 'h:idx',
  53. 'precip_type:idx',
  54. 'sunrise:sql'
  55. ];
  56. $parametersStr = implode(',', $parameters);
  58. // Create unique Redis key
  59. $keyParams = [
  60. $startDate->format(DateTime::ISO8601),
  61. $endDate->format(DateTime::ISO8601),
  62. $resolution,
  63. $lat,
  64. $lon,
  65. $hour,
  66. $format
  67. ];
  68. $redisKey = hash('sha256', implode('_', $keyParams));
  70. // Try to get the weather forecast data from Redis cache
  71. $data = $this->redisCache->get($redisKey);
  73. if (!$data) {
  74. $url = "{$this->apiBaseUrl}/{$startDateStr}--{$endDateStr}:{$resolution}/{$parametersStr}/{$lat},{$lon}/" . $format;
  76. //echo $url;exit;
  77. $client = new Client(['verify' => false]);
  78. $response = $client->request('GET', $url, [
  79. 'auth' => [$this->username, $this->password],
  80. 'connect_timeout' => 2,
  81. 'headers' => [
  82. 'User-Agent' => 'Meteomatics PHP connector (Guzzle)'
  83. ]
  84. ]);
  86. $statusCode = $response->getStatusCode();
  87. $data = json_decode($response->getBody(), true);
  89. if ($statusCode != 200) {
  90. return $this->createErrorResponse($statusCode);
  91. }
  93. $parsedData = array();
  94. if (isset($data['data']) && $format == "json") {
  95. foreach ($data['data'] as $item) {
  96. $parameter = $item["parameter"];
  97. $coordinates = $item["coordinates"];
  98. $lat = $coordinates[0]["lat"];
  99. $lon = $coordinates[0]["lon"];
  100. $dates = $coordinates[0]["dates"];
  101. $groupedDates = array();
  102. foreach ($dates as $date) {
  103. $dateTime = new DateTime($date["date"]);
  104. $dateString = $dateTime->format("Y-m-d");
  105. if (!array_key_exists($dateString, $groupedDates)) {
  106. $groupedDates[$dateString] = array();
  107. }
  108. $groupedDates[$dateString][] = $date["value"];
  109. }
  110. $parsedData[$parameter] = array("coordinates" => array("lat" => $lat, "lon" => $lon), "dates" => $groupedDates);
  111. }
  112. } else {
  113. $parsedData = $data;
  114. }
  116. if ($parsedData) {
  117. $this->redisCache->set($redisKey, $parsedData, 86400);
  118. }
  119. } else {
  120. $parsedData = $data;
  121. }
  123. return $parsedData;
  124. } catch (Exception\RequestException $e) {
  125. return throw new \Exception($e->getMessage());
  126. } catch (\Exception $e) {
  127. return throw new \Exception($e->getMessage());
  128. }
  129. }
  131. public function createErrorResponse(int $http_code): Response
  132. {
  133. switch ($http_code) {
  134. case 100:
  135. $text = 'Continue';
  136. break;
  137. case 101:
  138. $text = 'Switching Protocols';
  139. break;
  140. case 200:
  141. $text = 'OK';
  142. break;
  143. case 201:
  144. $text = 'Created';
  145. break;
  146. case 202:
  147. $text = 'Accepted';
  148. break;
  149. case 203:
  150. $text = 'Non-Authoritative Information';
  151. break;
  152. case 204:
  153. $text = 'No Content';
  154. break;
  155. case 205:
  156. $text = 'Reset Content';
  157. break;
  158. case 206:
  159. $text = 'Partial Content';
  160. break;
  161. case 300:
  162. $text = 'Multiple Choices';
  163. break;
  164. case 301:
  165. $text = 'Moved Permanently';
  166. break;
  167. case 302:
  168. $text = 'Moved Temporarily';
  169. break;
  170. case 303:
  171. $text = 'See Other';
  172. break;
  173. case 304:
  174. $text = 'Not Modified';
  175. break;
  176. case 305:
  177. $text = 'Use Proxy';
  178. break;
  179. case 400:
  180. $text = 'Bad Request';
  181. break;
  182. case 401:
  183. $text = 'Unauthorized';
  184. break;
  185. case 402:
  186. $text = 'Payment Required';
  187. break;
  188. case 403:
  189. $text = 'Forbidden';
  190. break;
  191. case 404:
  192. $text = 'Not Found';
  193. break;
  194. case 405:
  195. $text = 'Method Not Allowed';
  196. break;
  197. case 406:
  198. $text = 'Not Acceptable';
  199. break;
  200. case 407:
  201. $text = 'Proxy Authentication Required';
  202. break;
  203. case 408:
  204. $text = 'Request Time-out';
  205. break;
  206. case 409:
  207. $text = 'Conflict';
  208. break;
  209. case 410:
  210. $text = 'Gone';
  211. break;
  212. case 411:
  213. $text = 'Length Required';
  214. break;
  215. case 412:
  216. $text = 'Precondition Failed';
  217. break;
  218. case 413:
  219. $text = 'Request Entities Too Large';
  220. break;
  221. case 414:
  222. $text = 'Request-URI Too Large';
  223. break;
  224. case 415:
  225. $text = 'Unsupported Media Type';
  226. break;
  227. case 500:
  228. $text = 'Internal Server Error';
  229. break;
  230. case 501:
  231. $text = 'Not Implemented';
  232. break;
  233. case 502:
  234. $text = 'Bad Gateway';
  235. break;
  236. case 503:
  237. $text = 'Service Unavailable';
  238. break;
  239. case 504:
  240. $text = 'Gateway Time-out';
  241. break;
  242. case 505:
  243. $text = 'HTTP Version not supported';
  244. break;
  245. default:
  246. $text = 'Unknown http status code';
  247. break;
  248. }
  250. $response = new Response();
  251. $response->setContent($text);
  252. $response->setStatusCode($http_code);
  253. $response->headers->set('Content-Type', 'text/plain');
  255. return $response;
  256. }
  258. /**
  259. * Fetches the weather forecast data for a given latitude, longitude, and for selected data range
  260. *
  261. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  262. * @param int $days The number of days for which forecast is required
  263. * @return array|null The weather forecast data in JSON format, or null if there was an error
  264. */
  265. public function getTempratureByParams(array $coordinates, string $startDate, string $endDate, string $parametersStr, int $hour = 1)
  266. {
  267. try {
  269. if (count($coordinates) > 1) {
  271. // Validate the input parameters
  272. foreach ($coordinates as $coordinate) {
  273. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  274. throw new \InvalidArgumentException('Invalid coordinates');
  275. }
  276. }
  279. if (empty($startDate) || empty($endDate)) {
  280. throw new \InvalidArgumentException('Invalid dates');
  281. }
  283. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  284. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  286. // Create a Redis key for the cache
  287. $cacheKey = sprintf('custom_noti_%s_%s_%s', md5(implode('_', array_map(function ($coordinate) {
  288. return implode('_', $coordinate);
  289. }, $coordinates))), ($startDate . '-' . $endDate), $parametersStr . $hour);
  291. // Try to get the data from Redis cache
  292. $cachedData = $this->redisCache->get($cacheKey);
  295. if ($cachedData !== null) {
  296. // Return the cached data if available
  297. return $cachedData;
  298. }
  301. // If cache is empty, get the data from the API
  302. $client = new Client(['verify' => false]);
  305. // $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  307. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  308. // p_r($coordinateString); // Debug
  310. $url = sprintf(
  311. '%s/%s--%s:PT%sH/%s/%s/json',
  312. $this->apiBaseUrl,
  313. $startDate,
  314. $endDate,
  315. $hour,
  316. $parametersStr,
  317. $coordinateString
  318. );
  319. } else {
  321. //p_R($coordinates);
  322. if ($coordinates) {
  323. $latitude = $coordinates[0][0];
  324. $longitude = $coordinates[0][1];
  325. }
  327. // Validate the input parameters
  328. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  329. throw new \InvalidArgumentException('Invalid latitude');
  330. }
  331. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  332. throw new \InvalidArgumentException('Invalid longitude');
  333. }
  335. if (empty($startDate) || empty($endDate)) {
  336. throw new \InvalidArgumentException('Invalid dates');
  337. }
  339. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  340. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  342. // Create a Redis key for the cache
  343. $cacheKey = sprintf('custom_noti_%s_%s_%s', md5(implode('_', array_map(function ($coordinate) {
  344. return implode('_', $coordinate);
  345. }, $coordinates))), ($startDate . '-' . $endDate), $parametersStr . $hour);
  348. // Try to get the data from Redis cache
  349. $cachedData = $this->redisCache->get($cacheKey);
  351. if ($cachedData !== null) {
  352. // Return the cached data if available
  353. //return $cachedData;
  354. }
  356. // If cache is empty, get the data from the API
  357. $client = new Client(['verify' => false]);
  358. $url = sprintf(
  359. '%s/%s--%s:PT%sH/%s/%s,%s/json',
  360. $this->apiBaseUrl,
  361. $startDate,
  362. $endDate,
  363. $hour,
  364. $parametersStr,
  365. $latitude,
  366. $longitude
  367. );
  369. //p_r($url);
  370. }
  372. $response = $client->request('GET', $url, [
  373. 'auth' => [$this->username, $this->password],
  374. ]);
  376. $statusCode = $response->getStatusCode();
  377. $data = json_decode($response->getBody(), true);
  379. // Set the data to Redis cache
  380. $this->redisCache->set($cacheKey, $data);
  382. return $data;
  383. } catch (GuzzleHttp\Exception\RequestException $e) {
  384. return throw new \Exception($e->getMessage());
  385. } catch (\Exception $e) {
  386. return throw new \Exception($e->getMessage());
  387. }
  388. }
  391. /**
  392. * Fetches the weather forecast data for a given latitude, longitude, and for selected data range
  393. *
  394. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  395. * @param int $days The number of days for which forecast is required
  396. * @return array|null The weather forecast data in JSON format, or null if there was an error
  397. */
  398. public function getForecastData(array $coordinates, string $startDate, string $endDate, int $hours, string $model = "ksancm-wrf-48", $translator)
  399. {
  400. try {
  402. // Set timezone to Saudi (UTC+3)
  403. $timezone = new \DateTimeZone('Asia/Riyadh');
  404. if (count($coordinates) > 1) {
  405. // Validate the input parameters
  406. foreach ($coordinates as $coordinate) {
  407. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  408. // throw new \InvalidArgumentException('Invalid coordinates');
  409. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  410. }
  411. }
  412. if (empty($startDate) || empty($endDate)) {
  413. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  414. // throw new \InvalidArgumentException('Invalid dates');
  415. }
  416. if ($hours < 1 and $hours > 24) {
  417. throw new \InvalidArgumentException('Invalid hour');
  418. }
  419. // $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  420. // $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  422. // // Adjust the date range based on the hours parameter
  423. // if ($hours == 24) {
  424. // $startDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 day'));
  425. // $endDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 day'));
  426. // } elseif ($hours == 1) {
  427. // $startDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 hour'));
  428. // $endDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 hour'));
  429. // }
  431. // Convert dates to Saudi timezone
  432. $startDateObj = new \DateTime($startDate, $timezone);
  433. $endDateObj = new \DateTime($endDate, $timezone);
  434. // Subtract 3 hours from each date
  435. $startDateObj->modify('-3 hours');
  436. $endDateObj->modify('-3 hours');
  437. $startDate = $startDateObj->format('Y-m-d\TH:i:s.v\Z');
  438. $endDate = $endDateObj->format('Y-m-d\TH:i:s.v\Z');
  440. // Adjust date range based on the hours parameter
  441. $startDateNew = clone $startDateObj;
  442. $endDateNew = clone $endDateObj;
  444. if ($hours == 24) {
  445. $startDateNew->modify('+1 day');
  446. $endDateNew->modify('+1 day');
  447. } elseif ($hours == 1) {
  448. $startDateNew->modify('+1 hour');
  449. $endDateNew->modify('+1 hour');
  450. }
  453. $startDateNew = $startDateNew->format('Y-m-d\TH:i:s.v\Z');
  454. $endDateNew = $endDateNew->format('Y-m-d\TH:i:s.v\Z');
  456. // Create a Redis key for the cache
  457. $cacheKey = sprintf('daily_forecast_%s_%s', implode('_', array_map(function ($coordinate) {
  458. return implode('_', $coordinate);
  459. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model . $hours);
  460. // Try to get the data from Redis cache
  461. $cachedData = $this->redisCache->get($cacheKey);
  462. if ($cachedData !== null) {
  463. // Return the cached data if available
  464. return $cachedData;
  465. }
  466. // If cache is empty, get the data from the API
  467. $client = new Client(['verify' => false]);
  469. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  470. $url1 = sprintf(
  471. '%s/%s--%s:PT%sH/t_max_2m_%sh:C,t_min_2m_%sh:C,t_apparent_min_%sh:C,t_apparent_max_%sh:C/%s/json?model=' . $model,
  472. $this->apiBaseUrl,
  473. $startDateNew,
  474. $endDateNew,
  475. $hours,
  476. $hours,
  477. $hours,
  478. $hours,
  479. $hours,
  480. $coordinateString
  481. );
  482. $url2 = sprintf(
  483. '%s/%s--%s:PT%sH/wind_speed_mean_10m_%sh:kmh,wind_dir_mean_10m_%sh:d,prob_precip_%sh:p,precip_%sh:mm,relative_humidity_mean_2m_%sh:p,effective_cloud_cover_mean_%sh:octas,dew_point_mean_2m_%sh:C,wind_gusts_10m_%sh:kmh/%s/json?model=' . $model,
  484. $this->apiBaseUrl,
  485. $startDateNew,
  486. $endDateNew,
  487. $hours,
  488. $hours,
  489. $hours,
  490. $hours,
  491. $hours,
  492. $hours,
  493. $hours,
  494. $hours,
  495. $hours,
  496. $coordinateString
  497. );
  498. $url3 = sprintf(
  499. '%s/%s--%s:PT%sH/t_2m:C,visibility:km/%s/json?model=mix',
  500. $this->apiBaseUrl,
  501. $startDate,
  502. $endDate,
  503. $hours,
  504. $coordinateString
  505. );
  506. $url4 = sprintf(
  507. '%s/%s--%s:PT10M/t_2m:C/%s/json?model=' . $model,
  508. $this->apiBaseUrl,
  509. $startDate,
  510. $endDate,
  511. $coordinateString
  512. );
  513. $url5 = sprintf(
  514. '%s/%s--%s:PT3H/precip_3h:mm,prob_precip_3h:p/%s/json?model=' . $model,
  515. $this->apiBaseUrl,
  516. $startDate,
  517. $endDate,
  518. $coordinateString
  519. );
  520. $url6 = sprintf(
  521. '%s/%s--%s:PT6H/precip_6h:mm,prob_precip_6h:p/%s/json?model=' . $model,
  522. $this->apiBaseUrl,
  523. $startDate,
  524. $endDate,
  525. $coordinateString
  526. );
  527. } else {
  528. if ($coordinates) {
  529. $latitude = $coordinates[0][0];
  530. $longitude = $coordinates[0][1];
  531. }
  532. // Validate the input parameters
  533. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  534. // throw new \InvalidArgumentException('Invalid latitude');
  535. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  536. }
  537. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  538. // throw new \InvalidArgumentException('Invalid longitude');
  539. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  540. }
  541. if (empty($startDate) || empty($endDate)) {
  542. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  543. }
  544. if ($hours < 1 and $hours > 24) {
  545. throw new \InvalidArgumentException('Invalid hour');
  546. }
  547. // $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  548. // $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  550. // // Adjust the date range based on the hours parameter
  551. // if ($hours == 24) {
  552. // $startDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 day'));
  553. // $endDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 day'));
  554. // } elseif ($hours == 1) {
  555. // $startDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 hour'));
  556. // $endDateNew = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 hour'));
  557. // }
  559. // Convert dates to Saudi timezone
  560. $startDateObj = new \DateTime($startDate, $timezone);
  561. $endDateObj = new \DateTime($endDate, $timezone);
  562. // Subtract 3 hours from each date
  563. $startDateObj->modify('-3 hours');
  564. $endDateObj->modify('-3 hours');
  565. $startDate = $startDateObj->format('Y-m-d\TH:i:s.v\Z');
  566. $endDate = $endDateObj->format('Y-m-d\TH:i:s.v\Z');
  568. // Adjust date range based on the hours parameter
  569. $startDateNew = clone $startDateObj;
  570. $endDateNew = clone $endDateObj;
  572. if ($hours == 24) {
  573. $startDateNew->modify('+1 day');
  574. $endDateNew->modify('+1 day');
  575. } elseif ($hours == 1) {
  576. $startDateNew->modify('+1 hour');
  577. $endDateNew->modify('+1 hour');
  578. }
  581. $startDateNew = $startDateNew->format('Y-m-d\TH:i:s.v\Z');
  582. $endDateNew = $endDateNew->format('Y-m-d\TH:i:s.v\Z');
  583. // Create a Redis key for the cache
  584. $cacheKey = sprintf('daily_forecast_%s_%s', implode('_', array_map(function ($coordinate) {
  585. return implode('_', $coordinate);
  586. }, $coordinates)), ($startDate . '-' . $endDate) . $model . $hours);
  587. // Try to get the data from Redis cache
  588. $cachedData = $this->redisCache->get($cacheKey);
  589. if ($cachedData !== null) {
  590. // Return the cached data if available
  591. return $cachedData;
  592. }
  593. // If cache is empty, get the data from the API
  594. $client = new Client(['verify' => false]);
  595. $url1 = sprintf(
  596. '%s/%s--%s:PT%sH/t_max_2m_%sh:C,t_min_2m_%sh:C,t_apparent_min_%sh:C,t_apparent_max_%sh:C/%s,%s/json?model=' . $model,
  597. $this->apiBaseUrl,
  598. $startDateNew,
  599. $endDateNew,
  600. $hours,
  601. $hours,
  602. $hours,
  603. $hours,
  604. $hours,
  605. $latitude,
  606. $longitude
  607. );
  608. $url2 = sprintf(
  609. '%s/%s--%s:PT%sH/wind_speed_mean_10m_%sh:kmh,wind_dir_mean_10m_%sh:d,prob_precip_%sh:p,precip_%sh:mm,relative_humidity_mean_2m_%sh:p,effective_cloud_cover_mean_%sh:octas,dew_point_mean_2m_%sh:C,wind_gusts_10m_%sh:kmh/%s,%s/json?model=' . $model,
  610. $this->apiBaseUrl,
  611. $startDateNew,
  613. $endDateNew,
  614. $hours,
  615. $hours,
  616. $hours,
  617. $hours,
  618. $hours,
  619. $hours,
  620. $hours,
  621. $hours,
  622. $hours,
  623. $latitude,
  624. $longitude
  625. );
  626. $url3 = sprintf(
  627. '%s/%s--%s:PT%sH/t_2m:C,visibility:km/%s,%s/json?model=mix',
  628. $this->apiBaseUrl,
  629. $startDate,
  630. $endDate,
  631. $hours,
  632. $latitude,
  633. $longitude
  634. );
  635. $url4 = sprintf(
  636. '%s/%s--%s:PT10M/t_2m:C/%s,%s/json?model=' . $model,
  637. $this->apiBaseUrl,
  638. $startDate,
  639. $endDate,
  640. $latitude,
  641. $longitude
  642. );
  643. $url5 = sprintf(
  644. '%s/%s--%s:PT3H/precip_3h:mm,prob_precip_3h:p/%s,%s/json?model=' . $model,
  645. $this->apiBaseUrl,
  646. $startDate,
  647. $endDate,
  648. $latitude,
  649. $longitude
  650. );
  651. $url6 = sprintf(
  652. '%s/%s--%s:PT6H/precip_6h:mm,prob_precip_6h:p/%s,%s/json?model=' . $model,
  653. $this->apiBaseUrl,
  654. $startDate,
  655. $endDate,
  656. $latitude,
  657. $longitude
  658. );
  659. }
  660. $response = $client->request('GET', $url1, [
  661. 'auth' => [$this->username, $this->password],
  662. ]);
  663. $statusCode = $response->getStatusCode();
  664. $data1 = json_decode($response->getBody(), true);
  667. // Adjust the dates in the response data
  668. $this->adjustResponseDates($data1['data'], $hours);
  670. $response = $client->request('GET', $url2, [
  671. 'auth' => [$this->username, $this->password],
  672. ]);
  673. $statusCode = $response->getStatusCode();
  674. $data2 = json_decode($response->getBody(), true);
  675. $this->adjustResponseDates($data2['data'], $hours);
  676. $response = $client->request('GET', $url3, [
  677. 'auth' => [$this->username, $this->password],
  678. ]);
  679. $statusCode = $response->getStatusCode();
  680. $data3 = json_decode($response->getBody(), true);
  681. $response = $client->request('GET', $url4, [
  682. 'auth' => [$this->username, $this->password],
  683. ]);
  684. $statusCode = $response->getStatusCode();
  685. $data4 = json_decode($response->getBody(), true);
  687. $response = $client->request('GET', $url5, [
  688. 'auth' => [$this->username, $this->password],
  689. ]);
  690. $statusCode = $response->getStatusCode();
  691. $data5 = json_decode($response->getBody(), true);
  693. $response = $client->request('GET', $url6, [
  694. 'auth' => [$this->username, $this->password],
  695. ]);
  696. $statusCode = $response->getStatusCode();
  697. $data6 = json_decode($response->getBody(), true);
  699. $dataFinal = $data1;
  700. $dataFinal['data'] = array_merge($data6['data'], $data5['data'], $data4['data'], $data1['data'], $data2['data'], $data3['data']);
  701. $weatherSymbols = $this->getWeatherSymbols($coordinates, $startDate, $endDate, 'PT' . $hours . 'H', $hours . 'h', true);
  702. if (isset($weatherSymbols['data'][0]['parameter'])) {
  703. $dataFinal['symbols'] = $weatherSymbols['data'][0];
  704. }
  705. // Set the data to Redis cache
  706. $this->redisCache->set($cacheKey, $dataFinal);
  707. return $dataFinal;
  708. } catch (GuzzleHttp\Exception\RequestException $e) {
  709. return throw new \Exception($e->getMessage());
  710. } catch (\Exception $e) {
  711. return throw new \Exception($e->getMessage());
  712. }
  713. }
  716. /**
  717. * Fetches the hourly weather forecast data for a given latitude, longitude, and hour
  718. *
  719. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  720. * @param string $hourly The hour for which forecast is required in 24-hour format
  721. * @return array The hourly weather forecast data in JSON format
  722. */
  723. public function getHourlyForecastData(array $coordinates, string $startDate, string $endDate, int $hour, string $model, $translator)
  724. {
  725. try {
  726. if (count($coordinates) > 1) {
  728. // Validate the input parameters
  729. foreach ($coordinates as $coordinate) {
  730. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  731. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  732. }
  733. }
  735. if (empty($startDate) || empty($endDate)) {
  736. // throw new \InvalidArgumentException('Invalid dates');
  737. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  738. }
  740. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  741. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  743. // Create a Redis key for the cache
  744. $cacheKey = sprintf('hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  745. return implode('_', $coordinate);
  746. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, $hour);
  749. // Try to get the data from Redis cache
  750. $cachedData = $this->redisCache->get($cacheKey);
  753. if ($cachedData !== null) {
  754. // Return the cached data if available
  755. return $cachedData;
  756. }
  759. // If cache is empty, get the data from the API
  760. $client = new Client(['verify' => false]);
  762. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  763. $url1 = sprintf(
  764. '%s/%s--%s:PT%sH/t_max_2m_1h:C,t_min_2m_1h:C,t_apparent_min_1h:C,t_apparent_max_1h:C/%+%/json?model=' . $model,
  765. $this->apiBaseUrl,
  766. $startDate,
  767. $endDate,
  768. $hour,
  769. $coordinateString,
  770. $coordinateString
  771. );
  772. $url2 = sprintf(
  773. '%s/%s--%s:PT%sH/wind_speed_mean_10m_1h:kmh,wind_dir_mean_10m_1h:d,prob_precip_1h:p,precip_1h:mm,relative_humidity_mean_2m_1h:p,visibility:km,effective_cloud_cover_mean_1h:octas,dew_point_mean_2m_1h:C,wind_gusts_10m_1h:kmh/%+%/json?model=' . $model,
  774. $this->apiBaseUrl,
  775. $startDate,
  776. $endDate,
  777. $hour,
  778. $coordinateString,
  779. $coordinateString
  780. );
  781. } else {
  783. if ($coordinates) {
  784. $latitude = $coordinates[0][0];
  785. $longitude = $coordinates[0][1];
  786. }
  788. // Validate the input parameters
  789. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  790. // throw new \InvalidArgumentException('Invalid latitude');
  791. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  792. }
  793. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  794. // throw new \InvalidArgumentException('Invalid longitude');
  795. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  796. }
  798. if (empty($startDate) || empty($endDate)) {
  799. // throw new \InvalidArgumentException('Invalid dates');
  800. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  801. }
  803. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  804. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  806. // Create a Redis key for the cache
  807. $cacheKey = sprintf('hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  808. return implode('_', $coordinate);
  809. }, $coordinates)), ($startDate . '-' . $endDate) . $model, $hour);
  811. // Try to get the data from Redis cache
  812. $cachedData = $this->redisCache->get($cacheKey);
  814. if ($cachedData !== null) {
  815. // Return the cached data if available
  816. return $cachedData;
  817. }
  819. // If cache is empty, get the data from the API
  820. $client = new Client(['verify' => false]);
  821. $url1 = sprintf(
  822. '%s/%s--%s:PT%sH/t_max_2m_1h:C,t_min_2m_1h:C,t_apparent_min_1h:C,t_apparent_max_1h:C/%s,%s/json?model=' . $model,
  823. $this->apiBaseUrl,
  824. $startDate,
  825. $endDate,
  826. $hour,
  827. $latitude,
  828. $longitude
  829. );
  830. $url2 = sprintf(
  831. '%s/%s--%s:PT%sH/wind_speed_mean_10m_1h:kmh,wind_dir_mean_10m_1h:d,prob_precip_1h:p,precip_1h:mm,relative_humidity_mean_2m_1h:p,visibility:km,effective_cloud_cover_mean_1h:octas,dew_point_mean_2m_1h:C,wind_gusts_10m_1h:kmh/%s,%s/json?model=' . $model,
  832. $this->apiBaseUrl,
  833. $startDate,
  834. $endDate,
  835. $hour,
  836. $latitude,
  837. $longitude
  838. );
  839. }
  841. $response = $client->request('GET', $url1, [
  842. 'auth' => [$this->username, $this->password],
  843. ]);
  845. $statusCode = $response->getStatusCode();
  846. $data1 = json_decode($response->getBody(), true);
  848. $response = $client->request('GET', $url2, [
  849. 'auth' => [$this->username, $this->password],
  850. ]);
  852. $statusCode = $response->getStatusCode();
  853. $data2 = json_decode($response->getBody(), true);
  855. $data3 = $data1;
  856. $data3['data'] = array_merge($data1['data'], $data2['data']);
  858. $weatherSymbols = $this->getWeatherSymbols($coordinates, $startDate, $endDate, 'PT1H', '1h');
  860. if (isset($weatherSymbols['data'][0]['parameter'])) {
  861. $data3['symbols'] = $weatherSymbols['data'][0];
  862. }
  864. // Set the data to Redis cache
  865. $this->redisCache->set($cacheKey, $data3);
  867. return $data3;
  868. } catch (GuzzleHttp\Exception\RequestException $e) {
  869. return throw new \Exception($e->getMessage());
  870. } catch (\Exception $e) {
  871. return throw new \Exception($e->getMessage());
  872. }
  873. }
  876. /**
  877. * Fetches the hourly weather forecast data for a given latitude, longitude, and hour
  878. *
  879. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  880. * @param string $hourly The hour for which forecast is required in 24-hour format
  881. * @return array The hourly weather forecast data in JSON format
  882. */
  883. public function getForecastDataHistoryHourly(array $coordinates, string $startDate, string $endDate, $translator, int $hour = 1)
  884. {
  885. try {
  886. if (count($coordinates) > 1) {
  888. // Validate the input parameters
  889. foreach ($coordinates as $coordinate) {
  890. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  891. // throw new \InvalidArgumentException('Invalid coordinates');
  892. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  893. }
  894. }
  897. if (empty($startDate) || empty($endDate)) {
  898. // throw new \InvalidArgumentException('Invalid dates');
  899. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  900. }
  902. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  903. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  905. // Create a Redis key for the cache
  906. $cacheKey = sprintf('historical_hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  907. return implode('_', $coordinate);
  908. }, $coordinates)), (($startDate) . '-' . ($endDate)), $hour);
  910. // Try to get the data from Redis cache
  911. $cachedData = $this->redisCache->get($cacheKey);
  914. if ($cachedData !== null) {
  915. // Return the cached data if available
  916. return $cachedData;
  917. }
  920. // If cache is empty, get the data from the API
  921. $client = new Client(['verify' => false]);
  923. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  924. $url1 = sprintf(
  925. '%s/%s--%s:PT%sH/sfc_pressure:hPa,msl_pressure:hPa,dew_point_1000hPa:C,relative_humidity_2m:p,t_max_2m_1h:C,t_min_2m_1h:C,wind_speed_10m:kmh,wind_dir_10m:d,precip_1h:mm/%s+%s/json',
  926. $this->apiBaseUrl,
  927. $startDate,
  928. $endDate,
  929. $hour,
  930. $coordinateString,
  931. $coordinateString
  932. );
  933. $url2 = sprintf(
  934. '%s/%s--%s:PT%sH/effective_cloud_cover:octas,dew_point_2m:C,wind_speed_mean_10m_1h:ms/%s+%s/json',
  935. $this->apiBaseUrl,
  936. $startDate,
  937. $endDate,
  938. $hour,
  939. $coordinateString,
  940. $coordinateString
  941. );
  942. } else {
  944. if ($coordinates) {
  945. $latitude = $coordinates[0][0];
  946. $longitude = $coordinates[0][1];
  947. }
  949. // Validate the input parameters
  950. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  951. // throw new \InvalidArgumentException('Invalid latitude');
  952. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  953. }
  954. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  955. // throw new \InvalidArgumentException('Invalid longitude');
  956. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  957. }
  959. if (empty($startDate) || empty($endDate)) {
  960. // throw new \InvalidArgumentException('Invalid dates');
  961. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  962. }
  964. // 2023-04-06T00:00:00.000Z--2023-04-07T00:00:00.000Z
  965. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  966. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  968. // Create a Redis key for the cache
  969. $cacheKey = sprintf('historical_hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  970. return implode('_', $coordinate);
  971. }, $coordinates)), (($startDate) . '-' . ($endDate)), $hour);
  974. // Try to get the data from Redis cache
  975. $cachedData = $this->redisCache->get($cacheKey);
  977. if ($cachedData !== null) {
  978. // Return the cached data if available
  979. return $cachedData;
  980. }
  982. // If cache is empty, get the data from the API
  983. $client = new Client(['verify' => false]);
  984. $url1 = sprintf(
  985. '%s/%s--%s:PT%sH/sfc_pressure:hPa,msl_pressure:hPa,dew_point_1000hPa:C,relative_humidity_2m:p,t_max_2m_1h:C,t_min_2m_1h:C,wind_speed_10m:kmh,wind_dir_10m:d,precip_1h:mm/%s,%s/json',
  986. $this->apiBaseUrl,
  987. $startDate,
  988. $endDate,
  989. $hour,
  990. $latitude,
  991. $longitude
  992. );
  994. $url2 = sprintf(
  995. '%s/%s--%s:PT%sH/sfc_pressure:hPa,msl_pressure:hPa,dew_point_1000hPa:C,relative_humidity_2m:p,t_max_2m_1h:C,t_min_2m_1h:C,wind_speed_10m:kmh,wind_dir_10m:d,precip_1h:mm/%s,%s/json',
  996. $this->apiBaseUrl,
  997. $startDate,
  998. $endDate,
  999. $hour,
  1000. $latitude,
  1001. $longitude
  1002. );
  1004. //echo $url;exit;
  1006. }
  1007. $response = $client->request('GET', $url1, [
  1008. 'auth' => [$this->username, $this->password],
  1009. ]);
  1011. $statusCode = $response->getStatusCode();
  1012. $data1 = json_decode($response->getBody(), true);
  1014. $response = $client->request('GET', $url2, [
  1015. 'auth' => [$this->username, $this->password],
  1016. ]);
  1018. $statusCode = $response->getStatusCode();
  1019. $data2 = json_decode($response->getBody(), true);
  1021. array_push($data1['data'], $data2['data']);
  1023. $weatherSymbols = $this->getWeatherSymbols($coordinates, $startDate, $endDate, 'PT1H', $hour . 'h');
  1025. if (isset($weatherSymbols['data'][0]['parameter'])) {
  1026. $data1['symbols'] = $weatherSymbols['data'][0];
  1027. }
  1029. // Set the data to Redis cache
  1030. $this->redisCache->set($cacheKey, $data1);
  1032. return $data1;
  1033. } catch (GuzzleHttp\Exception\RequestException $e) {
  1035. //p_r($e->getMessage());exit;
  1036. return throw new \Exception($e->getMessage());
  1037. } catch (\Exception $e) {
  1038. //p_r($e->getMessage());exit;
  1039. return throw new \Exception($e->getMessage());
  1040. }
  1041. }
  1044. /**
  1045. * Compare weather based on mateomatics models
  1046. *
  1047. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1048. * @param string $hourly The hour for which forecast is required in 24-hour format
  1049. * @return array The hourly weather forecast data in JSON format
  1050. */
  1051. public function getCompareParameters(array $coordinates, string $startDate, string $endDate, string $model, string $tempParam, string $timeDuration = "P1H", $translator)
  1052. {
  1053. try {
  1055. if (count($coordinates) > 1) {
  1057. // Validate the input parameters
  1058. foreach ($coordinates as $coordinate) {
  1059. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  1060. // throw new \InvalidArgumentException('Invalid coordinates');
  1061. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  1062. }
  1063. }
  1066. if (empty($startDate) || empty($endDate)) {
  1067. // throw new \InvalidArgumentException('Invalid dates');
  1068. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  1069. }
  1071. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1072. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1074. // Create a Redis key for the cache
  1075. $cacheKey = sprintf('compare_model_%s_%s_' . $model . '_' . $tempParam, implode('_', array_map(function ($coordinate) {
  1076. return implode('_', $coordinate);
  1077. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $timeDuration);
  1079. // Try to get the data from Redis cache
  1080. $cachedData = $this->redisCache->get($cacheKey);
  1083. if ($cachedData !== null) {
  1084. // Return the cached data if available
  1085. return $cachedData;
  1086. }
  1089. // If cache is empty, get the data from the API
  1090. $client = new Client(['verify' => false]);
  1093. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  1094. $url = sprintf(
  1095. '%s/%s--%s:%s/%s/%+%/json?model=' . $model,
  1096. $this->apiBaseUrl,
  1097. $startDate,
  1098. $endDate,
  1099. $timeDuration,
  1100. $tempParam,
  1101. $coordinateString,
  1102. $coordinateString
  1103. );
  1104. } else {
  1106. if ($coordinates) {
  1107. $latitude = $coordinates[0][0];
  1108. $longitude = $coordinates[0][1];
  1109. }
  1111. // Validate the input parameters
  1112. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  1113. // throw new \InvalidArgumentException('Invalid latitude');
  1114. return ["success" => true, "message" => $translator->trans("invalid_latitude")];
  1115. }
  1116. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  1117. // throw new \InvalidArgumentException('Invalid longitude');
  1118. return ["success" => true, "message" => $translator->trans("invalid_longitude")];
  1119. }
  1121. if (empty($startDate) || empty($endDate)) {
  1122. // throw new \InvalidArgumentException('Invalid dates');
  1123. return ["success" => true, "message" => $translator->trans("invalid_dates")];
  1124. }
  1126. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1127. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1129. // Create a Redis key for the cache
  1130. $cacheKey = sprintf('compare_model_%s_%s_' . $model . '_' . $tempParam, implode('_', array_map(function ($coordinate) {
  1131. return implode('_', $coordinate);
  1132. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $timeDuration);
  1135. // Try to get the data from Redis cache
  1136. $cachedData = $this->redisCache->get($cacheKey);
  1138. if ($cachedData !== null) {
  1139. // Return the cached data if available
  1140. return $cachedData;
  1141. }
  1143. // If cache is empty, get the data from the API
  1144. $client = new Client(['verify' => false]);
  1145. $url = sprintf(
  1146. '%s/%s--%s:%s/%s/%s,%s/json?model=' . $model,
  1147. $this->apiBaseUrl,
  1148. $startDate,
  1149. $endDate,
  1150. $timeDuration,
  1151. $tempParam,
  1152. $latitude,
  1153. $longitude
  1154. );
  1155. }
  1157. $response = $client->request('GET', $url, [
  1158. 'auth' => [$this->username, $this->password],
  1159. ]);
  1161. $statusCode = $response->getStatusCode();
  1162. $data = json_decode($response->getBody(), true);
  1164. // Set the data to Redis cache
  1165. $this->redisCache->set($cacheKey, $data);
  1167. return $data;
  1168. } catch (GuzzleHttp\Exception\RequestException $e) {
  1170. return throw new \Exception($e->getMessage());
  1171. } catch (\Exception $e) {
  1172. return throw new \Exception($e->getMessage());
  1173. }
  1174. }
  1177. /**
  1178. * Get forecast data in daily dashboard display for multiple locations
  1179. *
  1180. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1181. * @param int $days The number of days for which forecast is required
  1182. * @return array The model forecast data
  1183. */
  1184. public function getDashboardDailyForecast(array $coordinates, string $startDate, string $endDate)
  1185. {
  1186. try {
  1188. if (count($coordinates) > 1) {
  1190. // Validate the input parameters
  1191. foreach ($coordinates as $coordinate) {
  1192. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  1193. throw new \InvalidArgumentException('Invalid coordinates');
  1194. }
  1195. }
  1198. if (empty($startDate) || empty($endDate)) {
  1199. throw new \InvalidArgumentException('Invalid dates');
  1200. }
  1202. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1203. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1205. // Create a Redis key for the cache
  1206. $cacheKey = sprintf('dashboard_%s_%s', implode('_', array_map(function ($coordinate) {
  1207. return implode('_', $coordinate);
  1208. }, $coordinates)), (($startDate) . '-' . ($endDate)));
  1210. // Try to get the data from Redis cache
  1211. $cachedData = $this->redisCache->get($cacheKey);
  1214. if ($cachedData !== null) {
  1215. // Return the cached data if available
  1216. return $cachedData;
  1217. }
  1220. // If cache is empty, get the data from the API
  1221. $client = new Client(['verify' => false]);
  1224. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  1226. $url = sprintf(
  1227. '%s/%s--%s:P%sD/t_max_2m_24h:C,t_apparent:C,wind_speed_10m:kmh,wind_dir_mean_10m_24h:d,prob_precip_24h:p,precip_24h:mm,sunrise:sql,visibility:km/%+%/json',
  1228. $this->apiBaseUrl,
  1229. $endDate,
  1230. $startDate,
  1231. 1,
  1232. $coordinateString,
  1233. $coordinateString
  1234. );
  1235. } else {
  1237. if ($coordinates) {
  1238. $latitude = $coordinates[0][0];
  1239. $longitude = $coordinates[0][1];
  1240. }
  1242. // Validate the input parameters
  1243. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  1244. throw new \InvalidArgumentException('Invalid latitude');
  1245. }
  1246. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  1247. throw new \InvalidArgumentException('Invalid longitude');
  1248. }
  1250. if (empty($startDate) || empty($endDate)) {
  1251. throw new \InvalidArgumentException('Invalid dates');
  1252. }
  1254. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1255. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1257. // Create a Redis key for the cache
  1258. $cacheKey = sprintf('dashboard_%s_%s', implode('_', array_map(function ($coordinate) {
  1259. return implode('_', $coordinate);
  1260. }, $coordinates)), (($startDate) . '-' . ($endDate)));
  1263. // Try to get the data from Redis cache
  1264. $cachedData = $this->redisCache->get($cacheKey);
  1266. if ($cachedData !== null) {
  1267. // Return the cached data if available
  1268. return $cachedData;
  1269. }
  1271. // If cache is empty, get the data from the API
  1272. $client = new Client(['verify' => false]);
  1273. $url = sprintf(
  1274. '%s/%s--%s:P%sD/t_max_2m_24h:C,t_apparent:C,wind_speed_10m:kmh,wind_dir_mean_10m_24h:d,prob_precip_24h:p,precip_24h:mm,sunrise:sql,visibility:km/%s,%s/json',
  1275. $this->apiBaseUrl,
  1276. $endDate,
  1277. $startDate,
  1278. 1,
  1279. $latitude,
  1280. $longitude
  1281. );
  1282. }
  1284. $response = $client->request('GET', $url, [
  1285. 'auth' => [$this->username, $this->password],
  1286. ]);
  1288. $statusCode = $response->getStatusCode();
  1289. $data = json_decode($response->getBody(), true);
  1291. // Set the data to Redis cache
  1292. $this->redisCache->set($cacheKey, $data);
  1294. return $data;
  1295. } catch (GuzzleHttp\Exception\RequestException $e) {
  1296. return throw new \Exception($e->getMessage());
  1297. } catch (\Exception $e) {
  1298. return throw new \Exception($e->getMessage());
  1299. }
  1300. }
  1303. /**
  1304. * Get forecast data for the provided coordinates
  1305. *
  1306. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1307. * @param string $timestamp The timestamp for which forecast is required in the format "YYYY-MM-DDTHHZ"
  1308. * @param string $duration The duration for which forecast is required in ISO 8601 format "P1D" for 1 day, "PT1H" for 1 hour
  1309. * @param string $parameters The weather parameters to fetch separated by comma, e.g. "t_2m:C,sfc_pressure:hPa,wind_speed_10m:ms"
  1310. * @param string $aggregations The aggregations to apply to the fetched parameters separated by comma, e.g. "mean,sum"
  1311. * @param string $format The format in which to receive the data, either "json" or "xml"
  1312. *
  1313. * @return array The forecast data for the provided coordinates
  1314. */
  1315. public function getForecastForCoordinates(
  1316. array $coordinates,
  1317. string $timestamp,
  1318. string $duration,
  1319. string $parameters,
  1320. string $aggregations,
  1321. string $format
  1322. ) {
  1323. try {
  1324. // Validate the input parameters
  1325. foreach ($coordinates as $coordinate) {
  1326. if (!is_array($coordinate) || count($coordinate) !== 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  1327. throw new \InvalidArgumentException('Invalid coordinates');
  1328. }
  1329. }
  1331. if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}Z$/', $timestamp)) {
  1332. throw new \InvalidArgumentException('Invalid timestamp');
  1333. }
  1335. if (!in_array($duration, ['PT1H', 'P1D'])) {
  1336. throw new \InvalidArgumentException('Invalid duration');
  1337. }
  1339. if (!is_string($parameters) || empty($parameters)) {
  1340. throw new \InvalidArgumentException('Invalid parameters');
  1341. }
  1343. if (!is_string($aggregations) || empty($aggregations)) {
  1344. throw new \InvalidArgumentException('Invalid aggregations');
  1345. }
  1347. if (!in_array($format, ['json', 'xml'])) {
  1348. throw new \InvalidArgumentException('Invalid format');
  1349. }
  1351. // Convert the coordinates array into a string
  1352. $coordinatesString = implode('_', array_map(function ($coordinate) {
  1353. return implode(',', $coordinate);
  1354. }, $coordinates));
  1356. // Build the URL for the API call
  1357. $url = sprintf(
  1358. '%s/%s/%s/%s/%s/%s/%s.%s',
  1359. $this->apiBaseUrl,
  1360. $timestamp,
  1361. $duration,
  1362. $parameters,
  1363. $coordinatesString,
  1364. $aggregations,
  1365. $format
  1366. );
  1368. // Make the API call
  1369. $client = new Client(['verify' => false]);
  1370. $response = $client->request('GET', $url, [
  1371. 'auth' => [$this->username, $this->password],
  1372. ]);
  1374. $statusCode = $response->getStatusCode();
  1375. $data = json_decode($response->getBody(), true);
  1377. return $data;
  1378. } catch (GuzzleHttp\Exception\RequestException $e) {
  1379. return throw new \Exception($e->getMessage());
  1380. } catch (\Exception $e) {
  1381. return throw new \Exception($e->getMessage());
  1382. }
  1383. }
  1385. /**
  1386. * Get weather symbols
  1387. *
  1388. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1389. * @param int $days The number of days for which forecast is required
  1390. * @return array The model forecast data
  1391. */
  1392. public function getWeatherSymbols(array $coordinates, string $startDate, string $endDate, string $weatherFirstParam = 'PT1H', string $weatherSecondParam = '1h', $adjustDate = false)
  1393. {
  1394. try {
  1396. if ($coordinates) {
  1397. $latitude = $coordinates[0][0];
  1398. $longitude = $coordinates[0][1];
  1399. }
  1401. // Validate the input parameters
  1402. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  1403. throw new \InvalidArgumentException('Invalid latitude');
  1404. }
  1405. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  1406. throw new \InvalidArgumentException('Invalid longitude');
  1407. }
  1409. if (empty($startDate) || empty($endDate)) {
  1410. throw new \InvalidArgumentException('Invalid dates');
  1411. }
  1414. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1415. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1417. if ($adjustDate) {
  1418. // Adjust the date range based on the hours parameter
  1419. if ($weatherSecondParam == '24h') {
  1420. $startDate = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 day'));
  1421. $endDate = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 day'));
  1422. } elseif ($weatherSecondParam == '1h') {
  1423. $startDate = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +1 hour'));
  1424. $endDate = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +1 hour'));
  1425. } elseif ($weatherSecondParam == '12h') {
  1426. $startDate = date('Y-m-d\TH:i:s.v\Z', strtotime($startDate . ' +12 hour'));
  1427. $endDate = date('Y-m-d\TH:i:s.v\Z', strtotime($endDate . ' +12 hour'));
  1428. }
  1429. }
  1431. // Create a Redis key for the cache
  1432. $cacheKey = sprintf('get_symbols_%s_%s', implode('_', array_map(function ($coordinate) {
  1433. return implode('_', $coordinate);
  1434. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $weatherFirstParam);
  1437. // Try to get the data from Redis cache
  1438. $cachedData = $this->redisCache->get($cacheKey);
  1440. if ($cachedData !== null) {
  1441. // Return the cached data if available
  1442. return $cachedData;
  1443. }
  1445. // If cache is empty, get the data from the API
  1446. $client = new Client(['verify' => false]);
  1447. $url = sprintf(
  1448. '%s/%s--%s:%s/weather_symbol_%s:idx/%s,%s/json',
  1449. $this->apiBaseUrl,
  1450. $startDate,
  1451. $endDate,
  1452. $weatherFirstParam,
  1453. $weatherSecondParam,
  1454. $latitude,
  1455. $longitude
  1456. );
  1459. $response = $client->request('GET', $url, [
  1460. 'auth' => [$this->username, $this->password],
  1461. ]);
  1463. $statusCode = $response->getStatusCode();
  1464. $data = json_decode($response->getBody(), true);
  1466. if ($adjustDate) {
  1467. // Define your adjustment ('-1 day' or '-1 hour' or '-12 hour')
  1469. if ($weatherSecondParam == '24h') {
  1470. $timeAdjustment = 24;
  1471. } elseif ($weatherSecondParam == '1h') {
  1472. $timeAdjustment = 1;
  1473. } elseif ($weatherSecondParam == '12h') {
  1474. $timeAdjustment = 12;
  1475. }
  1478. // Adjust the dates in the response data
  1479. $this->adjustResponseDates($data['data'], $timeAdjustment);
  1480. }
  1482. // Set the data to Redis cache
  1483. $this->redisCache->set($cacheKey, $data);
  1485. return $data;
  1486. } catch (GuzzleHttp\Exception\RequestException $e) {
  1487. return throw new \Exception($e->getMessage());
  1488. } catch (\Exception $e) {
  1489. return throw new \Exception($e->getMessage());
  1490. }
  1491. }
  1493. /**
  1494. * Weather Map
  1495. *
  1496. * @param string $version The version of the API (e.g., '1.3.0')
  1497. * @param string $request The type of request (e.g., 'GetMap')
  1498. * @param string $layers The layers to include in the map
  1499. * @param string $crs The coordinate reference system (e.g., 'EPSG:3857')
  1500. * @param string $bBox The bounding box in the format 'minX,minY,maxX,maxY'
  1501. * @param string $format The format of the map image (e.g., 'image/png')
  1502. * @param int $width The width of the map image
  1503. * @param int $height The height of the map image
  1504. * @param bool $tiled Whether to use tiled rendering (default: true)
  1505. * @return array The model forecast data
  1506. * @throws \InvalidArgumentException If any parameter has an invalid data type
  1507. */
  1508. public function getWeatherMap(
  1509. string $version,
  1510. string $request,
  1511. string $layers,
  1512. string $crs,
  1513. string $bBox,
  1514. string $format,
  1515. int $width,
  1516. int $height,
  1517. bool $tiled = true
  1518. ) {
  1519. // Validate data types of input parameters
  1520. if (!is_string($version)) {
  1521. throw new \InvalidArgumentException('Invalid data type for $version. Expected string.');
  1522. }
  1523. if (!is_string($request)) {
  1524. throw new \InvalidArgumentException('Invalid data type for $request. Expected string.');
  1525. }
  1526. if (!is_string($layers)) {
  1527. throw new \InvalidArgumentException('Invalid data type for $layers. Expected string.');
  1528. }
  1529. if (!is_string($crs)) {
  1530. throw new \InvalidArgumentException('Invalid data type for $crs. Expected string.');
  1531. }
  1532. if (!is_string($bBox)) {
  1533. throw new \InvalidArgumentException('Invalid data type for $bBox. Expected string.');
  1534. }
  1535. if (!is_string($format)) {
  1536. throw new \InvalidArgumentException('Invalid data type for $format. Expected string.');
  1537. }
  1538. if (!is_int($width)) {
  1539. throw new \InvalidArgumentException('Invalid data type for $width. Expected int.');
  1540. }
  1541. if (!is_int($height)) {
  1542. throw new \InvalidArgumentException('Invalid data type for $height. Expected int.');
  1543. }
  1544. if (!is_bool($tiled)) {
  1545. throw new \InvalidArgumentException('Invalid data type for $tiled. Expected bool.');
  1546. }
  1548. try {
  1549. // If cache is empty, get the data from the API
  1550. $client = new Client(['verify' => false]);
  1551. $url = sprintf(
  1552. '%s/wms?VERSION=%s&REQUEST=%s&LAYERS=%s&CRS=%s&BBOX=%s&FORMAT=%s&WIDTH=%s&HEIGHT=%s&TILED=%s',
  1553. $this->apiBaseUrl,
  1554. $version,
  1555. $request,
  1556. $layers,
  1557. $crs,
  1558. $bBox,
  1559. $format,
  1560. $width,
  1561. $height,
  1562. $tiled
  1563. );
  1564. $response = $client->request('GET', $url, [
  1565. 'auth' => [$this->username, $this->password],
  1566. ]);
  1567. return $response->getBody();
  1568. } catch (GuzzleHttp\Exception\RequestException $e) {
  1569. return throw new \Exception($e->getMessage());
  1570. } catch (\Exception $e) {
  1571. return throw new \Exception($e->getMessage());
  1572. }
  1573. }
  1576. /**
  1577. * Weather Warnings
  1578. *
  1579. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1580. * @param string $startDate The start date for the forecast
  1581. * @param string $endDate The end date for the forecast
  1582. * @param string $duration The duration for the forecast (default: '24')
  1583. * @param string $warningParam The type of weather warning parameter (default: 'frost_warning')
  1584. * @param string $format The format of the forecast data (default: 'json')
  1585. * @return array The model forecast data
  1586. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  1587. */
  1588. public function getWeatherWarnings(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $warningParam = 'frost_warning', string $format = "json", $translator)
  1589. {
  1590. try {
  1592. // Validate the input parameters
  1593. if (empty($coordinates)) {
  1594. // throw new \InvalidArgumentException('Invalid coordinates');
  1595. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  1596. }
  1598. if (!is_array($coordinates) || count($coordinates) < 1) {
  1599. // throw new \InvalidArgumentException('Coordinates should be a non-empty array');
  1600. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  1601. }
  1603. $latitude = $coordinates[0][0] ?? null;
  1604. $longitude = $coordinates[0][1] ?? null;
  1606. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  1607. // throw new \InvalidArgumentException('Invalid latitude');
  1608. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  1609. }
  1611. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  1612. // throw new \InvalidArgumentException('Invalid longitude');
  1613. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  1614. }
  1616. if (empty($startDate) || empty($endDate)) {
  1617. // throw new \InvalidArgumentException('Invalid dates');
  1618. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  1619. }
  1621. if (!is_numeric($duration)) {
  1622. // throw new \InvalidArgumentException('Duration should be numeric');
  1623. return ["success" => false, "message" => $translator->trans("duration_should_be _numeric")];
  1624. }
  1626. $weatherWarning = new \Pimcore\Model\DataObject\MMWarningConfig\Listing();
  1627. $weatherWarning->setCondition("WarningKey = ? AND (hourEnd >= ? AND hourStart <= ?)", [$warningParam, $duration, $duration]);
  1628. $weatherWarning = $weatherWarning->load();
  1630. if (!$weatherWarning) {
  1631. throw new \Exception('Weather configuration is missing for key.' . $warningParam);
  1632. }
  1634. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1635. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1637. // Create a Redis key for the cache
  1638. $cacheKey = sprintf('weather_warning_%s_%s_%s', $warningParam . $format, implode('_', array_map(function ($coordinate) {
  1639. return implode('_', $coordinate);
  1640. }, $coordinates)), (($startDate) . '-' . ($endDate)));
  1643. // Try to get the data from Redis cache
  1644. $cachedData = $this->redisCache->get($cacheKey);
  1646. if ($cachedData !== null) {
  1647. // Return the cached data if available
  1648. return $cachedData;
  1649. }
  1651. // If cache is empty, get the data from the API
  1652. $client = new Client(['verify' => false]);
  1653. $url = sprintf(
  1654. '%s/%s--%s:PT%sH//%s_%sh:idx/%s,%s/json',
  1655. $this->apiBaseUrl,
  1656. $startDate,
  1657. $endDate,
  1658. $duration,
  1659. $warningParam,
  1660. $duration,
  1661. $latitude,
  1662. $longitude
  1663. );
  1666. $response = $client->request('GET', $url, [
  1667. 'auth' => [$this->username, $this->password],
  1668. ]);
  1670. $statusCode = $response->getStatusCode();
  1671. $data = json_decode($response->getBody(), true);
  1672. $modifiedParams = [];
  1673. if (isset($data['data'][0]['coordinates'][0]['dates'])) {
  1674. foreach ($data['data'][0]['coordinates'][0]['dates'] as $weather) {
  1675. $data = \App\Lib\Utility::getWeatherTypeDescription($weatherWarning[0]->getParams(), $weather);
  1676. $modifiedParams[] = $data;
  1677. }
  1678. }
  1680. $data['data'] = $modifiedParams;
  1682. // Set the data to Redis cache
  1683. $this->redisCache->set($cacheKey, $data);
  1685. return $data;
  1686. } catch (GuzzleHttp\Exception\RequestException $e) {
  1687. return throw new \Exception($e->getMessage());
  1688. } catch (\Exception $e) {
  1689. return throw new \Exception($e->getMessage());
  1690. }
  1691. }
  1694. /**
  1695. * Weather Warnings
  1696. *
  1697. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1698. * @param string $startDate The start date for the forecast
  1699. * @param string $endDate The end date for the forecast
  1700. * @param string $duration The duration for the forecast (default: '24')
  1701. * @param string $warningParam The type of weather warning parameter (default: 'frost_warning')
  1702. * @param string $format The format of the forecast data (default: 'json')
  1703. * @return array The model forecast data
  1704. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  1705. */
  1706. public function getPrecipitationType(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $format = "json", $translator)
  1707. {
  1708. try {
  1710. // Validate the input parameters
  1711. if (empty($coordinates)) {
  1712. // throw new \InvalidArgumentException('Invalid coordinates');
  1713. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  1714. }
  1716. if (!is_array($coordinates) || count($coordinates) < 1) {
  1717. // throw new \InvalidArgumentException('Coordinates should be a non-empty array');
  1718. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  1719. }
  1721. $latitude = $coordinates[0][0] ?? null;
  1722. $longitude = $coordinates[0][1] ?? null;
  1724. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  1725. // throw new \InvalidArgumentException('Invalid latitude');
  1726. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  1727. }
  1729. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  1730. // throw new \InvalidArgumentException('Invalid longitude');
  1731. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  1732. }
  1734. if (empty($startDate) || empty($endDate)) {
  1735. // throw new \InvalidArgumentException('Invalid dates');
  1736. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  1737. }
  1739. if (!is_numeric($duration)) {
  1740. // throw new \InvalidArgumentException('Duration should be numeric');
  1741. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  1742. }
  1745. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1746. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1748. // Create a Redis key for the cache
  1749. $cacheKey = sprintf('weather_precitipitation_%s_%s', implode('_', array_map(function ($coordinate) {
  1750. return implode('_', $coordinate);
  1751. }, $coordinates)), (($startDate) . '-' . ($endDate)));
  1754. // Try to get the data from Redis cache
  1755. $cachedData = $this->redisCache->get($cacheKey);
  1757. if ($cachedData !== null) {
  1758. // Return the cached data if available
  1759. // return $cachedData;
  1760. }
  1762. // If cache is empty, get the data from the API
  1763. $client = new Client(['verify' => false]);
  1764. $url = sprintf(
  1765. '%s/%s--%s:PT%sM/precip_type:idx/%s,%s/json',
  1766. $this->apiBaseUrl,
  1767. $startDate,
  1768. $endDate,
  1769. $duration,
  1770. $duration,
  1771. $latitude,
  1772. $longitude
  1773. );
  1776. $response = $client->request('GET', $url, [
  1777. 'auth' => [$this->username, $this->password],
  1778. ]);
  1780. $statusCode = $response->getStatusCode();
  1781. $data = json_decode($response->getBody(), true);
  1783. $modifiedParams = [];
  1784. if (isset($data['data'][0]['coordinates'][0]['dates'])) {
  1785. foreach ($data['data'][0]['coordinates'][0]['dates'] as $prepData) {
  1786. $data = \App\Lib\Utility::getPrecipitationTypeDescription($prepData);
  1787. $modifiedParams[] = $data;
  1788. }
  1789. } else {
  1790. throw new \Exception("Data not available");
  1791. }
  1793. $data['data'][0]['coordinates'][0]['dates'] = $modifiedParams;
  1795. // Set the data to Redis cache
  1796. $this->redisCache->set($cacheKey, $data);
  1798. return $data;
  1799. } catch (GuzzleHttp\Exception\RequestException $e) {
  1800. return throw new \Exception($e->getMessage());
  1801. } catch (\Exception $e) {
  1802. return throw new \Exception($e->getMessage());
  1803. }
  1804. }
  1807. /**
  1808. * Weather Warnings
  1809. *
  1810. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1811. * @param string $startDate The start date for the forecast
  1812. * @param string $endDate The end date for the forecast
  1813. * @param string $duration The duration for the forecast (default: '24')
  1814. * @param string $intervalType type of interval (default: 'min')
  1815. * @param string $format The format of the forecast data (default: 'json')
  1816. * @return array The model forecast data
  1817. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  1818. */
  1819. public function getHailIndex(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $intervalType = "min", string $format = "json", $translator)
  1820. {
  1821. try {
  1823. // Validate the input parameters
  1824. if (count($coordinates) > 1) {
  1826. // Validate the input parameters
  1827. foreach ($coordinates as $coordinate) {
  1828. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  1829. throw new \InvalidArgumentException('Invalid coordinates');
  1830. }
  1831. }
  1833. if (empty($startDate) || empty($endDate)) {
  1834. // throw new \InvalidArgumentException('Invalid dates');
  1835. return ["success" => false, "message" => $translator->trans("duration_dates")];
  1836. }
  1838. if (!is_numeric($duration)) {
  1839. // throw new \InvalidArgumentException('Duration should be numeric');
  1840. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  1841. }
  1843. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1844. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1846. // Create a Redis key for the cache
  1847. $cacheKey = sprintf('weather_hail_%s_%s', implode('_', array_map(function ($coordinate) {
  1848. return implode('_', $coordinate);
  1849. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $intervalType));
  1852. // Try to get the data from Redis cache
  1853. $cachedData = $this->redisCache->get($cacheKey);
  1855. if ($cachedData !== null) {
  1856. // Return the cached data if available
  1857. return $cachedData;
  1858. }
  1861. // If cache is empty, get the data from the API
  1862. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  1864. //10min, 20min, 30min, 1h, 3h, 6h, 12h, 24h
  1865. // If cache is empty, get the data from the API
  1866. if ($intervalType == "min") {
  1867. $url = sprintf(
  1868. '%s/%s--%s:PT%sM/hail_%smin:cm/%s/json',
  1869. $this->apiBaseUrl,
  1870. $startDate,
  1871. $endDate,
  1872. $duration,
  1873. $duration,
  1874. $coordinateString
  1875. );
  1876. } else if ($intervalType == "hour") {
  1877. $url = sprintf(
  1878. '%s/%s--%s:PT%sH/hail_%sh:cm/%s/json',
  1879. $this->apiBaseUrl,
  1880. $startDate,
  1881. $endDate,
  1882. $duration,
  1883. $duration,
  1884. $coordinateString
  1885. );
  1886. }
  1888. $client = new Client(['verify' => false]);
  1891. $response = $client->request('GET', $url, [
  1892. 'auth' => [$this->username, $this->password],
  1893. ]);
  1895. $statusCode = $response->getStatusCode();
  1896. $data = json_decode($response->getBody(), true);
  1898. // Set the data to Redis cache
  1899. $this->redisCache->set($cacheKey, $data);
  1901. return $data;
  1902. } else {
  1905. $latitude = $coordinates[0][0] ?? null;
  1906. $longitude = $coordinates[0][1] ?? null;
  1908. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  1909. // throw new \InvalidArgumentException('Invalid latitude');
  1910. return ["success" => false, "message" => $translator->trans("duration_latitude")];
  1911. }
  1913. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  1914. // throw new \InvalidArgumentException('Invalid longitude');
  1915. return ["success" => false, "message" => $translator->trans("duration_longitude")];
  1916. }
  1918. if (empty($startDate) || empty($endDate)) {
  1919. // throw new \InvalidArgumentException('Invalid dates');
  1920. return ["success" => false, "message" => $translator->trans("duration_dates")];
  1921. }
  1923. if (!is_numeric($duration)) {
  1924. // throw new \InvalidArgumentException('Duration should be numeric');
  1925. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  1926. }
  1929. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  1930. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  1932. // Create a Redis key for the cache
  1933. $cacheKey = sprintf('weather_hail_%s_%s', implode('_', array_map(function ($coordinate) {
  1934. return implode('_', $coordinate);
  1935. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $intervalType));
  1938. // Try to get the data from Redis cache
  1939. $cachedData = $this->redisCache->get($cacheKey);
  1941. if ($cachedData !== null) {
  1942. // Return the cached data if available
  1943. return $cachedData;
  1944. }
  1946. //10min, 20min, 30min, 1h, 3h, 6h, 12h, 24h
  1947. // If cache is empty, get the data from the API
  1948. if ($intervalType == "min") {
  1949. $url = sprintf(
  1950. '%s/%s--%s:PT%sM/hail_%smin:cm/%s,%s/json',
  1951. $this->apiBaseUrl,
  1952. $startDate,
  1953. $endDate,
  1954. $duration,
  1955. $duration,
  1956. $latitude,
  1957. $longitude
  1958. );
  1959. } else if ($intervalType == "hour") {
  1960. $url = sprintf(
  1961. '%s/%s--%s:PT%sH/hail_%sh:cm/%s,%s/json',
  1962. $this->apiBaseUrl,
  1963. $startDate,
  1964. $endDate,
  1965. $duration,
  1966. $duration,
  1967. $latitude,
  1968. $longitude
  1969. );
  1970. }
  1972. $client = new Client(['verify' => false]);
  1975. $response = $client->request('GET', $url, [
  1976. 'auth' => [$this->username, $this->password],
  1977. ]);
  1979. $statusCode = $response->getStatusCode();
  1980. $data = json_decode($response->getBody(), true);
  1982. // Set the data to Redis cache
  1983. $this->redisCache->set($cacheKey, $data);
  1985. return $data;
  1986. }
  1987. } catch (GuzzleHttp\Exception\RequestException $e) {
  1988. return throw new \Exception($e->getMessage());
  1989. } catch (\Exception $e) {
  1990. return throw new \Exception($e->getMessage());
  1991. }
  1992. }
  1994. /**
  1995. * Temprature
  1996. *
  1997. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  1998. * @param string $startDate The start date for the forecast
  1999. * @param string $endDate The end date for the forecast
  2000. * @param string $duration The duration for the forecast (default: '24')
  2001. * @param string $intervalType type of interval (default: 'hour')
  2002. * @param string $format The format of the forecast data (default: 'json')
  2003. * @return array The model forecast data
  2004. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2005. */
  2007. //https://api.meteomatics.com/2023-07-11T00:00:00Z--2023-07-14T00:00:00Z:PT1H/t_2m:C/48.8566,2.3522/json
  2008. public function getTemprature(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $intervalType = "hour", string $format = "json", $translator)
  2009. {
  2010. try {
  2012. // Validate the input parameters
  2013. if (empty($coordinates)) {
  2014. // throw new \InvalidArgumentException('Invalid coordinates');
  2015. return ["success" => false, "message" => $translator->trans("invalid_coordinate")];
  2016. }
  2018. if (!is_array($coordinates) || count($coordinates) < 1) {
  2019. // throw new \InvalidArgumentException('Coordinates should be a non-empty array');
  2020. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2021. }
  2023. $latitude = $coordinates[0][0] ?? null;
  2024. $longitude = $coordinates[0][1] ?? null;
  2026. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2027. // throw new \InvalidArgumentException('Invalid latitude');
  2028. return ["success" => false, "message" => $translator->trans("invalid_coordinate")];
  2029. }
  2031. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2032. // throw new \InvalidArgumentException('Invalid longitude');
  2033. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2034. }
  2036. if (empty($startDate) || empty($endDate)) {
  2037. // throw new \InvalidArgumentException('Invalid dates');
  2038. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2039. }
  2041. if (!is_numeric($duration)) {
  2042. // throw new \InvalidArgumentException('Duration should be numeric');
  2043. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2044. }
  2047. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2048. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2050. // Create a Redis key for the cache
  2051. $cacheKey = sprintf('temprature_%s_%s', implode('_', array_map(function ($coordinate) {
  2052. return implode('_', $coordinate);
  2053. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $intervalType));
  2056. // Try to get the data from Redis cache
  2057. $cachedData = $this->redisCache->get($cacheKey);
  2059. if ($cachedData !== null) {
  2060. // Return the cached data if available
  2061. return $cachedData;
  2062. }
  2064. // If cache is empty, get the data from the API
  2065. if ($intervalType == "hour") {
  2066. $url = sprintf(
  2067. '%s/%s--%s:PT%sM/t_2m:C/%s,%s/json',
  2068. $this->apiBaseUrl,
  2069. $startDate,
  2070. $endDate,
  2071. $duration,
  2072. $latitude,
  2073. $longitude
  2074. );
  2075. } else if ($intervalType == "day") {
  2076. $url = sprintf(
  2077. '%s/%s--%s:P%sD/t_2m:C/%s,%s/json',
  2078. $this->apiBaseUrl,
  2079. $startDate,
  2080. $endDate,
  2081. $duration,
  2082. $latitude,
  2083. $longitude
  2084. );
  2085. }
  2087. $client = new Client(['verify' => false]);
  2090. $response = $client->request('GET', $url, [
  2091. 'auth' => [$this->username, $this->password],
  2092. ]);
  2094. $statusCode = $response->getStatusCode();
  2095. $data = json_decode($response->getBody(), true);
  2097. // Set the data to Redis cache
  2098. $this->redisCache->set($cacheKey, $data);
  2100. return $data;
  2101. } catch (GuzzleHttp\Exception\RequestException $e) {
  2102. return throw new \Exception($e->getMessage());
  2103. } catch (\Exception $e) {
  2104. return throw new \Exception($e->getMessage());
  2105. }
  2106. }
  2108. /**
  2109. * Precipitation Probability
  2110. *
  2111. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2112. * @param string $startDate The start date for the forecast
  2113. * @param string $endDate The end date for the forecast
  2114. * @param string $duration The duration for the forecast (default: '24')
  2115. * @param string $intervalType type of interval (default: 'hour')
  2116. * @param string $format The format of the forecast data (default: 'json')
  2117. * @return array The model forecast data
  2118. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2119. */
  2121. //https://api.meteomatics.com/2023-07-11T00:00:00Z--2023-07-14T00:00:00Z:PT1H/t_2m:C/48.8566,2.3522/json
  2122. public function getPrecipitationProbability(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $format = "json", $translator)
  2123. {
  2124. try {
  2126. // Validate the input parameters
  2127. if (empty($coordinates)) {
  2128. return ["success" => false, "message" => $translator->trans("invalid_coordinate")];
  2129. }
  2131. if (!is_array($coordinates) || count($coordinates) < 1) {
  2132. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2133. }
  2135. $latitude = $coordinates[0][0] ?? null;
  2136. $longitude = $coordinates[0][1] ?? null;
  2138. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2139. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2140. }
  2142. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2143. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2144. }
  2146. if (empty($startDate) || empty($endDate)) {
  2147. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2148. }
  2150. if (!is_numeric($duration)) {
  2151. // throw new \InvalidArgumentException('Duration should be numeric');
  2152. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2153. }
  2156. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2157. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2159. // Create a Redis key for the cache
  2160. $cacheKey = sprintf('precep_prob_%s_%s', implode('_', array_map(function ($coordinate) {
  2161. return implode('_', $coordinate);
  2162. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  2165. // Try to get the data from Redis cache
  2166. $cachedData = $this->redisCache->get($cacheKey);
  2168. if ($cachedData !== null) {
  2169. // Return the cached data if available
  2170. return $cachedData;
  2171. }
  2173. // If cache is empty, get the data from the API
  2174. $url = sprintf(
  2175. '%s/%s--%s:PT%sH/prob_precip_%sh:p/%s,%s/json',
  2176. $this->apiBaseUrl,
  2177. $startDate,
  2178. $endDate,
  2179. $duration,
  2180. $duration,
  2181. $latitude,
  2182. $longitude
  2183. );
  2185. $client = new Client(['verify' => false]);
  2188. $response = $client->request('GET', $url, [
  2189. 'auth' => [$this->username, $this->password],
  2190. ]);
  2192. $statusCode = $response->getStatusCode();
  2193. $data = json_decode($response->getBody(), true);
  2195. // Set the data to Redis cache
  2196. $this->redisCache->set($cacheKey, $data);
  2198. return $data;
  2199. } catch (GuzzleHttp\Exception\RequestException $e) {
  2200. return throw new \Exception($e->getMessage());
  2201. } catch (\Exception $e) {
  2202. return throw new \Exception($e->getMessage());
  2203. }
  2204. }
  2206. /**
  2207. * Visibility
  2208. *
  2209. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2210. * @param string $startDate The start date for the forecast
  2211. * @param string $endDate The end date for the forecast
  2212. * @param string $duration The duration for the forecast (default: '24')
  2213. * @param string $intervalType type of interval (default: 'hour')
  2214. * @param string $format The format of the forecast data (default: 'json')
  2215. * @return array The model forecast data
  2216. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2217. */
  2218. public function getVisibility(array $coordinates, string $startDate, string $endDate, string $duration = '24', $unit = 'km', string $format = "json", $translator)
  2219. {
  2220. try {
  2222. // Validate the input parameters
  2223. if (empty($coordinates)) {
  2224. // throw new \InvalidArgumentException('Invalid coordinates');
  2225. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2226. }
  2228. if (!is_array($coordinates) || count($coordinates) < 1) {
  2229. // throw new \InvalidArgumentException('Coordinates should be a non-empty array');
  2230. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2231. }
  2233. $latitude = $coordinates[0][0] ?? null;
  2234. $longitude = $coordinates[0][1] ?? null;
  2236. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2237. // throw new \InvalidArgumentException('Invalid latitude');
  2238. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2239. }
  2241. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2242. // throw new \InvalidArgumentException('Invalid longitude');
  2243. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2244. }
  2246. if (empty($startDate) || empty($endDate)) {
  2247. // throw new \InvalidArgumentException('Invalid dates');
  2248. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2249. }
  2251. if (!is_numeric($duration)) {
  2252. // throw new \InvalidArgumentException('Duration should be numeric');
  2253. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2254. }
  2256. if (!in_array($unit, ['m', 'km', 'ft', 'nmi'])) {
  2257. // throw new \InvalidArgumentException('Invalid unit');
  2258. return ["success" => false, "message" => $translator->trans("invalid_unit")];
  2259. }
  2262. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2263. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2265. // Create a Redis key for the cache
  2266. $cacheKey = sprintf('visibility_%s_%s', implode('_', array_map(function ($coordinate) {
  2267. return implode('_', $coordinate);
  2268. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  2271. // Try to get the data from Redis cache
  2272. $cachedData = $this->redisCache->get($cacheKey);
  2274. if ($cachedData !== null) {
  2275. // Return the cached data if available
  2276. return $cachedData;
  2277. }
  2279. // If cache is empty, get the data from the API
  2280. $url = sprintf(
  2281. '%s/%s--%s:PT%sH/visibility:%s/%s,%s/json',
  2282. $this->apiBaseUrl,
  2283. $startDate,
  2284. $endDate,
  2285. $duration,
  2286. $unit,
  2287. $latitude,
  2288. $longitude
  2289. );
  2291. $client = new Client(['verify' => false]);
  2294. $response = $client->request('GET', $url, [
  2295. 'auth' => [$this->username, $this->password],
  2296. ]);
  2298. $statusCode = $response->getStatusCode();
  2299. $data = json_decode($response->getBody(), true);
  2301. // Set the data to Redis cache
  2302. $this->redisCache->set($cacheKey, $data);
  2304. return $data;
  2305. } catch (GuzzleHttp\Exception\RequestException $e) {
  2306. return throw new \Exception($e->getMessage());
  2307. } catch (\Exception $e) {
  2308. return throw new \Exception($e->getMessage());
  2309. }
  2310. }
  2312. /**
  2313. * Wind Direction
  2314. *
  2315. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2316. * @param string $startDate The start date for the forecast
  2317. * @param string $endDate The end date for the forecast
  2318. * @param string $duration The duration for the forecast (default: '24')
  2319. * @param string $intervalType type of interval (default: 'hour')
  2320. * @param string $format The format of the forecast data (default: 'json')
  2321. * @return array The model forecast data
  2322. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2323. */
  2324. //https://api.meteomatics.com/2023-07-11T00:00:00ZP2D:PT3H/wind_dir_10m:d,wind_dir_700hPa:d/47.412164,9.340652/csv
  2325. public function getWindDirection(array $coordinates, string $startDate, string $endDate, string $duration = '24', $height = '10m', $level = '700hPa', string $format = "json", $translator)
  2326. {
  2327. try {
  2329. // Validate the input parameters
  2330. if (empty($coordinates)) {
  2331. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2332. }
  2334. if (!is_array($coordinates) || count($coordinates) < 1) {
  2335. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2336. }
  2338. $latitude = $coordinates[0][0] ?? null;
  2339. $longitude = $coordinates[0][1] ?? null;
  2341. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2342. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2343. }
  2345. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2346. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2347. }
  2349. if (empty($startDate) || empty($endDate)) {
  2350. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2351. }
  2353. if (!is_numeric($duration)) {
  2354. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2355. }
  2357. if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa', '50hPa', '10hPa'])) {
  2358. return ["success" => false, "message" => $translator->trans("invalid_level")];
  2359. }
  2362. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2363. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2365. // Create a Redis key for the cache
  2366. $cacheKey = sprintf('wind_direction_%s_%s', implode('_', array_map(function ($coordinate) {
  2367. return implode('_', $coordinate);
  2368. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $level));
  2371. // Try to get the data from Redis cache
  2372. $cachedData = $this->redisCache->get($cacheKey);
  2374. if ($cachedData !== null) {
  2375. // Return the cached data if available
  2376. return $cachedData;
  2377. }
  2379. // If cache is empty, get the data from the API
  2380. $url = sprintf(
  2381. '%s/%s--%s:PT%sH/wind_dir_%s:d,wind_dir_%s:d/%s,%s/json',
  2382. $this->apiBaseUrl,
  2383. $startDate,
  2384. $endDate,
  2385. $duration,
  2386. $height,
  2387. $level,
  2388. $latitude,
  2389. $longitude
  2390. );
  2392. $client = new Client(['verify' => false]);
  2395. $response = $client->request('GET', $url, [
  2396. 'auth' => [$this->username, $this->password],
  2397. ]);
  2399. $statusCode = $response->getStatusCode();
  2400. $data = json_decode($response->getBody(), true);
  2402. // Set the data to Redis cache
  2403. $this->redisCache->set($cacheKey, $data);
  2405. return $data;
  2406. } catch (GuzzleHttp\Exception\RequestException $e) {
  2407. return throw new \Exception($e->getMessage());
  2408. } catch (\Exception $e) {
  2409. return throw new \Exception($e->getMessage());
  2410. }
  2411. }
  2414. /**
  2415. * Wind Speed
  2416. *
  2417. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2418. * @param string $startDate The start date for the forecast
  2419. * @param string $endDate The end date for the forecast
  2420. * @param string $duration The duration for the forecast (default: '24')
  2421. * @param string $intervalType type of interval (default: 'hour')
  2422. * @param string $format The format of the forecast data (default: 'json')
  2423. * @return array The model forecast data
  2424. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2425. */
  2426. public function getWindSpeed(array $coordinates, string $startDate, string $endDate, string $duration = '24', $unit = 'ft', $level = '700hPa', string $format = "json", $translator)
  2427. {
  2428. try {
  2430. // Validate the input parameters
  2431. if (empty($coordinates)) {
  2432. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2433. }
  2435. if (!is_array($coordinates) || count($coordinates) < 1) {
  2436. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2437. }
  2439. $latitude = $coordinates[0][0] ?? null;
  2440. $longitude = $coordinates[0][1] ?? null;
  2442. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2443. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2444. }
  2446. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2447. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2448. }
  2450. if (empty($startDate) || empty($endDate)) {
  2451. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2452. }
  2454. if (!is_numeric($duration)) {
  2455. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2456. }
  2458. if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa', '50hPa', '10hPa'])) {
  2459. return ["success" => false, "message" => $translator->trans("invalid_level")];
  2460. }
  2462. if (!in_array($unit, ['ms', 'kmh', 'mph', 'kn', 'bft'])) {
  2463. return ["success" => false, "message" => $translator->trans("invalid_unit")];
  2464. }
  2467. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2468. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2470. // Create a Redis key for the cache
  2471. $cacheKey = sprintf('wind_speed_%s_%s', implode('_', array_map(function ($coordinate) {
  2472. return implode('_', $coordinate);
  2473. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $unit . $level));
  2476. // Try to get the data from Redis cache
  2477. $cachedData = $this->redisCache->get($cacheKey);
  2479. if ($cachedData !== null) {
  2480. // Return the cached data if available
  2481. return $cachedData;
  2482. }
  2484. // If cache is empty, get the data from the API
  2485. $url = sprintf(
  2486. '%s/%s--%s:PT%sH/wind_speed_%s:%s/%s,%s/json',
  2487. $this->apiBaseUrl,
  2488. $startDate,
  2489. $endDate,
  2490. $duration,
  2491. $level,
  2492. $unit,
  2493. $latitude,
  2494. $longitude
  2495. );
  2497. $client = new Client(['verify' => false]);
  2500. $response = $client->request('GET', $url, [
  2501. 'auth' => [$this->username, $this->password],
  2502. ]);
  2504. $statusCode = $response->getStatusCode();
  2505. $data = json_decode($response->getBody(), true);
  2507. // Set the data to Redis cache
  2508. $this->redisCache->set($cacheKey, $data);
  2510. return $data;
  2511. } catch (GuzzleHttp\Exception\RequestException $e) {
  2512. return throw new \Exception($e->getMessage());
  2513. } catch (\Exception $e) {
  2514. return throw new \Exception($e->getMessage());
  2515. }
  2516. }
  2518. /**
  2519. * Slippery Road
  2520. *
  2521. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2522. * @param string $startDate The start date for the forecast
  2523. * @param string $endDate The end date for the forecast
  2524. * @param string $duration The duration for the forecast (default: '24')
  2525. * @param string $intervalType type of interval (default: 'hour')
  2526. * @param string $format The format of the forecast data (default: 'json')
  2527. * @return array The model forecast data
  2528. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2529. */
  2530. public function getSlipperyRoad(array $coordinates, string $startDate, string $endDate, string $duration = '24', string $format = "json", $translator)
  2531. {
  2532. try {
  2534. // Validate the input parameters
  2535. if (empty($coordinates)) {
  2536. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2537. }
  2539. if (!is_array($coordinates) || count($coordinates) < 1) {
  2540. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2541. }
  2543. $latitude = $coordinates[0][0] ?? null;
  2544. $longitude = $coordinates[0][1] ?? null;
  2546. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2547. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2548. }
  2550. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2551. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2552. }
  2554. if (empty($startDate) || empty($endDate)) {
  2555. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2556. }
  2558. if (!is_numeric($duration)) {
  2559. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2560. }
  2563. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2564. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2566. // Create a Redis key for the cache
  2567. $cacheKey = sprintf('slipary_road_%s_%s', implode('_', array_map(function ($coordinate) {
  2568. return implode('_', $coordinate);
  2569. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  2572. // Try to get the data from Redis cache
  2573. $cachedData = $this->redisCache->get($cacheKey);
  2575. if ($cachedData !== null) {
  2576. // Return the cached data if available
  2577. return $cachedData;
  2578. }
  2580. // If cache is empty, get the data from the API
  2581. $url = sprintf(
  2582. '%s/%s--%s:PT%sH/prob_slippery_road_%sh:p,is_slippery_road_%sh:idx/%s,%s/json',
  2583. $this->apiBaseUrl,
  2584. $startDate,
  2585. $endDate,
  2586. $duration,
  2587. $duration,
  2588. $duration,
  2589. $latitude,
  2590. $longitude
  2591. );
  2593. $client = new Client(['verify' => false]);
  2596. $response = $client->request('GET', $url, [
  2597. 'auth' => [$this->username, $this->password],
  2598. ]);
  2600. $statusCode = $response->getStatusCode();
  2601. $data = json_decode($response->getBody(), true);
  2603. // Set the data to Redis cache
  2604. $this->redisCache->set($cacheKey, $data);
  2606. return $data;
  2607. } catch (GuzzleHttp\Exception\RequestException $e) {
  2608. return throw new \Exception($e->getMessage());
  2609. } catch (\Exception $e) {
  2610. return throw new \Exception($e->getMessage());
  2611. }
  2612. }
  2615. /**
  2616. * Solar Radiation
  2617. *
  2618. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2619. * @param string $startDate The start date for the forecast
  2620. * @param string $endDate The end date for the forecast
  2621. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2622. */
  2623. public function getSolarRadiation(array $coordinates, string $startDate, string $endDate, $translator, string $format = 'png',)
  2624. {
  2625. try {
  2627. // Validate the input parameters
  2628. if (empty($coordinates)) {
  2629. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2630. }
  2632. if (!is_array($coordinates) || count($coordinates) < 1) {
  2633. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2634. }
  2636. $latitude1 = $coordinates[0][0] ?? null;
  2637. $longitude1 = $coordinates[0][1] ?? null;
  2639. $latitude2 = $coordinates[1][0] ?? null;
  2640. $longitude2 = $coordinates[1][1] ?? null;
  2642. if (!is_numeric($latitude1) || $latitude1 < -90 || $latitude1 > 90) {
  2643. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2644. }
  2646. if (!is_numeric($longitude1) || $longitude1 < -180 || $longitude1 > 180) {
  2647. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2648. }
  2650. if (!is_numeric($latitude2) || $latitude2 < -90 || $latitude2 > 90) {
  2651. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2652. }
  2654. if (
  2655. !is_numeric($longitude2) || $longitude2 < -180 || $longitude2 > 180
  2656. ) {
  2657. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2658. }
  2660. if (empty($startDate) || empty($endDate)) {
  2661. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2662. }
  2664. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2665. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2667. $url = sprintf(
  2668. '%s/%s/global_rad:W/%s,%s_%s,%s:600x400/%s',
  2669. $this->apiBaseUrl,
  2670. $startDate,
  2671. $latitude1,
  2672. $longitude1,
  2673. $latitude2,
  2674. $longitude2,
  2675. $format
  2676. );
  2678. // echo $url;
  2679. // exit;
  2680. $client = new Client(['verify' => false]);
  2682. $response = $client->request('GET', $url, [
  2683. 'auth' => [$this->username, $this->password],
  2684. ]);
  2685. $statusCode = $response->getStatusCode();
  2686. return $response->getBody();
  2687. } catch (GuzzleHttp\Exception\RequestException $e) {
  2688. return throw new \Exception($e->getMessage());
  2689. } catch (\Exception $e) {
  2690. return throw new \Exception($e->getMessage());
  2691. }
  2692. }
  2694. /**
  2695. * Humidity
  2696. *
  2697. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2698. * @param string $startDate The start date for the forecast
  2699. * @param string $endDate The end date for the forecast
  2700. * @param string $duration The duration for the forecast (default: '24')
  2701. * @param string $intervalType type of interval (default: 'hour')
  2702. * @param string $format The format of the forecast data (default: 'json')
  2703. * @return array The model forecast data
  2704. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2705. */
  2706. public function getHumidity(array $coordinates, string $startDate, string $endDate, string $duration = '24', $unit = 'ft', $level = '700hPa', string $format = "json", $translator)
  2707. {
  2708. try {
  2710. // Validate the input parameters
  2711. if (empty($coordinates)) {
  2712. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2713. }
  2715. if (!is_array($coordinates) || count($coordinates) < 1) {
  2716. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2717. }
  2719. $latitude = $coordinates[0][0] ?? null;
  2720. $longitude = $coordinates[0][1] ?? null;
  2722. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2723. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2724. }
  2726. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2727. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2728. }
  2730. if (empty($startDate) || empty($endDate)) {
  2731. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2732. }
  2734. if (!is_numeric($duration)) {
  2735. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  2736. }
  2738. if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa', '50hPa', '10hPa'])) {
  2739. return ["success" => false, "message" => $translator->trans("invalid_level")];
  2740. }
  2742. if (!in_array($unit, ['p'])) {
  2743. return ["success" => false, "message" => $translator->trans("invalid_unit")];
  2744. }
  2747. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2748. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2750. // Create a Redis key for the cache
  2751. $cacheKey = sprintf('humidity_%s_%s', implode('_', array_map(function ($coordinate) {
  2752. return implode('_', $coordinate);
  2753. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration . $unit . $level));
  2756. // Try to get the data from Redis cache
  2757. $cachedData = $this->redisCache->get($cacheKey);
  2759. if ($cachedData !== null) {
  2760. // Return the cached data if available
  2761. return $cachedData;
  2762. }
  2764. // If cache is empty, get the data from the API
  2765. $url = sprintf(
  2766. '%s/%s--%s:PT%sH/relative_humidity_%s:%s/%s,%s/json',
  2767. $this->apiBaseUrl,
  2768. $startDate,
  2769. $endDate,
  2770. $duration,
  2771. $level,
  2772. $unit,
  2773. $latitude,
  2774. $longitude
  2775. );
  2777. $client = new Client(['verify' => false]);
  2780. $response = $client->request('GET', $url, [
  2781. 'auth' => [$this->username, $this->password],
  2782. ]);
  2784. $statusCode = $response->getStatusCode();
  2785. $data = json_decode($response->getBody(), true);
  2787. // Set the data to Redis cache
  2788. $this->redisCache->set($cacheKey, $data);
  2790. return $data;
  2791. } catch (GuzzleHttp\Exception\RequestException $e) {
  2792. return throw new \Exception($e->getMessage());
  2793. } catch (\Exception $e) {
  2794. return throw new \Exception($e->getMessage());
  2795. }
  2796. }
  2798. /**
  2799. * Fog
  2800. *
  2801. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2802. * @param string $startDate The start date for the forecast
  2803. * @param string $endDate The start date for the forecast
  2804. * @param string $interval Hours gap between search results
  2805. * @param string $intervalType type of interval (default: 'hour')
  2806. * @param string $format The format of the forecast data (default: 'json')
  2807. * @return array The model forecast data
  2808. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2809. */
  2810. public function getFog(array $coordinates, string $startDate, string $endDate, string $interval = '1', $unit = 'km', $translator, string $format = "json")
  2811. {
  2812. try {
  2814. if (count($coordinates) > 1) {
  2816. // Validate the input parameters
  2817. foreach ($coordinates as $coordinate) {
  2818. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  2819. throw new \InvalidArgumentException('Invalid coordinates');
  2820. }
  2821. }
  2823. if (empty($startDate)) {
  2824. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2825. }
  2827. if (empty($endDate)) {
  2828. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2829. }
  2831. if (!is_numeric($interval)) {
  2832. return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  2833. }
  2835. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2836. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2838. // Create a Redis key for the cache
  2839. $cacheKey = sprintf('visibility:%s,is_fog_%sh:idx', implode('_', array_map(function ($coordinate) {
  2840. return implode('_', $coordinate);
  2841. }, $coordinates)), (($startDate) . '-' . $endDate . $interval . $unit));
  2845. // Try to get the data from Redis cache
  2846. $cachedData = $this->redisCache->get($cacheKey);
  2848. if ($cachedData !== null) {
  2849. // Return the cached data if available
  2850. return $cachedData;
  2851. }
  2853. // If cache is empty, get the data from the API
  2854. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  2856. // If cache is empty, get the data from the API
  2857. $url = sprintf(
  2858. '%s/%s--%s:PT%sH/visibility:%s,is_fog_%sh:idx/%s/json',
  2859. $this->apiBaseUrl,
  2860. $startDate,
  2861. $endDate,
  2862. $interval,
  2863. $unit,
  2864. $interval,
  2865. $coordinateString
  2866. );
  2869. $client = new Client(['verify' => false]);
  2872. $response = $client->request('GET', $url, [
  2873. 'auth' => [$this->username, $this->password],
  2874. ]);
  2876. $statusCode = $response->getStatusCode();
  2877. $data = json_decode($response->getBody(), true);
  2879. // Set the data to Redis cache
  2880. $this->redisCache->set($cacheKey, $data);
  2882. return $data;
  2883. } else {
  2885. // Validate the input parameters
  2886. if (empty($coordinates)) {
  2887. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2888. }
  2890. if (!is_array($coordinates) || count($coordinates) < 1) {
  2891. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2892. }
  2894. $latitude = $coordinates[0][0] ?? null;
  2895. $longitude = $coordinates[0][1] ?? null;
  2897. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2898. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  2899. }
  2901. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  2902. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  2903. }
  2905. if (empty($startDate)) {
  2906. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2907. }
  2909. if (empty($endDate)) {
  2910. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  2911. }
  2913. if (!is_numeric($interval)) {
  2914. return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  2915. }
  2917. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  2918. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  2920. // Create a Redis key for the cache
  2921. $cacheKey = sprintf('visibility:%s,is_fog_%sh:idx', implode('_', array_map(function ($coordinate) {
  2922. return implode('_', $coordinate);
  2923. }, $coordinates)), (($startDate) . '-' . $endDate . $interval . $unit));
  2926. // Try to get the data from Redis cache
  2927. $cachedData = $this->redisCache->get($cacheKey);
  2929. if ($cachedData !== null) {
  2930. // Return the cached data if available
  2931. return $cachedData;
  2932. }
  2934. // If cache is empty, get the data from the API
  2935. $url = sprintf(
  2936. '%s/%s--%s:PT%sH/visibility:%s,is_fog_%sh:idx/%s,%s/json',
  2937. $this->apiBaseUrl,
  2938. $startDate,
  2939. $endDate,
  2940. $interval,
  2941. $unit,
  2942. $interval,
  2943. $latitude,
  2944. $longitude
  2945. );
  2948. $client = new Client(['verify' => false]);
  2951. $response = $client->request('GET', $url, [
  2952. 'auth' => [$this->username, $this->password],
  2953. ]);
  2955. $statusCode = $response->getStatusCode();
  2956. $data = json_decode($response->getBody(), true);
  2958. // Set the data to Redis cache
  2959. $this->redisCache->set($cacheKey, $data);
  2961. return $data;
  2962. }
  2963. } catch (GuzzleHttp\Exception\RequestException $e) {
  2964. return throw new \Exception($e->getMessage());
  2965. } catch (\Exception $e) {
  2966. return throw new \Exception($e->getMessage());
  2967. }
  2968. }
  2970. /**
  2971. * Icing Potential
  2972. *
  2973. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  2974. * @param string $startDate The start date for the forecast
  2975. * @param string $interval gap between duration
  2976. * @param string $duration The duration for the forecast (default: '24')
  2977. * @param string $intervalType type of interval (default: 'hour')
  2978. * @param string $format The format of the forecast data (default: 'json')
  2979. * @return array The model forecast data
  2980. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  2981. */
  2982. public function getIcingPotential(array $coordinates, string $startDate, string $duration = '24', $interval = '1', $level = '300hPa', $translator, string $format = "json")
  2983. {
  2984. try {
  2986. // Validate the input parameters
  2987. if (empty($coordinates)) {
  2988. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  2989. }
  2991. if (!is_array($coordinates) || count($coordinates) < 1) {
  2992. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  2993. }
  2995. $latitude = $coordinates[0][0] ?? null;
  2996. $longitude = $coordinates[0][1] ?? null;
  2998. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  2999. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3000. }
  3002. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  3003. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3004. }
  3006. if (empty($startDate)) {
  3007. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3008. }
  3010. if (!is_numeric($duration)) {
  3011. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  3012. }
  3014. if (!is_numeric($interval)) {
  3015. return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  3016. }
  3018. if (!in_array($level, ['1000hPa', '975hPa', '950hPa', '925hPa', '900hPa', '875hPa', '850hPa', '825hPa', '800hPa', '775hPa', '750hPa', '700hPa', '650hPa', '600hPa', '550hPa', '500hPa', '450hPa', '400hPa', '350hPa', '300hPa'])) {
  3019. return ["success" => false, "message" => $translator->trans("invalid_level")];
  3020. }
  3023. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3025. // Create a Redis key for the cache
  3026. $cacheKey = sprintf('icing_potential_%s_%s', implode('_', array_map(function ($coordinate) {
  3027. return implode('_', $coordinate);
  3028. }, $coordinates)), (($startDate) . $duration . $interval . $level));
  3031. // Try to get the data from Redis cache
  3032. $cachedData = $this->redisCache->get($cacheKey);
  3034. if ($cachedData !== null) {
  3035. // Return the cached data if available
  3036. return $cachedData;
  3037. }
  3039. // If cache is empty, get the data from the API
  3040. //https://api.meteomatics.com/2023-07-22T00:00:00ZP5D:PT1H/icing_potential_300hPa:idx,icing_potential_500hPa:idx,icing_potential_800hPa:idx/47.457625,8.555272/html
  3041. $url = sprintf(
  3042. '%s/%sP%sD:PT%sH/icing_potential_%s:idx/%s,%s/json',
  3043. $this->apiBaseUrl,
  3044. $startDate,
  3045. $duration,
  3046. $interval,
  3047. $level,
  3048. $latitude,
  3049. $longitude
  3050. );
  3052. $client = new Client(['verify' => false]);
  3055. $response = $client->request('GET', $url, [
  3056. 'auth' => [$this->username, $this->password],
  3057. ]);
  3059. $statusCode = $response->getStatusCode();
  3060. $data = json_decode($response->getBody(), true);
  3062. // Set the data to Redis cache
  3063. $this->redisCache->set($cacheKey, $data);
  3065. return $data;
  3066. } catch (GuzzleHttp\Exception\RequestException $e) {
  3067. return throw new \Exception($e->getMessage());
  3068. } catch (\Exception $e) {
  3069. return throw new \Exception($e->getMessage());
  3070. }
  3071. }
  3073. /**
  3074. * Wind Gust
  3075. *
  3076. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  3077. * @param string $startDate The start date for the forecast
  3078. * @param string $interval Gap between duration
  3079. * @param string $duration The duration for the forecast (default: '24')
  3080. * @param string $intervalType type of interval (default: 'hour')
  3081. * @param string $format The format of the forecast data (default: 'json')
  3082. * @return array The model forecast data
  3083. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3084. */
  3085. //https://api.meteomatics.com/2023-07-11T00:00:00ZP2D:PT3H/wind_dir_10m:d,wind_dir_700hPa:d/47.412164,9.340652/csv
  3086. public function getWindGust(array $coordinates, string $startDate, string $duration = '24', string $interval = '1', $height = '100', $translator, string $format = "json")
  3087. {
  3088. try {
  3090. // Validate the input parameters
  3091. if (empty($coordinates)) {
  3092. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  3093. }
  3095. if (!is_array($coordinates) || count($coordinates) < 1) {
  3096. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  3097. }
  3099. $latitude = $coordinates[0][0] ?? null;
  3100. $longitude = $coordinates[0][1] ?? null;
  3102. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  3103. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3104. }
  3106. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  3107. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3108. }
  3110. if (empty($startDate)) {
  3111. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3112. }
  3114. if (!is_numeric($duration)) {
  3115. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  3116. }
  3118. if (!in_array($duration, ['1', '3', '6', '12', '24'])) {
  3119. return ["success" => false, "message" => $translator->trans("invalid_duration")];
  3120. }
  3122. if (!is_numeric($interval)) {
  3123. return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  3124. }
  3126. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3128. // Create a Redis key for the cache
  3129. $cacheKey = sprintf('wind_gusts_%s_%s', implode('_', array_map(function ($coordinate) {
  3130. return implode('_', $coordinate);
  3131. }, $coordinates)), (($startDate) . $duration . $interval));
  3134. // Try to get the data from Redis cache
  3135. $cachedData = $this->redisCache->get($cacheKey);
  3137. if ($cachedData !== null) {
  3138. // Return the cached data if available
  3139. return $cachedData;
  3140. }
  3142. // If cache is empty, get the data from the API
  3143. // https://api.meteomatics.com/2023-07-22T00:00:00ZP4D:PT3H/wind_speed_mean_100m_3h:ms,wind_gusts_100m_3h:ms/47.412164,9.340652/html
  3144. $url = sprintf(
  3145. '%s/%sP%sD:PT%sH/wind_gusts_%s_%sh:ms/%s,%s/json',
  3146. $this->apiBaseUrl,
  3147. $startDate,
  3148. $duration,
  3149. $interval,
  3150. $height,
  3151. $interval,
  3152. $latitude,
  3153. $longitude
  3154. );
  3156. $client = new Client(['verify' => false]);
  3158. $response = $client->request('GET', $url, [
  3159. 'auth' => [$this->username, $this->password],
  3160. ]);
  3162. $statusCode = $response->getStatusCode();
  3163. $data = json_decode($response->getBody(), true);
  3165. // Set the data to Redis cache
  3166. $this->redisCache->set($cacheKey, $data);
  3168. return $data;
  3169. } catch (GuzzleHttp\Exception\RequestException $e) {
  3170. return throw new \Exception($e->getMessage());
  3171. } catch (\Exception $e) {
  3172. return throw new \Exception($e->getMessage());
  3173. }
  3174. }
  3176. /**
  3177. * Lightning Strikes
  3178. *
  3179. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  3180. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3181. */
  3182. public function getLightningStrikes(array $coordinates)
  3183. {
  3184. try {
  3186. // Validate the input parameters
  3187. if (empty($coordinates)) {
  3188. throw new \InvalidArgumentException('Invalid coordinates');
  3189. }
  3192. // Create a Redis key for the cache
  3193. $cacheKey = sprintf('lighting_strikes_%s', implode('_', array_map(function ($coordinate) {
  3194. return $coordinate;
  3195. }, $coordinates)));
  3198. // Try to get the data from Redis cache
  3199. $cachedData = $this->redisCache->get($cacheKey);
  3201. if ($cachedData !== null) {
  3202. // Return the cached data if available
  3203. // return $cachedData;
  3204. }
  3206. // If cache is empty, get the data from the API
  3207. // https://api.meteomatics.com/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=lightnings&BBOX=5.77,45.74,10.65,47.89
  3209. $url = sprintf(
  3210. '%s/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=lightnings&BBOX=%s',
  3211. $this->apiBaseUrl,
  3212. implode(",", $coordinates)
  3213. );
  3215. $client = new Client(['verify' => false]);
  3217. $response = $client->request('GET', $url, [
  3218. 'auth' => [$this->username, $this->password],
  3219. ]);
  3221. $statusCode = $response->getStatusCode();
  3222. $data = $response->getBody();
  3224. // Set the data to Redis cache
  3225. $this->redisCache->set($cacheKey, $data);
  3227. return $data;
  3228. } catch (GuzzleHttp\Exception\RequestException $e) {
  3229. return throw new \Exception($e->getMessage());
  3230. } catch (\Exception $e) {
  3231. return throw new \Exception($e->getMessage());
  3232. }
  3233. }
  3235. /**
  3236. * Fetches Turbulence data from the API or cache
  3237. *
  3238. * @param string $datetime The date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3239. * @return mixed The Turbulence data if available, or an error response
  3240. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3241. */
  3242. public function getTurbulenceData(string $datetime)
  3243. {
  3244. try {
  3245. // Validate the input parameter
  3246. if (empty($datetime)) {
  3247. throw new \InvalidArgumentException('Invalid datetime');
  3248. }
  3250. $datetime = date('Y-m-d\TH:i:s.v\Z', (strtotime($datetime)));
  3252. // Create a Redis key for the cache
  3253. $cacheKey = sprintf('turbulence_%s', $datetime);
  3255. // Try to get the data from Redis cache
  3256. $cachedData = $this->redisCache->get($cacheKey);
  3258. if ($cachedData !== null) {
  3259. // Return the cached data if available
  3260. //return $cachedData;
  3261. }
  3264. $client = new Client(['verify' => false]);
  3266. // If cache is empty, get the data from the API
  3267. $url = sprintf(
  3268. '%s/%s/turbulence_cape:m23s/global:1,1/html_map',
  3269. $this->apiBaseUrl,
  3270. $datetime
  3271. );
  3273. // Make an HTTP request to the API
  3274. $response = $client->request('GET', $url, [
  3275. 'auth' => [$this->username, $this->password],
  3276. ]);
  3279. $statusCode = $response->getStatusCode();
  3280. $data = json_decode($response->getBody(), true);
  3282. // Set the data to Redis cache
  3283. $this->redisCache->set($cacheKey, $data);
  3285. return $data;
  3286. } catch (GuzzleHttp\Exception\RequestException $e) {
  3287. // Handle Guzzle HTTP request exceptions and create and return an error response
  3288. return throw new \Exception($e->getMessage());
  3289. } catch (\Exception $e) {
  3290. // Handle other exceptions and create and return an error response
  3291. return throw new \Exception($e->getMessage());
  3292. }
  3293. }
  3295. /**
  3296. * Fetches SIGMET data from the API or cache
  3297. *
  3298. * @param string $datetime The date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3299. * @return mixed The SIGMET data if available, or an error response
  3300. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3301. */
  3302. public function getSigmetData(string $datetime, $translator)
  3303. {
  3304. try {
  3305. // Validate the input parameter
  3306. if (empty($datetime)) {
  3307. return ["success" => false, "message" => $translator->trans("invalid_datetime")];
  3308. }
  3310. $datetime = date('Y-m-d\TH:i:s.v\Z', (strtotime($datetime)));
  3312. // Create a Redis key for the cache
  3313. $cacheKey = sprintf('sigmet_%s', $datetime);
  3315. // Try to get the data from Redis cache
  3316. $cachedData = $this->redisCache->get($cacheKey);
  3318. if ($cachedData !== null) {
  3319. // Return the cached data if available
  3320. return $cachedData;
  3321. }
  3323. // If cache is empty, get the data from the API
  3324. $url = sprintf(
  3325. '%s/mvt/aviation_reports/sigmet:0/style.json?datetime=%s',
  3326. $this->apiBaseUrl,
  3327. $datetime
  3328. );
  3330. $client = new Client(['verify' => false]);
  3332. // Make an HTTP request to the API
  3333. $response = $client->request('GET', $url, [
  3334. 'auth' => [$this->username, $this->password],
  3335. ]);
  3338. $statusCode = $response->getStatusCode();
  3339. $data = json_decode($response->getBody(), true);
  3341. // Set the data to Redis cache
  3342. $this->redisCache->set($cacheKey, $data);
  3344. return $data;
  3345. } catch (GuzzleHttp\Exception\RequestException $e) {
  3346. // Handle Guzzle HTTP request exceptions and create and return an error response
  3347. return throw new \Exception($e->getMessage());
  3348. } catch (\Exception $e) {
  3349. // Handle other exceptions and create and return an error response
  3350. return throw new \Exception($e->getMessage());
  3351. }
  3352. }
  3354. /**
  3355. * Fetches Geopotential Height data from the API or cache
  3356. *
  3357. * @param array $coordinates The coordinates value
  3358. * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3359. * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3360. * @param float $level The level value
  3361. * @param float $interval The interval value
  3362. * @return mixed The Geopotential Height data if available, or an error response
  3363. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3364. */
  3365. public function getGeopotentialHeightData(array $coordinates, string $startDate, string $endDate, string $level, string $interval, $translator)
  3366. {
  3367. try {
  3369. if ($coordinates) {
  3370. $latitude = $coordinates[0][0];
  3371. $longitude = $coordinates[0][1];
  3372. }
  3374. // Validate the input parameters
  3375. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3376. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3377. }
  3378. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3379. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3380. }
  3382. if (empty($startDate) || empty($endDate)) {
  3383. return ["success" => false, "message" => $translator->trans("invalid_dates")];;
  3384. }
  3386. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3387. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3389. if (!is_numeric($interval)) {
  3390. return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  3391. }
  3393. if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa', '50hPa', '10hPa'])) {
  3394. return ["success" => false, "message" => $translator->trans("invalid_level")];
  3395. }
  3398. // Create a Redis key for the cache
  3399. $cacheKey = sprintf('geopotential_height_%s_%s_%.6f_%.6f', $startDate, $endDate, $latitude, $longitude);
  3401. // Try to get the data from Redis cache
  3402. $cachedData = $this->redisCache->get($cacheKey);
  3404. if ($cachedData !== null) {
  3405. // Return the cached data if available
  3406. return $cachedData;
  3407. }
  3409. // If cache is empty, get the data from the API
  3410. //https://api.meteomatics.com/2023-07-23T00:00:00Z--2023-07-26T00:00:00Z:PT1H/geopotential_height_500hPa:m/46.5468,7.9826/html
  3411. $url = sprintf(
  3412. '%s/%s--%s:PT%sH/geopotential_height_%s:m/%s,%s/json',
  3413. $this->apiBaseUrl,
  3414. $startDate,
  3415. $endDate,
  3416. $interval,
  3417. $level,
  3418. $latitude,
  3419. $longitude
  3420. );
  3422. $client = new Client(['verify' => false]);
  3424. // Make an HTTP request to the API
  3425. $response = $client->request('GET', $url, [
  3426. 'auth' => [$this->username, $this->password],
  3427. ]);
  3430. $statusCode = $response->getStatusCode();
  3431. $data = json_decode($response->getBody(), true);
  3433. // Set the data to Redis cache
  3434. $this->redisCache->set($cacheKey, $data);
  3436. return $data;
  3437. } catch (GuzzleHttp\Exception\RequestException $e) {
  3438. // Handle Guzzle HTTP request exceptions and create and return an error response
  3439. return throw new \Exception($e->getMessage());
  3440. } catch (\Exception $e) {
  3441. // Handle other exceptions and create and return an error response
  3442. return throw new \Exception($e->getMessage());
  3443. }
  3444. }
  3446. /**
  3447. * Pressure at Higher Altitudes data from the API or cache
  3448. *
  3449. * @param array $coordinates The coordinates value
  3450. * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3451. * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3452. * @param float $level The level value
  3453. * @param float $interval The interval value
  3454. * @return mixed The Geopotential Height data if available, or an error response
  3455. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3456. */
  3457. public function getPressureData(array $coordinates, string $startDate, string $endDate, string $level, string $interval)
  3458. {
  3459. try {
  3461. if ($coordinates) {
  3462. $latitude = $coordinates[0][0];
  3463. $longitude = $coordinates[0][1];
  3464. }
  3466. // Validate the input parameters
  3467. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3468. throw new \InvalidArgumentException('Invalid latitude');
  3469. }
  3470. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3471. throw new \InvalidArgumentException('Invalid longitude');
  3472. }
  3474. if (empty($startDate) || empty($endDate)) {
  3475. throw new \InvalidArgumentException('Invalid dates');
  3476. }
  3478. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3479. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3481. if (!is_numeric($interval)) {
  3482. throw new \InvalidArgumentException('Interval should be numeric');
  3483. }
  3485. if ($level < 1 && $level > 20000) {
  3486. throw new \InvalidArgumentException('Invalid level it should be between 1 to 20000');
  3487. }
  3489. // Create a Redis key for the cache
  3490. $cacheKey = sprintf('pressure_%s_%s_%.6f_%.6f', $startDate, $endDate, $latitude, $longitude);
  3492. // Try to get the data from Redis cache
  3493. $cachedData = $this->redisCache->get($cacheKey);
  3495. if ($cachedData !== null) {
  3496. // Return the cached data if available
  3497. return $cachedData;
  3498. }
  3500. // If cache is empty, get the data from the API
  3501. ///pressure_1000m:hPa/-16.489689,-68.119293/html
  3502. $url = sprintf(
  3503. '%s/%s--%s:PT%sH/pressure_%sm:hPa/%s,%s/json',
  3504. $this->apiBaseUrl,
  3505. $startDate,
  3506. $endDate,
  3507. $interval,
  3508. $level,
  3509. $latitude,
  3510. $longitude
  3511. );
  3513. $client = new Client(['verify' => false]);
  3515. // Make an HTTP request to the API
  3516. $response = $client->request('GET', $url, [
  3517. 'auth' => [$this->username, $this->password],
  3518. ]);
  3521. $statusCode = $response->getStatusCode();
  3522. $data = json_decode($response->getBody(), true);
  3524. // Set the data to Redis cache
  3525. $this->redisCache->set($cacheKey, $data);
  3527. return $data;
  3528. } catch (GuzzleHttp\Exception\RequestException $e) {
  3529. // Handle Guzzle HTTP request exceptions and create and return an error response
  3530. return throw new \Exception($e->getMessage());
  3531. } catch (\Exception $e) {
  3532. // Handle other exceptions and create and return an error response
  3533. return throw new \Exception($e->getMessage());
  3534. }
  3535. }
  3538. /**
  3539. * Cloud Cover data from the API or cache
  3540. *
  3541. * @param array $coordinates The coordinates value
  3542. * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3543. * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3544. * @param float $level The level value
  3545. * @param float $interval The interval value
  3546. * @return mixed The Geopotential Height data if available, or an error response
  3547. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3548. */
  3549. public function getCloudCover(array $coordinates, string $startDate, string $endDate, $translator)
  3550. {
  3551. try {
  3553. if ($coordinates) {
  3554. $latitude = $coordinates[0][0];
  3555. $longitude = $coordinates[0][1];
  3556. }
  3558. // Validate the input parameters
  3559. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3560. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3561. }
  3562. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3563. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3564. }
  3566. if (empty($startDate) || empty($endDate)) {
  3567. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3568. }
  3570. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3571. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3573. // Create a Redis key for the cache
  3574. $cacheKey = sprintf('cloud_cover_%s_%s_%.6f_%.6f', $startDate, $endDate, $latitude, $longitude);
  3576. // Try to get the data from Redis cache
  3577. $cachedData = $this->redisCache->get($cacheKey);
  3579. if ($cachedData !== null) {
  3580. // Return the cached data if available
  3581. return $cachedData;
  3582. }
  3584. // If cache is empty, get the data from the API
  3585. $url = sprintf(
  3586. '%s/%s/effective_cloud_cover:octas/%s,%s/json',
  3587. $this->apiBaseUrl,
  3588. $startDate,
  3589. $latitude,
  3590. $longitude
  3591. );
  3593. $client = new Client(['verify' => false]);
  3595. // Make an HTTP request to the API
  3596. $response = $client->request('GET', $url, [
  3597. 'auth' => [$this->username, $this->password],
  3598. ]);
  3601. $statusCode = $response->getStatusCode();
  3602. $data = json_decode($response->getBody(), true);
  3604. // Set the data to Redis cache
  3605. $this->redisCache->set($cacheKey, $data);
  3607. return $data;
  3608. } catch (GuzzleHttp\Exception\RequestException $e) {
  3609. // Handle Guzzle HTTP request exceptions and create and return an error response
  3610. return throw new \Exception($e->getMessage());
  3611. } catch (\Exception $e) {
  3612. // Handle other exceptions and create and return an error response
  3613. return throw new \Exception($e->getMessage());
  3614. }
  3615. }
  3617. /**
  3618. * Wind Speed vertical components data from the API or cache
  3619. *
  3620. * @param array $coordinates The coordinates value
  3621. * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3622. * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3623. * @param int $level The day value
  3624. * @param string $level The level value
  3625. * @param string $unit The level value
  3626. * @param intervalInMinutes $interval The interval value
  3627. * @return mixed The Geopotential Height data if available, or an error response
  3628. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3629. */
  3630. public function getWindSpeedVerticalComponents(array $coordinates, string $startDate, int $day, int $intervalInMinutes, string $level, string $unit, $translator)
  3631. {
  3632. try {
  3634. if ($coordinates) {
  3635. $latitude = $coordinates[0][0];
  3636. $longitude = $coordinates[0][1];
  3637. }
  3639. // Validate the input parameters
  3640. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3641. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3642. }
  3643. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3644. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3645. }
  3647. if (empty($startDate)) {
  3648. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3649. }
  3651. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3653. if (!is_numeric($day)) {
  3654. return ["success" => false, "message" => $translator->trans("day_should_be_numeric")];
  3655. }
  3657. if (!is_numeric($intervalInMinutes)) {
  3658. return ["success" => false, "message" => $translator->trans("interval_in_minute_should_be_numeric")];
  3659. }
  3661. if (!in_array($level, ['1000hPa', '950hPa', '925hPa', '900hPa', '850hPa', '800hPa', '700hPa', '500hPa', '300hPa', '250hPa', '200hPa', '150hPa', '100hPa', '70hPa'])) {
  3662. return ["success" => false, "message" => $translator->trans("invalid_level")];
  3663. }
  3665. // Create a Redis key for the cache
  3666. $cacheKey = sprintf('wind_speed_vertical_%s_%s_%s_%s_%.6f_%.6f', $startDate, $day, $level, $unit, $latitude, $longitude);
  3668. // Try to get the data from Redis cache
  3669. $cachedData = $this->redisCache->get($cacheKey);
  3671. if ($cachedData !== null) {
  3672. // Return the cached data if available
  3673. return $cachedData;
  3674. }
  3677. // If cache is empty, get the data from the API
  3678. $url = sprintf(
  3679. '%s/%sP%sD:PT%sM/wind_speed_w_%s:%s/%s,%s/json',
  3680. $this->apiBaseUrl,
  3681. $startDate,
  3682. $day,
  3683. $intervalInMinutes,
  3684. $level,
  3685. $unit,
  3686. $latitude,
  3687. $longitude
  3688. );
  3690. $client = new Client(['verify' => false]);
  3692. // Make an HTTP request to the API
  3693. $response = $client->request('GET', $url, [
  3694. 'auth' => [$this->username, $this->password],
  3695. ]);
  3697. $data = json_decode($response->getBody(), true);
  3699. // Set the data to Redis cache
  3700. $this->redisCache->set($cacheKey, $data);
  3702. return $data;
  3703. } catch (GuzzleHttp\Exception\RequestException $e) {
  3704. // Handle Guzzle HTTP request exceptions and create and return an error response
  3705. return throw new \Exception($e->getMessage());
  3706. } catch (\Exception $e) {
  3707. // Handle other exceptions and create and return an error response
  3708. return throw new \Exception($e->getMessage());
  3709. }
  3710. }
  3712. /**
  3713. * Wind Power data from the API or cache
  3714. * @param array $coordinates The coordinates value
  3715. * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3716. * @param string $endDate The end date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3717. * @param int $intervalInMinutes The interval value
  3718. * @param int $height The height value
  3719. * @param float $unit The interval value
  3720. * @return mixed The Geopotential Height data if available, or an error response
  3721. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3722. */
  3723. public function getWindPower(array $coordinates, string $startDate, string $endDate, int $height, int $intervalInMinutes, string $unit, string $turbine_id, $translator)
  3724. {
  3725. try {
  3727. if ($coordinates) {
  3728. $latitude = $coordinates[0][0];
  3729. $longitude = $coordinates[0][1];
  3730. }
  3732. // Validate the input parameters
  3733. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3734. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3735. }
  3736. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3737. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3738. }
  3740. if (empty($startDate)) {
  3741. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3742. }
  3744. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3745. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3748. if (!is_numeric($intervalInMinutes)) {
  3749. return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];
  3750. }
  3752. if (!is_numeric($height)) {
  3753. return ["success" => false, "message" => $translator->trans("height_should_be_numeric")];
  3754. }
  3756. // Create a Redis key for the cache
  3757. $cacheKey = sprintf('wind_power_%s_%s_%s_%s_%s', $startDate, $endDate, $height, $unit, $intervalInMinutes);
  3759. // Try to get the data from Redis cache
  3760. $cachedData = $this->redisCache->get($cacheKey);
  3762. if ($cachedData !== null) {
  3763. // Return the cached data if available
  3764. return $cachedData;
  3765. }
  3767. // If cache is empty, get the data from the API
  3768. $url = sprintf(
  3769. '%s/%s--%s:PT%sM/wind_power_turbine_%s_hub_height_%sm:%s,wind_power_turbine_siemens_swt_2_3_93_2300_hub_height_%sm:%s,wind_power_turbine_enercon_e66_2000_hub_height_%sm:%s/%s,%s/json',
  3770. $this->apiBaseUrl,
  3771. $startDate,
  3772. $endDate,
  3773. $intervalInMinutes,
  3774. $turbine_id,
  3775. $height,
  3776. $unit,
  3777. $height,
  3778. $unit,
  3779. $height,
  3780. $unit,
  3781. $latitude,
  3782. $longitude
  3783. );
  3785. $client = new Client(['verify' => false]);
  3787. // Make an HTTP request to the API
  3788. $response = $client->request('GET', $url, [
  3789. 'auth' => [$this->username, $this->password],
  3790. ]);
  3792. $data = json_decode($response->getBody(), true);
  3794. // Set the data to Redis cache
  3795. $this->redisCache->set($cacheKey, $data);
  3797. return $data;
  3798. } catch (GuzzleHttp\Exception\RequestException $e) {
  3799. // Handle Guzzle HTTP request exceptions and create and return an error response
  3800. return throw new \Exception($e->getMessage());
  3801. } catch (\Exception $e) {
  3802. // Handle other exceptions and create and return an error response
  3803. return throw new \Exception($e->getMessage());
  3804. }
  3805. }
  3807. /**
  3808. * Radiation data from the API or cache
  3809. * @param array $coordinates The coordinates value
  3810. * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3811. * @param int $intervalInHours The interval value
  3812. * @param int $day The day value
  3813. * @param string $typeOfRadiation should be one of these "clear_sky_rad","diffuse_rad","direct_rad","global_rad"
  3814. * @return mixed The Geopotential Height data if available, or an error response
  3815. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3816. */
  3817. public function getRadiation(array $coordinates, string $startDate, int $day, int $intervalInHours, string $typeOfRadiation, $translator)
  3818. {
  3819. try {
  3821. if ($coordinates) {
  3822. $latitude = $coordinates[0][0];
  3823. $longitude = $coordinates[0][1];
  3824. }
  3826. // Validate the input parameters
  3827. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3828. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3829. }
  3830. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3831. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3832. }
  3834. if (empty($startDate)) {
  3835. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  3836. }
  3837. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3840. if (!is_numeric($intervalInHours)) {
  3841. return ["success" => false, "message" => $translator->trans("interval_in_hour_should_be_numeric")];
  3842. }
  3844. if (!is_numeric($day)) {
  3845. return ["success" => false, "message" => $translator->trans("day_should_be_numeric")];
  3846. }
  3848. if (!in_array($typeOfRadiation, ["clear_sky_rad", "diffuse_rad", "direct_rad", "global_rad"])) {
  3849. // throw new \InvalidArgumentException('Radiation type should be one of these "clear_sky_rad","diffuse_rad","direct_rad","global_rad"');
  3850. return ["success" => false, "message" => $translator->trans("Radiation_should_be_type:'clear_sky_rad','diffuse_rad','direct_rad','global_rad'")];
  3851. }
  3853. // Create a Redis key for the cache
  3854. $cacheKey = sprintf('radiation_%s_%s_%s_%s_%s_%s', $startDate, $day, $intervalInHours, $typeOfRadiation, $latitude, $longitude);
  3856. // Try to get the data from Redis cache
  3857. $cachedData = $this->redisCache->get($cacheKey);
  3859. if ($cachedData !== null) {
  3860. // Return the cached data if available
  3861. return $cachedData;
  3862. }
  3864. // If cache is empty, get the data from the API
  3865. $url = sprintf(
  3866. '%s/%sP%sD:PT%sH/%s:W/%s,%s/json',
  3867. $this->apiBaseUrl,
  3868. $startDate,
  3869. $day,
  3870. $intervalInHours,
  3871. $typeOfRadiation,
  3872. $latitude,
  3873. $longitude
  3874. );
  3876. $client = new Client(['verify' => false]);
  3878. // Make an HTTP request to the API
  3879. $response = $client->request('GET', $url, [
  3880. 'auth' => [$this->username, $this->password],
  3881. ]);
  3883. $data = json_decode($response->getBody(), true);
  3885. // Set the data to Redis cache
  3886. $this->redisCache->set($cacheKey, $data);
  3888. return $data;
  3889. } catch (GuzzleHttp\Exception\RequestException $e) {
  3890. // Handle Guzzle HTTP request exceptions and create and return an error response
  3891. return throw new \Exception($e->getMessage());
  3892. } catch (\Exception $e) {
  3893. // Handle other exceptions and create and return an error response
  3894. return throw new \Exception($e->getMessage());
  3895. }
  3896. }
  3898. /**
  3899. * Solar Power data from the API or cache
  3900. * @param array $coordinates The coordinates value
  3901. * @param string $startDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3902. * @param string $endDate The start date and time in the format "YYYY-MM-DDTHH:MM:SSZ"
  3903. * @param int $intervalInHours The interval value
  3904. * @param int $hour The hour value
  3905. * @param string $unit The unit value
  3906. * @param string $specification would be like this "installed_capacity_<capacity>"
  3907. * @return mixed The Geopotential Height data if available, or an error response
  3908. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  3909. */
  3910. public function getSolarPower(array $coordinates, string $startDate, string $endDate, int $intervalInHours, string $hour, string $unit, string $specification, $translator)
  3911. {
  3912. try {
  3914. if ($coordinates) {
  3915. $latitude = $coordinates[0][0];
  3916. $longitude = $coordinates[0][1];
  3917. }
  3919. // Validate the input parameters
  3920. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  3921. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  3922. }
  3923. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  3924. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  3925. }
  3927. if (empty($startDate)) {
  3928. return ["success" => false, "message" => $translator->trans("invalid_start_date")];
  3929. }
  3931. if (empty($endDate)) {
  3932. return ["success" => false, "message" => $translator->trans("invalid_end_date")];
  3933. }
  3935. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  3936. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  3939. if (!is_numeric($intervalInHours)) {
  3940. return ["success" => false, "message" => $translator->trans("interval_should_be_numeric")];;
  3941. }
  3943. if (!is_numeric($hour)) {
  3944. return ["success" => false, "message" => $translator->trans("hours_should_be_numeric")];
  3945. }
  3948. // Create a Redis key for the cache
  3949. $cacheKey = sprintf('solar_power_%s_%s_%s_%s_%s_%s_%s', $specification, $startDate, $endDate, $unit, $hour, $latitude, $longitude);
  3951. // Try to get the data from Redis cache
  3952. $cachedData = $this->redisCache->get($cacheKey);
  3954. if ($cachedData !== null) {
  3955. // Return the cached data if available
  3956. return $cachedData;
  3957. }
  3959. // If cache is empty, get the data from the API
  3960. $url = sprintf(
  3961. '%s/%s--%s:PT%sH/solar_power_%s:%s/%s,%s/json',
  3962. $this->apiBaseUrl,
  3963. $startDate,
  3964. $endDate,
  3965. $hour,
  3966. $specification,
  3967. $unit,
  3968. $latitude,
  3969. $longitude
  3970. );
  3971. // p_r($url);
  3972. // exit;
  3973. $client = new Client(['verify' => false]);
  3975. // Make an HTTP request to the API
  3976. $response = $client->request('GET', $url, [
  3977. 'auth' => [$this->username, $this->password],
  3978. ]);
  3980. $data = json_decode($response->getBody(), true);
  3982. // Set the data to Redis cache
  3983. $this->redisCache->set($cacheKey, $data);
  3985. return $data;
  3986. } catch (GuzzleHttp\Exception\RequestException $e) {
  3987. // Handle Guzzle HTTP request exceptions and create and return an error response
  3988. return throw new \Exception($e->getMessage());
  3989. } catch (\Exception $e) {
  3990. // Handle other exceptions and create and return an error response
  3991. return throw new \Exception($e->getMessage());
  3992. }
  3993. }
  3995. /**
  3996. * Rainfall
  3997. *
  3998. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  3999. * @param string $startDate The start date for the forecast
  4000. * @param string $endDate The end date for the forecast
  4001. * @param string $duration The duration for the forecast (default: '24')
  4002. * @param string $intervalType type of interval (default: 'hour')
  4003. * @param string $format The format of the forecast data (default: 'json')
  4004. * @return array The model forecast data
  4005. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  4006. */
  4007. public function getRainfall(array $coordinates, string $startDate, string $endDate, string $duration = '24', $translator, string $format = "json")
  4008. {
  4009. try {
  4011. // Validate the input parameters
  4012. if (empty($coordinates)) {
  4013. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  4014. }
  4016. if (!is_array($coordinates) || count($coordinates) < 1) {
  4017. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  4018. }
  4020. $latitude = $coordinates[0][0] ?? null;
  4021. $longitude = $coordinates[0][1] ?? null;
  4023. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4024. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  4025. }
  4027. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4028. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  4029. }
  4031. if (empty($startDate) || empty($endDate)) {
  4032. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  4033. }
  4035. if (!is_numeric($duration)) {
  4036. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  4037. }
  4040. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4041. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4043. // Create a Redis key for the cache
  4044. $cacheKey = sprintf('rainfall_%s_%s', implode('_', array_map(function ($coordinate) {
  4045. return implode('_', $coordinate);
  4046. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  4049. // Try to get the data from Redis cache
  4050. $cachedData = $this->redisCache->get($cacheKey);
  4052. if ($cachedData !== null) {
  4053. // Return the cached data if available
  4054. return $cachedData;
  4055. }
  4057. // If cache is empty, get the data from the API
  4058. $url = sprintf(
  4059. '%s/%s--%s:PT%sM/is_rain_%smin:idx/%s,%s/json',
  4060. $this->apiBaseUrl,
  4061. $startDate,
  4062. $endDate,
  4063. $duration,
  4064. $duration,
  4065. $latitude,
  4066. $longitude
  4067. );
  4069. $client = new Client(['verify' => false]);
  4072. $response = $client->request('GET', $url, [
  4073. 'auth' => [$this->username, $this->password],
  4074. ]);
  4076. $statusCode = $response->getStatusCode();
  4077. $data = json_decode($response->getBody(), true);
  4079. // Set the data to Redis cache
  4080. $this->redisCache->set($cacheKey, $data);
  4082. return $data;
  4083. } catch (GuzzleHttp\Exception\RequestException $e) {
  4084. return throw new \Exception($e->getMessage());
  4085. } catch (\Exception $e) {
  4086. return throw new \Exception($e->getMessage());
  4087. }
  4088. }
  4090. /**
  4091. * Dew Point
  4092. *
  4093. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4094. * @param string $startDate The start date for the forecast
  4095. * @param string $endDate The end date for the forecast
  4096. * @param string $duration The duration for the forecast (default: '24')
  4097. * @param string $intervalType type of interval (default: 'hour')
  4098. * @param string $format The format of the forecast data (default: 'json')
  4099. * @return array The model forecast data
  4100. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  4101. */
  4102. public function getDewPoint(array $coordinates, string $startDate, string $endDate, string $duration = '24', $translator, string $format = "json")
  4103. {
  4104. try {
  4106. // Validate the input parameters
  4107. if (empty($coordinates)) {
  4108. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  4109. }
  4111. if (!is_array($coordinates) || count($coordinates) < 1) {
  4112. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  4113. }
  4115. $latitude = $coordinates[0][0] ?? null;
  4116. $longitude = $coordinates[0][1] ?? null;
  4118. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4119. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  4120. }
  4122. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4123. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  4124. }
  4126. if (empty($startDate) || empty($endDate)) {
  4127. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  4128. }
  4130. if (!is_numeric($duration)) {
  4131. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  4132. }
  4135. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4136. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4138. // Create a Redis key for the cache
  4139. $cacheKey = sprintf('dew_point_%s_%s', implode('_', array_map(function ($coordinate) {
  4140. return implode('_', $coordinate);
  4141. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  4144. // Try to get the data from Redis cache
  4145. $cachedData = $this->redisCache->get($cacheKey);
  4147. if ($cachedData !== null) {
  4148. // Return the cached data if available
  4149. return $cachedData;
  4150. }
  4152. // If cache is empty, get the data from the API
  4153. $url = sprintf(
  4154. '%s/%s--%s:PT%sH/dew_point_2m:C/%s,%s/json',
  4155. $this->apiBaseUrl,
  4156. $startDate,
  4157. $endDate,
  4158. $duration,
  4159. $latitude,
  4160. $longitude
  4161. );
  4163. $client = new Client(['verify' => false]);
  4166. $response = $client->request('GET', $url, [
  4167. 'auth' => [$this->username, $this->password],
  4168. ]);
  4170. $statusCode = $response->getStatusCode();
  4171. $data = json_decode($response->getBody(), true);
  4173. // Set the data to Redis cache
  4174. $this->redisCache->set($cacheKey, $data);
  4176. return $data;
  4177. } catch (GuzzleHttp\Exception\RequestException $e) {
  4178. return throw new \Exception($e->getMessage());
  4179. } catch (\Exception $e) {
  4180. return throw new \Exception($e->getMessage());
  4181. }
  4182. }
  4184. /**
  4185. * Wms
  4186. *
  4187. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  4188. */
  4189. public function getWms($params)
  4190. {
  4191. try {
  4193. // If cache is empty, get the data from the API
  4194. $url = sprintf(
  4195. '%s/wms?%s',
  4196. $this->apiBaseUrl,
  4197. $params['param']
  4198. );
  4200. $client = new Client(['verify' => false]);
  4201. $response = $client->request('GET', $url, [
  4202. 'auth' => [$this->username, $this->password],
  4203. ]);
  4205. return $response->getBody();
  4206. } catch (GuzzleHttp\Exception\RequestException $e) {
  4207. return throw new \Exception($e->getMessage());
  4208. } catch (\Exception $e) {
  4209. return throw new \Exception($e->getMessage());
  4210. }
  4211. }
  4213. /**
  4214. * Wind
  4215. *
  4216. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4217. * @param string $startDate The start date for the forecast
  4218. * @param string $endDate The end date for the forecast
  4219. * @param string $duration The duration for the forecast (default: '24')
  4220. * @param string $intervalType type of interval (default: 'hour')
  4221. * @param string $format The format of the forecast data (default: 'json')
  4222. * @return array The model forecast data
  4223. * @throws \InvalidArgumentException If any of the parameters are invalid or missing
  4224. */
  4225. public function getWind(array $coordinates, string $startDate, string $endDate, string $duration = '24', $translator, string $format = "json")
  4226. {
  4227. try {
  4229. // Validate the input parameters
  4230. if (empty($coordinates)) {
  4231. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  4232. }
  4234. if (!is_array($coordinates) || count($coordinates) < 1) {
  4235. return ["success" => false, "message" => $translator->trans("coordinates_should_be_a_non_empty_array")];
  4236. }
  4238. $latitude = $coordinates[0][0] ?? null;
  4239. $longitude = $coordinates[0][1] ?? null;
  4241. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4242. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  4243. }
  4245. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4246. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  4247. }
  4249. if (empty($startDate) || empty($endDate)) {
  4250. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  4251. }
  4253. if (!is_numeric($duration)) {
  4254. return ["success" => false, "message" => $translator->trans("duration_should_be_numeric")];
  4255. }
  4258. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4259. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4261. // Create a Redis key for the cache
  4262. $cacheKey = sprintf('wind_%s_%s', implode('_', array_map(function ($coordinate) {
  4263. return implode('_', $coordinate);
  4264. }, $coordinates)), (($startDate) . '-' . ($endDate) . $duration));
  4267. // Try to get the data from Redis cache
  4268. $cachedData = $this->redisCache->get($cacheKey);
  4270. if ($cachedData !== null) {
  4271. // Return the cached data if available
  4272. return $cachedData;
  4273. }
  4275. // If cache is empty, get the data from the API
  4276. $url = sprintf(
  4277. '%s/%s--%s:PT%sH/wind_speed_u_10m:ms,wind_speed_v_10m:ms/%s,%s/json',
  4278. $this->apiBaseUrl,
  4279. $startDate,
  4280. $endDate,
  4281. $duration,
  4282. $latitude,
  4283. $longitude
  4284. );
  4286. $client = new Client(['verify' => false]);
  4289. $response = $client->request('GET', $url, [
  4290. 'auth' => [$this->username, $this->password],
  4291. ]);
  4293. $statusCode = $response->getStatusCode();
  4294. $data = json_decode($response->getBody(), true);
  4296. // Set the data to Redis cache
  4297. $this->redisCache->set($cacheKey, $data);
  4299. return $data;
  4300. } catch (GuzzleHttp\Exception\RequestException $e) {
  4301. return throw new \Exception($e->getMessage());
  4302. } catch (\Exception $e) {
  4303. return throw new \Exception($e->getMessage());
  4304. }
  4305. }
  4307. /**
  4308. * Wind by location
  4309. *
  4310. * @param string $time The type of data time (e.g., '2023-09-01')
  4311. * @param string $location The latitude and longitude of location
  4312. * @param string $format return type of json
  4313. * @throws \InvalidArgumentException If any parameter has an invalid data type
  4314. */
  4315. public function getWindByLocation(
  4316. string $time,
  4317. string $location,
  4318. string $format = 'json'
  4319. ) {
  4321. if (!is_string($time)) {
  4322. throw new \InvalidArgumentException('Invalid data type for $time. Expected string.');
  4323. }
  4324. if (!is_string($location)) {
  4325. throw new \InvalidArgumentException('Invalid data type for $location. Expected string.');
  4326. }
  4327. if (!is_string($format)) {
  4328. throw new \InvalidArgumentException('Invalid data type for $format. Expected string.');
  4329. }
  4331. $cacheKey = sprintf('wind_location_%s_%s', $time, $location);
  4333. // Try to get the data from Redis cache
  4334. $cachedData = $this->redisCache->get($cacheKey);
  4336. if ($cachedData !== null) {
  4337. // Return the cached data if available
  4338. return $cachedData;
  4339. }
  4342. try {
  4343. // If cache is empty, get the data from the API
  4344. $client = new Client(['verify' => false]);
  4345. $url = sprintf(
  4346. '%s/%s/wind_speed_u_10m:ms,wind_speed_v_10m:ms/%s/%s',
  4347. $this->apiBaseUrl,
  4348. $time,
  4349. $location,
  4350. $format
  4351. );
  4352. $response = $client->request('GET', $url, [
  4353. 'auth' => [$this->username, $this->password],
  4354. ]);
  4355. $data = json_decode($response->getBody(), true);
  4357. // Set the data to Redis cache
  4358. $this->redisCache->set($cacheKey, $data);
  4360. return $data;
  4361. } catch (GuzzleHttp\Exception\RequestException $e) {
  4362. return throw new \Exception($e->getMessage());
  4363. } catch (\Exception $e) {
  4364. return throw new \Exception($e->getMessage());
  4365. }
  4366. }
  4368. /**
  4369. * Water Temperature
  4370. *
  4371. * @param string $query The type of data request (e.g., 't_sea_sfc:ms')
  4372. * @param string $format return type of json
  4373. * @param string $date The type of data date (e.g., '2023-09-01')
  4374. * @param array $coordinates The latitude and longitude of location in array
  4375. * @param string $dimensions type of data (e.g., '500x300')
  4376. * @param string $modal type of data (e.g., 'noaa-hycom', 'ecmwf-cmems', 'noaa-hycom')
  4377. * @throws \InvalidArgumentException If any parameter has an invalid data type
  4378. */
  4379. public function getWaterTempereture(
  4380. string $query,
  4381. array $coordinates,
  4382. string $dimensions,
  4383. string $format,
  4384. string $date,
  4385. string $modal
  4386. ) {
  4388. try {
  4390. if (empty($query)) {
  4391. throw new \InvalidArgumentException('Invalid query');
  4392. }
  4394. if (empty($date)) {
  4395. throw new \InvalidArgumentException('Invalid date');
  4396. }
  4397. $date = date('Y-m-d\TH:i:s\Z', (strtotime($date)));
  4400. foreach ($coordinates as $coordinate) {
  4401. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4402. throw new \InvalidArgumentException('Invalid coordinates');
  4403. }
  4404. }
  4406. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  4408. $cacheKey = \App\Lib\Utility::generateKey($query, $coordinates, $dimensions, $date, $format, $modal);
  4410. // Try to get the data from Redis cache
  4411. $cachedData = $this->redisCache->get($cacheKey);
  4413. if ($cachedData !== null) {
  4414. // Return the cached data if available
  4415. return $cachedData;
  4416. }
  4420. // If cache is empty, get the data from the API
  4421. $client = new Client(['verify' => false]);
  4422. $url = sprintf(
  4423. '%s/%s/%s/%s:%s/%s?%s',
  4424. $this->apiBaseUrl,
  4425. $date,
  4426. $query,
  4427. $coordinateString,
  4428. $dimensions,
  4429. $format,
  4430. $modal
  4431. );
  4433. $response = $client->request('GET', $url, [
  4434. 'auth' => [$this->username, $this->password],
  4435. ]);
  4437. if ($format == "json") {
  4438. $data = json_decode($response->getBody(), true);
  4439. } else {
  4440. $data = $response->getBody();
  4441. }
  4444. // Set the data to Redis cache
  4445. $this->redisCache->set($cacheKey, $data);
  4447. return $data;
  4448. } catch (GuzzleHttp\Exception\RequestException $e) {
  4449. return throw new \Exception($e->getMessage());
  4450. } catch (\Exception $e) {
  4451. return throw new \Exception($e->getMessage());
  4452. }
  4453. }
  4455. /**
  4456. * Ocean Current
  4457. *
  4458. * @param string $query The type of data request (e.g., 'ocean_current_speed_2m:ms')
  4459. * @param string $format return type of json
  4460. * @param string $date The type of data date (e.g., '2023-09-01')
  4461. * @param array $coordinates The latitude and longitude of location in array
  4462. * @param string $dimensions type of data (e.g., '500x300')
  4463. * @throws \InvalidArgumentException If any parameter has an invalid data type
  4464. */
  4465. public function getOceanCurrent(
  4466. string $query,
  4467. array $coordinates,
  4468. string $dimensions,
  4469. string $format,
  4470. string $date
  4471. ) {
  4472. try {
  4474. if (empty($query)) {
  4475. throw new \InvalidArgumentException('Invalid query');
  4476. }
  4478. if (empty($date)) {
  4479. throw new \InvalidArgumentException('Invalid dates');
  4480. }
  4481. $date = date('Y-m-d\TH:i:s\Z', (strtotime($date)));
  4484. foreach ($coordinates as $coordinate) {
  4485. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4486. throw new \InvalidArgumentException('Invalid coordinates');
  4487. }
  4488. }
  4490. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  4492. $cacheKey = \App\Lib\Utility::generateKey($query, $coordinates, $dimensions, $date, $format);
  4494. // Try to get the data from Redis cache
  4495. $cachedData = $this->redisCache->get($cacheKey);
  4497. if ($cachedData !== null) {
  4498. // Return the cached data if available
  4499. return $cachedData;
  4500. }
  4504. // If cache is empty, get the data from the API
  4505. $client = new Client(['verify' => false]);
  4506. $url = sprintf(
  4507. '%s/%s/%s/%s:%s/%s',
  4508. $this->apiBaseUrl,
  4509. $date,
  4510. $query,
  4511. $coordinateString,
  4512. $dimensions,
  4513. $format
  4514. );
  4516. $response = $client->request('GET', $url, [
  4517. 'auth' => [$this->username, $this->password],
  4518. ]);
  4520. if ($format == "json") {
  4521. $data = json_decode($response->getBody(), true);
  4522. } else {
  4523. $data = $response->getBody();
  4524. }
  4527. // Set the data to Redis cache
  4528. $this->redisCache->set($cacheKey, $data);
  4530. return $data;
  4531. } catch (GuzzleHttp\Exception\RequestException $e) {
  4532. return throw new \Exception($e->getMessage());
  4533. } catch (\Exception $e) {
  4534. return throw new \Exception($e->getMessage());
  4535. }
  4536. }
  4538. /**
  4539. * Oceanic Tides
  4540. *
  4541. * @param string $query The type of data request (e.g., 'tidal_amplitude:cm')
  4542. * @param string $format return type of json
  4543. * @param string $date The type of data date (e.g., '2023-09-01')
  4544. * @param array $latitude The latitude of location
  4545. * @param array $longitude The longitude of location
  4546. * @param string $dimensions type of data (e.g., '500x300')
  4547. * @throws \InvalidArgumentException If any parameter has an invalid data type
  4548. */
  4549. public function getOceanicTides(
  4550. string $query,
  4551. string $latitude,
  4552. string $longitude,
  4553. string $date,
  4554. string $format,
  4555. string $resolution,
  4556. string $model
  4557. ) {
  4560. try {
  4562. if (empty($query)) {
  4563. throw new \InvalidArgumentException('Invalid query');
  4564. }
  4566. if (empty($date)) {
  4567. throw new \InvalidArgumentException('Invalid dates');
  4568. }
  4570. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4571. throw new \InvalidArgumentException('Invalid latitude');
  4572. }
  4574. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4575. throw new \InvalidArgumentException('Invalid longitude');
  4576. }
  4578. $date = date('Y-m-d\TH:i:s\Z', (strtotime($date)));
  4581. $cacheKey = \App\Lib\Utility::generateKey($query, $latitude, $longitude, $date, $format, $resolution, $model);
  4583. // Try to get the data from Redis cache
  4584. $cachedData = $this->redisCache->get($cacheKey);
  4586. if ($cachedData !== null) {
  4587. // Return the cached data if available
  4588. return $cachedData;
  4589. }
  4593. // If cache is empty, get the data from the API
  4594. $client = new Client(['verify' => false]);
  4595. $url = sprintf(
  4596. '%s/%s%s/%s/%s,%s/%s?%s',
  4597. $this->apiBaseUrl,
  4598. $date,
  4599. $resolution,
  4600. $query,
  4601. $latitude,
  4602. $longitude,
  4603. $format,
  4604. $model
  4606. );
  4608. $response = $client->request('GET', $url, [
  4609. 'auth' => [$this->username, $this->password],
  4610. ]);
  4612. if ($format == "json") {
  4613. $data = json_decode($response->getBody(), true);
  4614. } else {
  4615. $data = $response->getBody();
  4616. }
  4619. // Set the data to Redis cache
  4620. $this->redisCache->set($cacheKey, $data);
  4622. return $data;
  4623. } catch (GuzzleHttp\Exception\RequestException $e) {
  4624. return throw new \Exception($e->getMessage());
  4625. } catch (\Exception $e) {
  4626. return throw new \Exception($e->getMessage());
  4627. }
  4628. }
  4630. /**
  4631. * Drought Index
  4632. *
  4633. * @param string $query The type of data request (e.g., 'drought_index:idx/Asia')
  4634. * @param string $format return type of json or html_map
  4635. * @param string $startDate The type of data date (e.g., '2023-09-01')
  4636. * @param string $longitude The longitude of location
  4637. * @param string $latitude The latitude of location
  4638. * @throws \InvalidArgumentException If any parameter has an invalid data type
  4639. */
  4640. public function getDroughtIndex(
  4641. string $query,
  4642. string $latitude,
  4643. string $longitude,
  4644. string $date,
  4645. string $format,
  4647. ) {
  4648. try {
  4650. if (empty($query)) {
  4651. throw new \InvalidArgumentException('Invalid query');
  4652. }
  4654. if (empty($date)) {
  4655. throw new \InvalidArgumentException('Invalid dates');
  4656. }
  4658. if (!is_numeric($latitude) || $latitude < -90 || $latitude > 90) {
  4659. throw new \InvalidArgumentException('Invalid latitude');
  4660. }
  4662. if (!is_numeric($longitude) || $longitude < -180 || $longitude > 180) {
  4663. throw new \InvalidArgumentException('Invalid longitude');
  4664. }
  4668. $date = date('Y-m-d\TH:i:s\Z', (strtotime($date)));
  4672. $cacheKey = \App\Lib\Utility::generateKey($query, $latitude, $longitude, $date, $format);
  4674. // Try to get the data from Redis cache
  4675. $cachedData = $this->redisCache->get($cacheKey);
  4677. if ($cachedData !== null) {
  4678. // Return the cached data if available
  4679. return $cachedData;
  4680. }
  4684. // If cache is empty, get the data from the API
  4685. $client = new Client(['verify' => false]);
  4686. $url = sprintf(
  4687. '%s/%s/%s:%s,%s/%s',
  4688. $this->apiBaseUrl,
  4689. $date,
  4690. $query,
  4691. $latitude,
  4692. $longitude,
  4693. $format
  4695. );
  4697. $response = $client->request('GET', $url, [
  4698. 'auth' => [$this->username, $this->password],
  4699. ]);
  4701. if ($format == "json") {
  4702. $data = json_decode($response->getBody(), true);
  4703. } else {
  4704. $data = $response->getBody();
  4705. }
  4708. // Set the data to Redis cache
  4709. $this->redisCache->set($cacheKey, $data);
  4711. return $data;
  4712. } catch (GuzzleHttp\Exception\RequestException $e) {
  4713. return throw new \Exception($e->getMessage());
  4714. } catch (\Exception $e) {
  4715. return throw new \Exception($e->getMessage());
  4716. }
  4717. }
  4720. /**
  4721. * Fetches the hourly weather forecast data for a given latitude, longitude, and hour
  4722. *
  4723. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4724. * @param string $hourly The hour for which forecast is required in 24-hour format
  4725. * @return array The hourly weather forecast data in JSON format
  4726. */
  4727. public function getHourlyForecastWithoutSymbols(array $coordinates, string $startDate, string $endDate, int $hour, string $model)
  4728. {
  4730. try {
  4732. if (count($coordinates) > 1) {
  4734. // Validate the input parameters
  4735. foreach ($coordinates as $coordinate) {
  4736. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4737. throw new \InvalidArgumentException('Invalid coordinates');
  4738. }
  4739. }
  4741. if (empty($startDate) || empty($endDate)) {
  4742. throw new \InvalidArgumentException('Invalid dates');
  4743. }
  4745. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4746. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4748. // Create a Redis key for the cache
  4749. $cacheKey = sprintf('cn_hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  4750. return implode('_', $coordinate);
  4751. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, $hour);
  4754. // Try to get the data from Redis cache
  4755. $cachedData = $this->redisCache->get($cacheKey);
  4758. if ($cachedData !== null) {
  4759. // Return the cached data if available
  4760. return $cachedData;
  4761. }
  4764. // If cache is empty, get the data from the API
  4765. $client = new Client(['verify' => false]);
  4767. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  4768. $url1 = sprintf(
  4769. '%s/%s--%s:PT%sH/t_2m:C,wind_speed_10m:kmh,wind_dir_mean_100m_2h:d,prob_precip_2h:p,precip_2h:mm/%+%/json?model=' . $model,
  4770. $this->apiBaseUrl,
  4771. $startDate,
  4772. $endDate,
  4773. $hour,
  4774. $coordinateString,
  4775. $coordinateString
  4776. );
  4777. } else {
  4779. if ($coordinates) {
  4780. $latitude = $coordinates[0][0];
  4781. $longitude = $coordinates[0][1];
  4782. }
  4784. // Validate the input parameters
  4785. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  4786. throw new \InvalidArgumentException('Invalid latitude');
  4787. }
  4788. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  4789. throw new \InvalidArgumentException('Invalid longitude');
  4790. }
  4792. if (empty($startDate) || empty($endDate)) {
  4793. throw new \InvalidArgumentException('Invalid dates');
  4794. }
  4796. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4797. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4799. // Create a Redis key for the cache
  4800. $cacheKey = sprintf('cn_hourly_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  4801. return implode('_', $coordinate);
  4802. }, $coordinates)), ($startDate . '-' . $endDate) . $model, $hour);
  4804. // Try to get the data from Redis cache
  4805. $cachedData = $this->redisCache->get($cacheKey);
  4807. if ($cachedData !== null) {
  4808. // Return the cached data if available
  4809. return $cachedData;
  4810. }
  4812. // If cache is empty, get the data from the API
  4813. $client = new Client(['verify' => false]);
  4814. $url1 = sprintf(
  4815. '%s/%s--%s:PT%sH/t_2m:C,wind_speed_10m:kmh,wind_dir_mean_100m_2h:d,prob_precip_2h:p,precip_2h:mm/%s,%s/json?model=' . $model,
  4816. $this->apiBaseUrl,
  4817. $startDate,
  4818. $endDate,
  4819. $hour,
  4820. $latitude,
  4821. $longitude
  4822. );
  4823. }
  4825. $response = $client->request('GET', $url1, [
  4826. 'auth' => [$this->username, $this->password],
  4827. ]);
  4829. $statusCode = $response->getStatusCode();
  4830. $data1 = json_decode($response->getBody(), true);
  4833. // Set the data to Redis cache
  4834. $this->redisCache->set($cacheKey, $data1);
  4836. return $data1;
  4837. } catch (GuzzleHttp\Exception\RequestException $e) {
  4838. return throw new \Exception($e->getMessage());
  4839. } catch (\Exception $e) {
  4840. return throw new \Exception($e->getMessage());
  4841. }
  4842. }
  4845. /**
  4846. * Fetches the weather forecast data for a given latitude, longitude, and for selected data range
  4847. *
  4848. * @param array $coordinates An array of coordinates in the format [[lat1, long1], [lat2, long2], ...]
  4849. * @param int $days The number of days for which forecast is required
  4850. * @return array|null The weather forecast data in JSON format, or null if there was an error
  4851. */
  4852. public function getTempratureByParamsHourly(
  4853. array $coordinates,
  4854. string $startDate,
  4855. string $endDate,
  4856. string $parametersStr,
  4857. int $hour = 2,
  4858. string $model,
  4859. $timezone
  4860. ) {
  4861. try {
  4863. // Convert start and end dates to the specified timezone
  4864. $startDateObj = new \DateTime($startDate, $timezone);
  4865. $endDateObj = new \DateTime($endDate, $timezone);
  4867. // Format dates to ISO 8601 format for the API request
  4868. $startDate = $startDateObj->format('Y-m-d\TH:i:s.v\Z');
  4869. $endDate = $endDateObj->format('Y-m-d\TH:i:s.v\Z');
  4871. if (count($coordinates) > 1) {
  4872. // Validate the input parameters
  4873. foreach ($coordinates as $coordinate) {
  4874. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4875. throw new \InvalidArgumentException('Invalid coordinates');
  4876. }
  4877. }
  4879. // Create a Redis key for the cache
  4880. $cacheKey = sprintf('hourly_custom_noti_%s_%s_%s_%s', md5(implode('_', array_map(function ($coordinate) {
  4881. return implode('_', $coordinate);
  4882. }, $coordinates))), ($startDate . '-' . $endDate), $parametersStr, $model);
  4884. // Try to get the data from Redis cache
  4885. $cachedData = $this->redisCache->get($cacheKey);
  4886. if ($cachedData !== null) {
  4887. return $cachedData;
  4888. }
  4890. // Build the API URL
  4891. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  4892. $url = sprintf(
  4893. '%s/%s--%s:PT%sH/%s/%s+%s/json?source=%s',
  4894. $this->apiBaseUrl,
  4895. $startDate,
  4896. $endDate,
  4897. $hour,
  4898. $parametersStr,
  4899. $coordinateString,
  4900. $coordinateString,
  4901. $model
  4902. );
  4903. } else {
  4904. // Handle single coordinate case
  4905. if ($coordinates) {
  4906. $latitude = $coordinates[0][0];
  4907. $longitude = $coordinates[0][1];
  4908. }
  4910. if (empty($latitude) || empty($longitude)) {
  4911. throw new \InvalidArgumentException('Invalid coordinates');
  4912. }
  4914. // Create a Redis key for the cache
  4915. $cacheKey = sprintf('hourly_custom_noti_%s_%s_%s_%s', md5(implode('_', array_map(function ($coordinate) {
  4916. return implode('_', $coordinate);
  4917. }, $coordinates))), ($startDate . '-' . $endDate), $parametersStr, $model);
  4919. // Try to get the data from Redis cache
  4920. $cachedData = $this->redisCache->get($cacheKey);
  4921. if ($cachedData !== null) {
  4922. return $cachedData;
  4923. }
  4925. // Build the API URL for a single coordinate
  4926. $url = sprintf(
  4927. '%s/%s--%s:PT%sH/%s/%s,%s/json?source=%s',
  4928. $this->apiBaseUrl,
  4929. $startDate,
  4930. $endDate,
  4931. $hour,
  4932. $parametersStr,
  4933. $latitude,
  4934. $longitude,
  4935. $model
  4936. );
  4937. }
  4939. // Make the API request
  4940. $client = new Client(['verify' => false]);
  4941. $response = $client->request('GET', $url, [
  4942. 'auth' => [$this->username, $this->password],
  4943. ]);
  4945. $data = json_decode($response->getBody(), true);
  4947. // Cache the data in Redis
  4948. $this->redisCache->set($cacheKey, $data);
  4950. return $data;
  4951. } catch (GuzzleHttp\Exception\RequestException $e) {
  4952. throw new \Exception($e->getMessage());
  4953. } catch (\Exception $e) {
  4954. throw new \Exception($e->getMessage());
  4955. }
  4956. }
  4958. /**
  4959. * Tidal Amplitude
  4960. *
  4961. * @param string $hourly The hour for which forecast is required in 24-hour format
  4962. * @param string $unit The type of data request unit (e.g., 'cm')
  4963. * @param string $format return type of json
  4964. * @param string $startDate The type of data date (e.g., '2023-09-01')
  4965. * @param string $endDate The type of data date (e.g., '2023-09-01')
  4966. * @param array $coordinates The latitude and longitude of location
  4967. * @param string $model type of data Api return (e.g., 'mm-tides')
  4968. * @throws \InvalidArgumentException If any parameter has an invalid data type
  4969. */
  4971. public function getTidalAmplitudes(int $hour, $startDate, $endDate, array $coordinates, $unit, $model, $format)
  4972. {
  4974. try {
  4976. if (count($coordinates) > 1) {
  4978. // Validate the input parameters
  4979. foreach ($coordinates as $coordinate) {
  4980. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  4981. throw new \InvalidArgumentException('Invalid coordinates');
  4982. }
  4983. }
  4985. if (empty($startDate) || empty($endDate)) {
  4986. throw new \InvalidArgumentException('Invalid dates');
  4987. }
  4989. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  4990. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  4992. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinates, $unit, $model, $format);
  4994. // Try to get the data from Redis cache
  4995. $cachedData = $this->redisCache->get($cacheKey);
  4997. if ($cachedData !== null) {
  4998. // Return the cached data if available
  4999. return $cachedData;
  5000. }
  5002. // If cache is empty, get the data from the API
  5003. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5004. $client = new Client(['verify' => false]);
  5006. $url = sprintf(
  5007. '%s/%s--%s:PT%sH/tidal_amplitude:%s/%s/%s?model=%s',
  5008. $this->apiBaseUrl,
  5009. $startDate,
  5010. $endDate,
  5011. $hour,
  5012. $unit,
  5013. $coordinateString,
  5014. $format,
  5015. $model
  5016. );
  5018. $response = $client->request('GET', $url, [
  5019. 'auth' => [$this->username, $this->password],
  5020. ]);
  5022. $statusCode = $response->getStatusCode();
  5023. $data = json_decode($response->getBody(), true);
  5025. if ($statusCode != 200) {
  5026. return $this->createErrorResponse($statusCode);
  5027. }
  5029. // Set the data to Redis cache
  5030. $this->redisCache->set($cacheKey, $data);
  5031. return $data;
  5032. } else {
  5034. if ($coordinates) {
  5035. $latitude = $coordinates[0][0];
  5036. $longitude = $coordinates[0][1];
  5037. }
  5039. // Validate the input parameters
  5040. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5041. throw new \InvalidArgumentException('Invalid latitude');
  5042. }
  5044. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5045. throw new \InvalidArgumentException('Invalid longitude');
  5046. }
  5048. if (empty($startDate)) {
  5049. throw new \InvalidArgumentException('Invalid startDate');
  5050. }
  5051. if (empty($endDate)) {
  5052. throw new \InvalidArgumentException('Invalid endDate');
  5053. }
  5055. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5056. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5058. // Create a Redis key for the cache
  5059. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $unit, $latitude, $longitude, $model, $format);
  5061. // Try to get the data from Redis cache
  5062. $cachedData = $this->redisCache->get($cacheKey);
  5064. if ($cachedData !== null) {
  5065. // Return the cached data if available
  5066. return $cachedData;
  5067. }
  5069. // If cache is empty, get the data from the API
  5070. $client = new Client(['verify' => false]);
  5072. $url = sprintf(
  5073. '%s/%s--%s:PT%sH/tidal_amplitude:%s/%s,%s/%s?model=%s',
  5074. $this->apiBaseUrl,
  5075. $startDate,
  5076. $endDate,
  5077. $hour,
  5078. $unit,
  5079. $latitude,
  5080. $longitude,
  5081. $format,
  5082. $model
  5083. );
  5085. $response = $client->request('GET', $url, [
  5086. 'auth' => [$this->username, $this->password],
  5087. ]);
  5089. $statusCode = $response->getStatusCode();
  5090. $data = json_decode($response->getBody(), true);
  5092. if ($statusCode != 200) {
  5093. return $this->createErrorResponse($statusCode);
  5094. }
  5096. // Set the data to Redis cache
  5097. $this->redisCache->set($cacheKey, $data);
  5098. return $data;
  5099. }
  5100. } catch (GuzzleHttp\Exception\RequestException $e) {
  5101. return throw new \Exception($e->getMessage());
  5102. } catch (\Exception $e) {
  5103. return throw new \Exception($e->getMessage());
  5104. }
  5105. }
  5108. /**
  5109. * High and Low Tide Times
  5110. *
  5111. * @param string $hourly The hour for which forecast is required in 24-hour format
  5112. * @param string $format return type of json
  5113. * @param string $startDate The type of data date (e.g., '2023-09-01')
  5114. * @param string $endDate The type of data date (e.g., '2023-09-01')
  5115. * @param array $coordinates The latitude and longitude of location
  5116. * @param string $model type of data Api return (e.g., 'mm-tides')
  5117. * @throws \InvalidArgumentException If any parameter has an invalid data type
  5118. */
  5120. public function getHighLowTideTimes(int $hour, $startDate, $endDate, array $coordinates, $model, $format)
  5121. {
  5123. try {
  5125. if (count($coordinates) > 1) {
  5127. // Validate the input parameters
  5128. foreach ($coordinates as $coordinate) {
  5129. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5130. throw new \InvalidArgumentException('Invalid coordinates');
  5131. }
  5132. }
  5134. if (empty($startDate) || empty($endDate)) {
  5135. throw new \InvalidArgumentException('Invalid dates');
  5136. }
  5138. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5139. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5141. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinates, $model, $format);
  5143. // Try to get the data from Redis cache
  5144. $cachedData = $this->redisCache->get($cacheKey);
  5146. if ($cachedData !== null) {
  5147. // Return the cached data if available
  5148. return $cachedData;
  5149. }
  5151. // If cache is empty, get the data from the API
  5152. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5153. $client = new Client(['verify' => false]);
  5155. $url = sprintf(
  5156. '%s/%s--%s:PT%sH/first_high_tide:sql,second_high_tide:sql,first_low_tide:sql,second_low_tide:sql/%s/%s?model=%s',
  5157. $this->apiBaseUrl,
  5158. $startDate,
  5159. $endDate,
  5160. $hour,
  5161. $coordinateString,
  5162. $format,
  5163. $model
  5164. );
  5166. $response = $client->request('GET', $url, [
  5167. 'auth' => [$this->username, $this->password],
  5168. ]);
  5170. $statusCode = $response->getStatusCode();
  5171. $data = json_decode($response->getBody(), true);
  5173. if ($statusCode != 200) {
  5174. return $this->createErrorResponse($statusCode);
  5175. }
  5177. // Set the data to Redis cache
  5178. $this->redisCache->set($cacheKey, $data);
  5179. return $data;
  5180. } else {
  5182. if ($coordinates) {
  5183. $latitude = $coordinates[0][0];
  5184. $longitude = $coordinates[0][1];
  5185. }
  5187. // Validate the input parameters
  5188. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5189. throw new \InvalidArgumentException('Invalid latitude');
  5190. }
  5192. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5193. throw new \InvalidArgumentException('Invalid longitude');
  5194. }
  5196. if (empty($startDate)) {
  5197. throw new \InvalidArgumentException('Invalid startDate');
  5198. }
  5199. if (empty($endDate)) {
  5200. throw new \InvalidArgumentException('Invalid endDate');
  5201. }
  5203. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5204. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5206. // Create a Redis key for the cache
  5207. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude, $model, $format);
  5209. // Try to get the data from Redis cache
  5210. $cachedData = $this->redisCache->get($cacheKey);
  5212. if ($cachedData !== null) {
  5213. // Return the cached data if available
  5214. return $cachedData;
  5215. }
  5217. // If cache is empty, get the data from the API
  5218. $client = new Client(['verify' => false]);
  5220. $url = sprintf(
  5221. '%s/%s--%s:PT%sH/first_high_tide:sql,second_high_tide:sql,first_low_tide:sql,second_low_tide:sql/%s,%s/%s?model=%s',
  5222. $this->apiBaseUrl,
  5223. $startDate,
  5224. $endDate,
  5225. $hour,
  5226. $latitude,
  5227. $longitude,
  5228. $format,
  5229. $model
  5230. );
  5232. $response = $client->request('GET', $url, [
  5233. 'auth' => [$this->username, $this->password],
  5234. ]);
  5236. $statusCode = $response->getStatusCode();
  5237. $data = json_decode($response->getBody(), true);
  5239. if ($statusCode != 200) {
  5240. return $this->createErrorResponse($statusCode);
  5241. }
  5243. // Set the data to Redis cache
  5244. $this->redisCache->set($cacheKey, $data);
  5245. return $data;
  5246. }
  5247. } catch (GuzzleHttp\Exception\RequestException $e) {
  5248. return throw new \Exception($e->getMessage());
  5249. } catch (\Exception $e) {
  5250. return throw new \Exception($e->getMessage());
  5251. }
  5252. }
  5254. /**
  5255. * Significant Wave Height
  5256. *
  5257. * @param string $hourly The hour for which forecast is required in 24-hour format
  5258. * @param string $format return type of json
  5259. * @param string $startDate The type of data date (e.g., '2023-09-01')
  5260. * @param string $endDate The type of data date (e.g., '2023-09-01')
  5261. * @param array $coordinates The latitude and longitude of location
  5262. * @throws \InvalidArgumentException If any parameter has an invalid data type
  5263. */
  5265. public function getSignificantWaveHeight(int $hour, $startDate, $endDate, array $coordinates, $format)
  5266. {
  5268. try {
  5270. if (count($coordinates) > 1) {
  5272. // Validate the input parameters
  5273. foreach ($coordinates as $coordinate) {
  5274. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5275. throw new \InvalidArgumentException('Invalid coordinates');
  5276. }
  5277. }
  5279. if (empty($startDate) || empty($endDate)) {
  5280. throw new \InvalidArgumentException('Invalid dates');
  5281. }
  5283. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5284. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5286. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinate, $format);
  5288. // Try to get the data from Redis cache
  5289. $cachedData = $this->redisCache->get($cacheKey);
  5291. if ($cachedData !== null) {
  5292. // Return the cached data if available
  5293. return $cachedData;
  5294. }
  5296. // If cache is empty, get the data from the API
  5297. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5298. $client = new Client(['verify' => false]);
  5300. $url = sprintf(
  5301. '%s/%s--%s:PT%sH/significant_height_wind_waves:m/%s/%s',
  5302. $this->apiBaseUrl,
  5303. $startDate,
  5304. $endDate,
  5305. $hour,
  5306. $coordinateString,
  5307. $format
  5308. );
  5310. $response = $client->request('GET', $url, [
  5311. 'auth' => [$this->username, $this->password],
  5312. ]);
  5314. $statusCode = $response->getStatusCode();
  5315. $data = json_decode($response->getBody(), true);
  5317. if ($statusCode != 200) {
  5318. return $this->createErrorResponse($statusCode);
  5319. }
  5321. // Set the data to Redis cache
  5322. $this->redisCache->set($cacheKey, $data);
  5323. return $data;
  5324. } else {
  5326. if ($coordinates) {
  5327. $latitude = $coordinates[0][0];
  5328. $longitude = $coordinates[0][1];
  5329. }
  5331. // Validate the input parameters
  5332. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5333. throw new \InvalidArgumentException('Invalid latitude');
  5334. }
  5336. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5337. throw new \InvalidArgumentException('Invalid longitude');
  5338. }
  5340. if (empty($startDate)) {
  5341. throw new \InvalidArgumentException('Invalid startDate');
  5342. }
  5344. if (empty($endDate)) {
  5345. throw new \InvalidArgumentException('Invalid endDate');
  5346. }
  5348. $startDate = date('Y-m-d\TH\Z', (strtotime($startDate)));
  5349. $endDate = date('Y-m-d\TH\Z', (strtotime($endDate)));
  5351. // Create a Redis key for the cache
  5352. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude, $format);
  5354. // Try to get the data from Redis cache
  5355. $cachedData = $this->redisCache->get($cacheKey);
  5357. if ($cachedData !== null) {
  5358. // Return the cached data if available
  5359. return $cachedData;
  5360. }
  5362. // If cache is empty, get the data from the API
  5363. $client = new Client(['verify' => false]);
  5365. $url = sprintf(
  5366. '%s/%s--%s:PT%sH/significant_height_wind_waves:m/%s,%s/%s',
  5367. $this->apiBaseUrl,
  5368. $startDate,
  5369. $endDate,
  5370. $hour,
  5371. $latitude,
  5372. $longitude,
  5373. $format
  5374. );
  5376. $response = $client->request('GET', $url, [
  5377. 'auth' => [$this->username, $this->password],
  5378. ]);
  5380. $statusCode = $response->getStatusCode();
  5381. $data = json_decode($response->getBody(), true);
  5383. if ($statusCode != 200) {
  5384. return $this->createErrorResponse($statusCode);
  5385. }
  5387. // Set the data to Redis cache
  5388. $this->redisCache->set($cacheKey, $data);
  5389. return $data;
  5390. }
  5391. } catch (GuzzleHttp\Exception\RequestException $e) {
  5392. return throw new \Exception($e->getMessage());
  5393. } catch (\Exception $e) {
  5394. return throw new \Exception($e->getMessage());
  5395. }
  5396. }
  5398. /**
  5399. * Surge Amplitude
  5400. *
  5401. * @param string $hourly The hour for which forecast is required in 24-hour format
  5402. * @param string $format return type of json
  5403. * @param string $startDate The type of data date (e.g., '2023-09-01')
  5404. * @param string $endDate The type of data date (e.g., '2023-09-01')
  5405. * @param string $unit The type of data unit (e.g., 'cm')
  5406. * @param array $coordinates The latitude and longitude of location
  5407. * @param string $model type of data Api return (e.g., 'mix')
  5408. * @throws \InvalidArgumentException If any parameter has an invalid data type
  5409. */
  5411. public function getSurgeAmplitude(int $hour, $startDate, $endDate, array $coordinates, $unit, $model, $format)
  5412. {
  5414. try {
  5416. if (count($coordinates) > 1) {
  5418. // Validate the input parameters
  5419. foreach ($coordinates as $coordinate) {
  5420. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5421. throw new \InvalidArgumentException('Invalid coordinates');
  5422. }
  5423. }
  5425. if (empty($startDate) || empty($endDate)) {
  5426. throw new \InvalidArgumentException('Invalid dates');
  5427. }
  5429. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5430. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5432. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinate, $unit, $model, $format);
  5434. // Try to get the data from Redis cache
  5435. $cachedData = $this->redisCache->get($cacheKey);
  5437. if ($cachedData !== null) {
  5438. // Return the cached data if available
  5439. return $cachedData;
  5440. }
  5442. // If cache is empty, get the data from the API
  5443. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5444. $client = new Client(['verify' => false]);
  5446. $url = sprintf(
  5447. '%s/%s--%s:PT%sH/surge_amplitude:%s/%s/%s?model=%s',
  5448. $this->apiBaseUrl,
  5449. $startDate,
  5450. $endDate,
  5451. $hour,
  5452. $unit,
  5453. $coordinateString,
  5454. $format,
  5455. $model
  5456. );
  5458. $response = $client->request('GET', $url, [
  5459. 'auth' => [$this->username, $this->password],
  5460. ]);
  5462. $statusCode = $response->getStatusCode();
  5463. $data = json_decode($response->getBody(), true);
  5465. if ($statusCode != 200) {
  5466. return $this->createErrorResponse($statusCode);
  5467. }
  5469. // Set the data to Redis cache
  5470. $this->redisCache->set($cacheKey, $data);
  5471. return $data;
  5472. } else {
  5474. if ($coordinates) {
  5475. $latitude = $coordinates[0][0];
  5476. $longitude = $coordinates[0][1];
  5477. }
  5479. // Validate the input parameters
  5480. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5481. throw new \InvalidArgumentException('Invalid latitude');
  5482. }
  5484. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5485. throw new \InvalidArgumentException('Invalid longitude');
  5486. }
  5488. if (empty($startDate)) {
  5489. throw new \InvalidArgumentException('Invalid startDate');
  5490. }
  5491. if (empty($endDate)) {
  5492. throw new \InvalidArgumentException('Invalid endDate');
  5493. }
  5495. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5496. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5498. // Create a Redis key for the cache
  5499. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude, $unit, $model, $format);
  5501. // Try to get the data from Redis cache
  5502. $cachedData = $this->redisCache->get($cacheKey);
  5504. if ($cachedData !== null) {
  5505. // Return the cached data if available
  5506. return $cachedData;
  5507. }
  5509. // If cache is empty, get the data from the API
  5510. $client = new Client(['verify' => false]);
  5512. $url = sprintf(
  5513. '%s/%s--%s:PT%sH/surge_amplitude:%s/%s,%s/%s?model=%s',
  5514. $this->apiBaseUrl,
  5515. $startDate,
  5516. $endDate,
  5517. $hour,
  5518. $unit,
  5519. $latitude,
  5520. $longitude,
  5521. $format,
  5522. $model
  5523. );
  5525. $response = $client->request('GET', $url, [
  5526. 'auth' => [$this->username, $this->password],
  5527. ]);
  5529. $statusCode = $response->getStatusCode();
  5530. $data = json_decode($response->getBody(), true);
  5532. if ($statusCode != 200) {
  5533. return $this->createErrorResponse($statusCode);
  5534. }
  5536. // Set the data to Redis cache
  5537. $this->redisCache->set($cacheKey, $data);
  5538. return $data;
  5539. }
  5540. } catch (GuzzleHttp\Exception\RequestException $e) {
  5541. return throw new \Exception($e->getMessage());
  5542. } catch (\Exception $e) {
  5543. return throw new \Exception($e->getMessage());
  5544. }
  5545. }
  5548. /**
  5549. * Heat index
  5550. *
  5551. * @param string $hourly The hour for which forecast is required in 24-hour format
  5552. * @param string $format return type of json
  5553. * @param string $unit request unit type (e.g, 'C')
  5554. * @param string $startDate The type of data date (e.g., '2023-09-01')
  5555. * @param string $endDate The type of data date (e.g., '2023-09-01')
  5556. * @param array $coordinates The latitude and longitude of location
  5557. * @param string $model type of data Api return (e.g., 'mix')
  5558. * @throws \InvalidArgumentException If any parameter has an invalid data type
  5559. */
  5561. public function getHeatIndex(int $hour, $startDate, $endDate, array $coordinates, $unit, $format, $model)
  5562. {
  5565. try {
  5567. if (count($coordinates) > 1) {
  5569. // Validate the input parameters
  5570. foreach ($coordinates as $coordinate) {
  5571. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5572. throw new \InvalidArgumentException('Invalid coordinates');
  5573. }
  5574. }
  5576. if (empty($startDate) || empty($endDate)) {
  5577. throw new \InvalidArgumentException('Invalid dates');
  5578. }
  5580. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5581. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5583. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinate, $model, $unit, $format);
  5585. // Try to get the data from Redis cache
  5586. $cachedData = $this->redisCache->get($cacheKey);
  5588. if ($cachedData !== null) {
  5589. // Return the cached data if available
  5590. return $cachedData;
  5591. }
  5593. // If cache is empty, get the data from the API
  5594. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5595. $client = new Client(['verify' => false]);
  5596. $url = sprintf(
  5597. '%s/%s--%s:PT%sH/heat_index:%s,t_2m:%s/%s/%s?model=%s',
  5598. $this->apiBaseUrl,
  5599. $startDate,
  5600. $endDate,
  5601. $hour,
  5602. $unit,
  5603. $unit,
  5604. $coordinateString,
  5605. $format,
  5606. $model
  5607. );
  5609. $response = $client->request('GET', $url, [
  5610. 'auth' => [$this->username, $this->password],
  5611. ]);
  5613. $statusCode = $response->getStatusCode();
  5614. $data = json_decode($response->getBody(), true);
  5616. if ($statusCode != 200) {
  5617. return $this->createErrorResponse($statusCode);
  5618. }
  5620. // Set the data to Redis cache
  5621. $this->redisCache->set($cacheKey, $data);
  5622. return $data;
  5623. } else {
  5625. if ($coordinates) {
  5626. $latitude = $coordinates[0][0];
  5627. $longitude = $coordinates[0][1];
  5628. }
  5630. // Validate the input parameters
  5631. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5632. throw new \InvalidArgumentException('Invalid latitude');
  5633. }
  5635. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5636. throw new \InvalidArgumentException('Invalid longitude');
  5637. }
  5639. if (empty($startDate)) {
  5640. throw new \InvalidArgumentException('Invalid startDate');
  5641. }
  5642. if (empty($endDate)) {
  5643. throw new \InvalidArgumentException('Invalid endDate');
  5644. }
  5646. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5647. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5649. // Create a Redis key for the cache
  5650. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude, $unit, $model, $format);
  5652. // Try to get the data from Redis cache
  5653. $cachedData = $this->redisCache->get($cacheKey);
  5655. if ($cachedData !== null) {
  5656. // Return the cached data if available
  5657. return $cachedData;
  5658. }
  5660. // If cache is empty, get the data from the API
  5661. $client = new Client(['verify' => false]);
  5662. $url = sprintf(
  5663. '%s/%s--%s:PT%sH/heat_index:%s,t_2m:%s/%s,%s/%s?model=%s',
  5664. $this->apiBaseUrl,
  5665. $startDate,
  5666. $endDate,
  5667. $hour,
  5668. $unit,
  5669. $unit,
  5670. $latitude,
  5671. $longitude,
  5672. $format,
  5673. $model
  5674. );
  5676. $response = $client->request('GET', $url, [
  5677. 'auth' => [$this->username, $this->password],
  5678. ]);
  5680. $statusCode = $response->getStatusCode();
  5681. $data = json_decode($response->getBody(), true);
  5683. if ($statusCode != 200) {
  5684. return $this->createErrorResponse($statusCode);
  5685. }
  5687. // Set the data to Redis cache
  5688. $this->redisCache->set($cacheKey, $data);
  5689. return $data;
  5690. }
  5691. } catch (GuzzleHttp\Exception\RequestException $e) {
  5692. return throw new \Exception($e->getMessage());
  5693. } catch (\Exception $e) {
  5694. return throw new \Exception($e->getMessage());
  5695. }
  5696. }
  5700. /**
  5701. * Atmospheric Density
  5702. *
  5703. * @param string $hourly The hour for which forecast is required in 24-hour format
  5704. * @param string $format return type of json
  5705. * @param string $level The type of level request (e.g., '2m')
  5706. * @param string $unit The type of unit request (e.g., 'kgm3')
  5707. * @param string $startDate The type of data date (e.g., '2023-09-01')
  5708. * @param string $endDate The type of data date (e.g., '2023-09-01')
  5709. * @param array $coordinates The latitude and longitude of location
  5710. * @throws \InvalidArgumentException If any parameter has an invalid data type
  5711. */
  5713. public function getAirdensity(int $hour, $startDate, $endDate, array $coordinates, $level, $unit, $format)
  5714. {
  5716. try {
  5718. if (count($coordinates) > 1) {
  5720. // Validate the input parameters
  5721. foreach ($coordinates as $coordinate) {
  5722. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5723. throw new \InvalidArgumentException('Invalid coordinates');
  5724. }
  5725. }
  5727. if (empty($startDate) || empty($endDate)) {
  5728. throw new \InvalidArgumentException('Invalid dates');
  5729. }
  5731. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5732. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5734. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinates, $level, $unit, $format);
  5736. // Try to get the data from Redis cache
  5737. $cachedData = $this->redisCache->get($cacheKey);
  5739. if ($cachedData !== null) {
  5740. // Return the cached data if available
  5741. return $cachedData;
  5742. }
  5744. // If cache is empty, get the data from the API
  5745. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5746. $client = new Client(['verify' => false]);
  5747. $url = sprintf(
  5748. '%s/%s--%s:PT%sH/air_density_%s:%s/%s/%s',
  5749. $this->apiBaseUrl,
  5750. $startDate,
  5751. $endDate,
  5752. $hour,
  5753. $level,
  5754. $unit,
  5755. $coordinateString,
  5756. $format
  5757. );
  5759. $response = $client->request('GET', $url, [
  5760. 'auth' => [$this->username, $this->password],
  5761. ]);
  5763. $statusCode = $response->getStatusCode();
  5764. $data = json_decode($response->getBody(), true);
  5766. if ($statusCode != 200) {
  5767. return $this->createErrorResponse($statusCode);
  5768. }
  5770. // Set the data to Redis cache
  5771. $this->redisCache->set($cacheKey, $data);
  5772. return $data;
  5773. } else {
  5775. if ($coordinates) {
  5776. $latitude = $coordinates[0][0];
  5777. $longitude = $coordinates[0][1];
  5778. }
  5780. // Validate the input parameters
  5781. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5782. throw new \InvalidArgumentException('Invalid latitude');
  5783. }
  5785. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5786. throw new \InvalidArgumentException('Invalid longitude');
  5787. }
  5789. if (empty($startDate)) {
  5790. throw new \InvalidArgumentException('Invalid startDate');
  5791. }
  5792. if (empty($endDate)) {
  5793. throw new \InvalidArgumentException('Invalid endDate');
  5794. }
  5796. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5797. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5799. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude, $level, $unit, $format);
  5801. // Try to get the data from Redis cache
  5802. $cachedData = $this->redisCache->get($cacheKey);
  5804. if ($cachedData !== null) {
  5805. // Return the cached data if available
  5806. return $cachedData;
  5807. }
  5809. // If cache is empty, get the data from the API
  5810. $client = new Client(['verify' => false]);
  5811. $url = sprintf(
  5812. '%s/%s--%s:PT%sH/air_density_%s:%s/%s,%s/%s',
  5813. $this->apiBaseUrl,
  5814. $startDate,
  5815. $endDate,
  5816. $hour,
  5817. $level,
  5818. $unit,
  5819. $latitude,
  5820. $longitude,
  5821. $format
  5822. );
  5824. $response = $client->request('GET', $url, [
  5825. 'auth' => [$this->username, $this->password],
  5826. ]);
  5828. $statusCode = $response->getStatusCode();
  5829. $data = json_decode($response->getBody(), true);
  5831. if ($statusCode != 200) {
  5832. return $this->createErrorResponse($statusCode);
  5833. }
  5835. // Set the data to Redis cache
  5836. $this->redisCache->set($cacheKey, $data);
  5837. return $data;
  5838. }
  5839. } catch (GuzzleHttp\Exception\RequestException $e) {
  5840. return throw new \Exception($e->getMessage());
  5841. } catch (\Exception $e) {
  5842. return throw new \Exception($e->getMessage());
  5843. }
  5844. }
  5846. /**
  5847. * Soil Moisture Index
  5848. *
  5849. * @param string $hourly The hour for which forecast is required in 24-hour format
  5850. * @param string $format return type of json
  5851. * @param string $level The type of level request (e.g., '2m')
  5852. * @param string $unit The type of unit request (e.g., 'kgm3')
  5853. * @param string $startDate The type of data date (e.g., '2023-09-01')
  5854. * @param string $endDate The type of data date (e.g., '2023-09-01')
  5855. * @param array $coordinates The latitude and longitude of location
  5856. * @throws \InvalidArgumentException If any parameter has an invalid data type
  5857. */
  5859. public function getSoilMoistureIndex(int $hour, $startDate, $endDate, array $coordinates, $level, $unit, $format)
  5860. {
  5862. try {
  5864. if (count($coordinates) > 1) {
  5866. // Validate the input parameters
  5867. foreach ($coordinates as $coordinate) {
  5868. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  5869. throw new \InvalidArgumentException('Invalid coordinates');
  5870. }
  5871. }
  5873. if (empty($startDate) || empty($endDate)) {
  5874. throw new \InvalidArgumentException('Invalid dates');
  5875. }
  5877. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5878. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5880. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $coordinates, $level, $unit, $format);
  5882. // Try to get the data from Redis cache
  5883. $cachedData = $this->redisCache->get($cacheKey);
  5885. if ($cachedData !== null) {
  5886. // Return the cached data if available
  5887. return $cachedData;
  5888. }
  5890. // If cache is empty, get the data from the API
  5891. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  5892. $client = new Client(['verify' => false]);
  5893. $url = sprintf(
  5894. '%s/%s--%s:PT%sH/soil_moisture_index_%s:%s/%s/%s',
  5895. $this->apiBaseUrl,
  5896. $startDate,
  5897. $endDate,
  5898. $hour,
  5899. $level,
  5900. $unit,
  5901. $coordinateString,
  5902. $format
  5903. );
  5905. $response = $client->request('GET', $url, [
  5906. 'auth' => [$this->username, $this->password],
  5907. ]);
  5909. $statusCode = $response->getStatusCode();
  5910. $data = json_decode($response->getBody(), true);
  5912. if ($statusCode != 200) {
  5913. return $this->createErrorResponse($statusCode);
  5914. }
  5916. // Set the data to Redis cache
  5917. $this->redisCache->set($cacheKey, $data);
  5918. return $data;
  5919. } else {
  5921. if ($coordinates) {
  5922. $latitude = $coordinates[0][0];
  5923. $longitude = $coordinates[0][1];
  5924. }
  5926. // Validate the input parameters
  5927. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  5928. throw new \InvalidArgumentException('Invalid latitude');
  5929. }
  5931. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  5932. throw new \InvalidArgumentException('Invalid longitude');
  5933. }
  5935. if (empty($startDate)) {
  5936. throw new \InvalidArgumentException('Invalid startDate');
  5937. }
  5938. if (empty($endDate)) {
  5939. throw new \InvalidArgumentException('Invalid endDate');
  5940. }
  5942. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  5943. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  5945. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $latitude, $longitude, $level, $unit, $format);
  5947. // Try to get the data from Redis cache
  5948. $cachedData = $this->redisCache->get($cacheKey);
  5950. if ($cachedData !== null) {
  5951. // Return the cached data if available
  5952. return $cachedData;
  5953. }
  5955. // If cache is empty, get the data from the API
  5956. $client = new Client(['verify' => false]);
  5957. $url = sprintf(
  5958. '%s/%s--%s:PT%sH/soil_moisture_index_%s:%s/%s,%s/%s',
  5959. $this->apiBaseUrl,
  5960. $startDate,
  5961. $endDate,
  5962. $hour,
  5963. $level,
  5964. $unit,
  5965. $latitude,
  5966. $longitude,
  5967. $format
  5968. );
  5970. $response = $client->request('GET', $url, [
  5971. 'auth' => [$this->username, $this->password],
  5972. ]);
  5974. $statusCode = $response->getStatusCode();
  5975. $data = json_decode($response->getBody(), true);
  5977. if ($statusCode != 200) {
  5978. return $this->createErrorResponse($statusCode);
  5979. }
  5981. // Set the data to Redis cache
  5982. $this->redisCache->set($cacheKey, $data);
  5983. return $data;
  5984. }
  5985. } catch (GuzzleHttp\Exception\RequestException $e) {
  5986. return throw new \Exception($e->getMessage());
  5987. } catch (\Exception $e) {
  5988. return throw new \Exception($e->getMessage());
  5989. }
  5990. }
  5992. /**
  5993. * Frost & Thaw Depth
  5994. *
  5995. * @param string $hourly The hour for which forecast is required in 24-hour format
  5996. * @param string $format return type of json
  5997. * @param string $startDate The type of data date (e.g., '2023-09-01')
  5998. * @param string $endDate The type of data date (e.g., '2023-09-01')
  5999. * @param string $unit The type of data request (e.g., 'cm')
  6000. * @param array $coordinates The latitude and longitude of location
  6001. * @throws \InvalidArgumentException If any parameter has an invalid data type
  6002. */
  6004. public function getFrostThawAndDepth(int $hour, $startDate, $endDate, $unit, array $coordinates, $format)
  6005. {
  6007. try {
  6009. if (count($coordinates) > 1) {
  6011. // Validate the input parameters
  6012. foreach ($coordinates as $coordinate) {
  6013. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  6014. throw new \InvalidArgumentException('Invalid coordinates');
  6015. }
  6016. }
  6018. if (empty($startDate) || empty($endDate)) {
  6019. throw new \InvalidArgumentException('Invalid dates');
  6020. }
  6022. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  6023. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  6025. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $unit, $coordinates, $format);
  6027. // Try to get the data from Redis cache
  6028. $cachedData = $this->redisCache->get($cacheKey);
  6030. if ($cachedData !== null) {
  6031. // Return the cached data if available
  6032. return $cachedData;
  6033. }
  6035. // If cache is empty, get the data from the API
  6036. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  6037. $client = new Client(['verify' => false]);
  6038. $url = sprintf(
  6039. '%s/%s--%s:PT%sH/frost_depth:%s,thaw_depth:%s/%s/%s',
  6040. $this->apiBaseUrl,
  6041. $startDate,
  6042. $endDate,
  6043. $hour,
  6044. $unit,
  6045. $unit,
  6046. $coordinateString,
  6047. $format
  6048. );
  6050. $response = $client->request('GET', $url, [
  6051. 'auth' => [$this->username, $this->password],
  6052. ]);
  6054. $statusCode = $response->getStatusCode();
  6055. $data = json_decode($response->getBody(), true);
  6057. if ($statusCode != 200) {
  6058. return $this->createErrorResponse($statusCode);
  6059. }
  6061. // Set the data to Redis cache
  6062. $this->redisCache->set($cacheKey, $data);
  6063. return $data;
  6064. } else {
  6066. if ($coordinates) {
  6067. $latitude = $coordinates[0][0];
  6068. $longitude = $coordinates[0][1];
  6069. }
  6071. // Validate the input parameters
  6072. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  6073. throw new \InvalidArgumentException('Invalid latitude');
  6074. }
  6076. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  6077. throw new \InvalidArgumentException('Invalid longitude');
  6078. }
  6080. if (empty($startDate)) {
  6081. throw new \InvalidArgumentException('Invalid startDate');
  6082. }
  6083. if (empty($endDate)) {
  6084. throw new \InvalidArgumentException('Invalid endDate');
  6085. }
  6087. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  6088. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  6090. $cacheKey = \App\Lib\Utility::generateKey($hour, $startDate, $endDate, $unit, $latitude, $longitude, $format);
  6092. // Try to get the data from Redis cache
  6093. $cachedData = $this->redisCache->get($cacheKey);
  6095. if ($cachedData !== null) {
  6096. // Return the cached data if available
  6097. return $cachedData;
  6098. }
  6100. // If cache is empty, get the data from the API
  6101. $client = new Client(['verify' => false]);
  6102. $url = sprintf(
  6103. '%s/%s--%s:PT%sH/frost_depth:%s,thaw_depth:%s/%s,%s/%s',
  6104. $this->apiBaseUrl,
  6105. $startDate,
  6106. $endDate,
  6107. $hour,
  6108. $unit,
  6109. $unit,
  6110. $latitude,
  6111. $longitude,
  6112. $format
  6113. );
  6115. $response = $client->request('GET', $url, [
  6116. 'auth' => [$this->username, $this->password],
  6117. ]);
  6119. $statusCode = $response->getStatusCode();
  6120. $data = json_decode($response->getBody(), true);
  6122. if ($statusCode != 200) {
  6123. return $this->createErrorResponse($statusCode);
  6124. }
  6126. // Set the data to Redis cache
  6127. $this->redisCache->set($cacheKey, $data);
  6128. return $data;
  6129. }
  6130. } catch (GuzzleHttp\Exception\RequestException $e) {
  6131. return throw new \Exception($e->getMessage());
  6132. } catch (\Exception $e) {
  6133. return throw new \Exception($e->getMessage());
  6134. }
  6135. }
  6137. public function getReportForecastData(array $coordinates, string $startDate, string $endDate, int $hours, string $model = "ksancm-wrf-48", array $parameters = [], $translator, array $cities, $params)
  6138. {
  6139. try {
  6140. if (count($coordinates) > 1) {
  6141. // Validate the input parameters
  6142. foreach ($coordinates as $coordinate) {
  6143. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  6144. // throw new \InvalidArgumentException('Invalid coordinates');
  6145. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  6146. }
  6147. }
  6148. }else{
  6149. if ($coordinates) {
  6150. $latitude = $coordinates[0][0];
  6151. $longitude = $coordinates[0][1];
  6152. }
  6153. // Validate the input parameters
  6154. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  6155. // throw new \InvalidArgumentException('Invalid latitude');
  6156. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  6157. }
  6158. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  6159. // throw new \InvalidArgumentException('Invalid longitude');
  6160. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  6161. }
  6162. }
  6164. if (empty($startDate) || empty($endDate)) {
  6165. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  6166. // throw new \InvalidArgumentException('Invalid dates');
  6167. }
  6168. if ($hours < 1 and $hours > 24) {
  6169. throw new \InvalidArgumentException('Invalid hour');
  6170. }
  6171. $startDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($startDate)));
  6172. $endDate = date('Y-m-d\TH:i:s.v\Z', (strtotime($endDate)));
  6173. if (empty($parameters)) {
  6174. $parameters = [
  6175. 't_2m:C',
  6176. 't_max_2m_%sh:C',
  6177. 't_min_2m_%sh:C',
  6178. 't_apparent_min_%sh:C',
  6179. 't_apparent_max_%sh:C',
  6180. 'wind_speed_mean_10m_%sh:kmh',
  6181. 'wind_dir_mean_10m_%sh:d',
  6182. 'prob_precip_%sh:p',
  6183. 'precip_%sh:mm',
  6184. 'relative_humidity_mean_2m_%sh:p',
  6185. 'effective_cloud_cover_mean_%sh:octas',
  6186. 'dew_point_mean_2m_%sh:C',
  6187. 'wind_gusts_10m_%sh:kn',
  6188. 'visibility:km',
  6189. ];
  6190. }
  6191. // Create a Redis key for the cache
  6192. $cacheKey = sprintf('daily_forecast_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  6193. return implode('_', $coordinate);
  6194. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, implode('_', $parameters));
  6195. // Try to get the data from Redis cache
  6196. $cachedData = $this->redisCache->get($cacheKey);
  6197. if ($cachedData !== null) {
  6198. // Return the cached data if available
  6199. return $cachedData;
  6200. }
  6202. $timeResolutions = [
  6203. '_24h' => '+1 day',
  6204. '_12h' => '+12 hours',
  6205. '_6h' => '+6 hours',
  6206. '_3h' => '+3 hours',
  6207. '_1h' => '+1 hour'
  6208. ];
  6210. $adjustedParameters = [];
  6211. $nonAdjustedParameters = [];
  6213. foreach ($parameters as $parameter) {
  6214. $matched = false;
  6215. foreach ($timeResolutions as $key => $adjustment) {
  6216. if (strpos($parameter, $key) !== false) {
  6217. $matched = true;
  6218. $adjustedParameters[$adjustment][] = $parameter;
  6219. break;
  6220. }
  6221. }
  6222. if (!$matched) {
  6223. $nonAdjustedParameters[] = $parameter;
  6224. }
  6225. }
  6226. // Construct the URL
  6227. // $url = "{$this->apiBaseUrl}/{$startDate}--{$endDate}:{$duration}/t_2m:C,wind_speed_10m:kmh,wind_dir_10m:d,sfs_pressure:hPa,precip_10min:mm,relative_humidity_2m:p,visibility:km,dew_point_2m:c,wind_gusts_10m_1h:kmh,ceiling_height_agl:m,geopotential_height:m,t_min_2m_24h:C,t_max_2m_24h:C,precip_24h:mm,total_cloud_cover:octas/metar_{$metar}/json?source=mix-obs&on_invalid=fill_with_invalid";
  6228. $dataFinal = [
  6229. 'data' => []
  6230. ];
  6232. foreach ($adjustedParameters as $adjustment => $adjParams) {
  6233. $adjustedStartDate = (new \DateTime($startDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  6234. $adjustedEndDate = (new \DateTime($endDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  6235. $data = $this->fetchReportForecastData($coordinates,$adjustedStartDate,$adjustedEndDate,$hours, $model,$adjParams,$translator,$cities, $params);
  6236. // Revert dates to original range
  6237. if (isset($data['data']) && is_array($data['data'])) {
  6239. foreach ($data['data'] as &$datum) {
  6240. if (isset($datum['coordinates']) && is_array($datum['coordinates'])) {
  6241. foreach ($datum['coordinates'] as &$coordinate) {
  6242. if (isset($coordinate['dates']) && is_array($coordinate['dates'])) {
  6243. foreach ($coordinate['dates'] as &$date) {
  6244. if (isset($date['date'])) {
  6245. // Convert the date back by subtracting the adjustment
  6246. $adjustmentValue = str_replace(['+', ' '], '', $adjustment); // Remove '+' and extra spaces
  6247. $date['date'] = (new \DateTime($date['date']))
  6248. ->modify('-' . $adjustmentValue)
  6249. ->format('Y-m-d\TH:i:s\Z');
  6250. }
  6251. }
  6252. }
  6253. }
  6254. }
  6255. }
  6256. } else {
  6257. $data['data'] = []; // Ensure 'data' exists
  6258. }
  6260. // Merge into $dataFinal
  6261. if (empty($dataFinal['version'])) {
  6262. $dataFinal['version'] = $data['version'] ?? null;
  6263. $dataFinal['user'] = $data['user'] ?? null;
  6264. $dataFinal['dateGenerated'] = $data['dateGenerated'] ?? null;
  6265. $dataFinal['status'] = $data['status'] ?? null;
  6266. }
  6268. if (isset($data['data']) && is_array($data['data'])) {
  6269. $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  6270. }
  6271. }
  6272. // Process non-adjusted parameters
  6273. if (!empty($nonAdjustedParameters)) {
  6274. $data= $this->fetchReportForecastData($coordinates,$startDate,$endDate,$hours, $model ,$nonAdjustedParameters,$translator,$cities, $params);
  6275. if (isset($data['data']) && is_array($data['data'])) {
  6276. $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  6277. }
  6278. }
  6279. // Reorder data based on parameters
  6280. $dataFinal['data'] = isset($dataFinal['data']) && is_array($dataFinal['data'])
  6281. ? $this->orderResults($dataFinal['data'], $parameters)
  6282. : [];
  6284. $result = [];
  6285. foreach ($dataFinal['data'] as $param) {
  6286. foreach ($param['coordinates'] as $paramCoordinates) {
  6287. // exit;
  6288. $paramCoordinates['lat'] = number_format($paramCoordinates['lat'], 6, '.', '');
  6289. $paramCoordinates['lon'] = number_format($paramCoordinates['lon'], 6, '.', '');
  6290. $cityKey = $paramCoordinates['lat'] . '|' . $paramCoordinates['lon'];
  6291. if (!isset($result[$cityKey])) {
  6292. $result[$cityKey] = [];
  6293. if (isset($cities[$cityKey]['en'])) {
  6294. $result[$cityKey] = [
  6295. 'cityEn' => $cities[$cityKey]['en'],
  6296. 'cityAr' => $cities[$cityKey]['ar'],
  6297. 'lat' => $paramCoordinates['lat'],
  6298. 'lon' => $paramCoordinates['lon'],
  6299. 'parameters' => [],
  6300. ];
  6301. } else {
  6302. $result[$cityKey] = [
  6303. 'city' => $cities[$cityKey],
  6304. 'lat' => $paramCoordinates['lat'],
  6305. 'lon' => $paramCoordinates['lon'],
  6306. 'parameters' => [],
  6307. ];
  6308. }
  6309. }
  6310. $parameterData = [
  6311. 'parameter' => $param['parameter'],
  6312. 'dates' => [],
  6313. ];
  6314. foreach ($paramCoordinates['dates'] as $item) {
  6315. $parameterData['dates'][] = [
  6316. 'date' => $item['date'], // You can modify this as needed
  6317. 'value' => $item['value'], // You can modify this as needed
  6318. ];
  6319. }
  6321. // p_r($parameterData);
  6322. $result[$cityKey]['parameters'][] = $parameterData;
  6323. }
  6324. }
  6326. $result = array_values($result);
  6327. if (isset($params['report_type_id']) && !empty($params['report_type_id'])) {
  6328. $latestReport = new Report\Listing();
  6329. $latestReport->setCondition('reportType__id = ?', [$params['report_type_id']]);
  6330. $latestReport->setOrderKey("o_creationDate");
  6331. $latestReport->setOrder("desc");
  6332. $latestReport = $latestReport->current();
  6333. if ($latestReport) {
  6334. $jsonData = json_decode($latestReport->getJsonData(), true);
  6335. foreach ($result as &$value) {
  6336. // Compare latitude and longitude
  6337. foreach ($jsonData as $jsonEntry) {
  6338. if ($value['lat'] == $jsonEntry['lat'] && $value['lon'] == $jsonEntry['lon']) {
  6339. // Latitude and longitude match, proceed with parameter comparison
  6340. foreach ($value['parameters'] as &$paramValue) {
  6341. foreach ($jsonEntry['parameters'] as $jsonParam) {
  6342. if ($jsonParam['parameter'] == $paramValue['parameter']) {
  6343. // Parameter matches, check dates now
  6344. foreach ($paramValue['dates'] as &$dateValue) {
  6345. foreach ($jsonParam['dates'] as $jsonDate) {
  6346. if ($dateValue['date'] == $jsonDate['date']) {
  6347. // Exact match found, override the value
  6348. $dateValue['value'] = $jsonDate['value'];
  6349. // Continue checking all dates, no break here
  6350. }
  6351. }
  6352. }
  6353. unset($dateValue); // Ensure reference is not carried over
  6354. }
  6355. }
  6356. }
  6357. unset($paramValue); // Ensure reference is not carried over
  6358. }
  6359. }
  6360. }
  6361. unset($value); // Ensure reference is not carried over
  6362. }
  6363. }
  6365. // Set the data to Redis cache
  6366. $this->redisCache->set($cacheKey, $dataFinal);
  6367. return $result;
  6368. } catch (GuzzleHttp\Exception\RequestException $e) {
  6369. return throw new \Exception($e->getMessage());
  6370. } catch (\Exception $e) {
  6371. return throw new \Exception($e->getMessage());
  6372. }
  6373. }
  6375. public function fetchReportForecastData($coordinates,$startDate,$endDate,$hours, $model,$parameters,$translator,$cities, $params){
  6376. $dataFinal = [];
  6377. $client = new Client(['verify' => false]);
  6378. if (count($coordinates) > 1) {
  6379. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  6380. }else{
  6381. if ($coordinates) {
  6382. $latitude = $coordinates[0][0];
  6383. $longitude = $coordinates[0][1];
  6384. }
  6385. }
  6386. while (!empty($parameters)) {
  6388. $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  6389. $batchQueryString = implode(',', $batchParameters);
  6390. $batchQueryString = str_replace('%s', $hours, $batchQueryString);
  6392. if (count($coordinates) > 1) {
  6393. $url = sprintf(
  6394. '%s/%s--%s:PT%sH/%s/%s/json?model=%s',
  6395. $this->apiBaseUrl,
  6396. $startDate,
  6397. $endDate,
  6398. $hours,
  6399. $batchQueryString,
  6400. $coordinateString,
  6401. $model
  6402. );
  6403. }else{
  6404. $url = sprintf(
  6405. '%s/%s--%s:PT%sH/%s/%s,%s/json?model=%s',
  6406. $this->apiBaseUrl,
  6407. $startDate,
  6408. $endDate,
  6409. $hours,
  6410. $batchQueryString,
  6411. $latitude,
  6412. $longitude,
  6413. $model
  6414. );
  6415. }
  6416. $response = $client->request('GET', $url, [
  6417. 'auth' => [$this->username, $this->password],
  6418. ]);
  6419. $statusCode = $response->getStatusCode();
  6420. $data = json_decode($response->getBody(), true);
  6421. // Merge data from the current API call into the final data
  6422. $dataFinal['data'] = array_merge($dataFinal['data'] ?? [], $data['data']);
  6423. }
  6424. foreach ($coordinates as $coOrd) {
  6425. $weatherSymbols = $this->getWeatherSymbols([$coOrd], $startDate, $endDate, 'PT' . $hours . 'H', $hours . 'h', true);
  6426. if (isset($weatherSymbols['data'][0]['parameter'])) {
  6427. $dataFinal['symbols'][$coOrd[0] . '|' . $coOrd[1]] = $weatherSymbols['data'][0];
  6428. }
  6429. }
  6430. // p_r($dataFinal);
  6431. // exit;
  6433. // Convert the associative array to indexed array
  6435. return $dataFinal;
  6437. }
  6440. public function getAdminReportForecastData(array $coordinates, string $startDate, string $endDate, string $model = "ksancm-wrf-48", array $parameters12h = [], array $parameters24h = [], $translator, array $cities, $params)
  6441. {
  6442. try {
  6444. if (isset($params['report_type_id']) && !empty($params['report_type_id'])) {
  6445. $latestReport = new Report\Listing();
  6446. $reportType = \Pimcore\Model\DataObject::getById($params['report_type_id']);
  6447. $latestReport->filterByReportType($reportType);
  6448. $latestReport->setOrderKey("createdOn");
  6449. $latestReport->setLimit(1);
  6450. $latestReport->setOrder("desc");
  6451. $latestReport = $latestReport->current();
  6452. }
  6454. if (count($coordinates) > 1) {
  6456. // Validate the input parameters
  6457. foreach ($coordinates as $coordinate) {
  6458. if (count($coordinate) < 2 || !is_numeric($coordinate[0]) || !is_numeric($coordinate[1])) {
  6459. // throw new \InvalidArgumentException('Invalid coordinates');
  6460. return ["success" => false, "message" => $translator->trans("invalid_coordinates")];
  6461. }
  6462. }
  6463. if (empty($startDate) || empty($endDate)) {
  6464. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  6465. // throw new \InvalidArgumentException('Invalid dates');
  6466. }
  6468. // Create a Redis key for the cache
  6469. $cacheKey = sprintf('daily_forecast_%s_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  6470. return implode('_', $coordinate);
  6471. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, implode('_', $parameters12h), implode('_', $parameters24h));
  6472. // Try to get the data from Redis cache
  6473. $cachedData = $this->redisCache->get($cacheKey);
  6474. if ($cachedData !== null) {
  6475. // Return the cached data if available
  6476. // return $cachedData;
  6477. }
  6478. // If cache is empty, get the data from the API
  6479. $client = new Client(['verify' => false]);
  6480. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  6481. $dataFinal = [];
  6482. // Function to perform the API requests for given parameters and hours
  6483. $performApiRequests = function ($parameters, $hours, $startDate, $endDate) use ($client, $coordinateString, $model) {
  6484. $data = [];
  6485. while (!empty($parameters)) {
  6486. $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  6487. $batchQueryString = implode(',', $batchParameters);
  6488. $url = sprintf(
  6489. '%s/%s--%s:PT%sH/%s/%s/json?model=%s',
  6490. $this->apiBaseUrl,
  6491. $startDate,
  6492. $endDate,
  6493. $hours,
  6494. $batchQueryString,
  6495. $coordinateString,
  6496. $model
  6497. );
  6498. $response = $client->request('GET', $url, [
  6499. 'auth' => [$this->username, $this->password],
  6500. ]);
  6501. $statusCode = $response->getStatusCode();
  6502. $dataBatch = json_decode($response->getBody(), true);
  6503. // Merge data from the current API call into the data array
  6504. $data['data'] = array_merge($data['data'] ?? [], $dataBatch['data']);
  6505. }
  6506. return $data;
  6507. };
  6510. // Process 24h parameters
  6511. if (!empty($parameters24h)) {
  6513. $startDateUpdated = new DateTime($startDate);
  6514. $endDateUpdated = new DateTime($endDate);
  6516. $startDateUpdated = $startDateUpdated->modify('+1 day')->format('Y-m-d\TH:i:s\Z');
  6517. $endDateUpdated = $endDateUpdated->modify('+1 day')->format('Y-m-d\TH:i:s\Z');
  6520. $data24h = $performApiRequests($parameters24h, 24, $startDateUpdated, $endDateUpdated);
  6522. if (!empty($data24h)) {
  6523. foreach ($data24h['data'] as &$datum) {
  6525. if (isset($datum['coordinates'])) {
  6526. foreach ($datum['coordinates'] as &$coordinate) {
  6527. foreach ($coordinate['dates'] as &$date) {
  6528. $dateObj = new DateTime($date['date']);
  6529. $date['date'] = $dateObj->modify('-1 day')->format('Y-m-d\TH:i:s\Z');
  6530. }
  6531. }
  6532. }
  6533. }
  6535. // Correctly append 24h data to $datainal
  6536. if (!empty($data24h['data'])) {
  6537. // Existing code to adjust dates in $data24h['data']
  6538. if (empty($dataFinal['data'])) {
  6539. $dataFinal['data'] = $data24h['data'];
  6540. } else {
  6541. $dataFinal['data'] = array_merge($dataFinal['data'], $data24h['data']);
  6542. }
  6543. }
  6544. }
  6545. }
  6547. // Process 12h parameters
  6548. if (!empty($parameters12h)) {
  6550. $startDateUpdated = new DateTime($startDate);
  6551. $endDateUpdated = new DateTime($endDate);
  6553. $startDateUpdated = $startDateUpdated->modify('+1 day')->format('Y-m-d\T12\Z');
  6554. $endDateUpdated = $endDateUpdated->modify('+1 day')->format('Y-m-d\T00\Z');
  6556. $data12h = $performApiRequests($parameters12h, 12, $startDateUpdated, $endDateUpdated);
  6558. if (!empty($data12h)) {
  6560. foreach ($data12h['data'] as &$datum) {
  6562. if (isset($datum['coordinates'])) {
  6563. foreach ($datum['coordinates'] as &$coordinate) {
  6564. foreach ($coordinate['dates'] as &$date) {
  6565. $dateObj = new DateTime($date['date']);
  6566. $date['date'] = $dateObj->modify('-1 day')->format('Y-m-d\TH:i:s\Z');
  6567. }
  6568. }
  6569. }
  6570. }
  6571. // Correctly append 12h data to $dataFinal
  6572. if (!empty($data12h['data'])) {
  6573. // Existing code to adjust dates in $data12h['data']
  6574. if (empty($dataFinal['data'])) {
  6575. $dataFinal['data'] = $data12h['data'];
  6576. } else {
  6577. $dataFinal['data'] = array_merge($dataFinal['data'], $data12h['data']);
  6578. }
  6579. }
  6580. }
  6581. }
  6583. foreach ($coordinates as $coOrd) {
  6584. $weatherSymbols = $this->getWeatherSymbols([$coOrd], $startDate, $endDate, 'PT12H', '12h');
  6585. if (isset($weatherSymbols['data'][0]['parameter'])) {
  6586. $dataFinal['symbols'][$coOrd[0] . '|' . $coOrd[1]] = $weatherSymbols['data'][0];
  6587. }
  6588. }
  6590. $result = [];
  6592. foreach ($dataFinal['data'] as $param) {
  6594. foreach ($param['coordinates'] as $paramCoordinates) {
  6596. $paramCoordinates['lat'] = number_format($paramCoordinates['lat'], 6, '.', '');
  6597. $paramCoordinates['lon'] = number_format($paramCoordinates['lon'], 6, '.', '');
  6598. $cityKey = $paramCoordinates['lat'] . '|' . $paramCoordinates['lon'];
  6600. if (!isset($result[$cityKey])) {
  6601. $result[$cityKey] = [];
  6602. if (isset($cities[$cityKey]['en'])) {
  6603. if (isset($paramCoordinates['lat']) && isset($paramCoordinates['lon'])) {
  6604. $result[$cityKey] = [
  6605. 'cityEn' => $cities[$cityKey]['en'],
  6606. 'cityAr' => $cities[$cityKey]['ar'],
  6607. 'lat' => $paramCoordinates['lat'],
  6608. 'lon' => $paramCoordinates['lon'],
  6609. 'parameters' => [],
  6610. ];
  6611. }
  6612. } else {
  6613. if (isset($paramCoordinates['lat']) && isset($paramCoordinates['lon'])) {
  6614. $result[$cityKey] = [
  6615. 'city' => $cities[$cityKey],
  6616. 'lat' => $paramCoordinates['lat'],
  6617. 'lon' => $paramCoordinates['lon'],
  6618. 'parameters' => [],
  6619. ];
  6620. }
  6621. }
  6622. }
  6624. $parameterData = [
  6625. 'parameter' => $param['parameter'],
  6626. 'dates' => [],
  6627. ];
  6629. foreach ($paramCoordinates['dates'] as $date) {
  6630. $parameterData['dates'][] = [
  6631. 'date' => $date['date'], // You can modify this as needed
  6632. 'value' => $date['value'], // You can modify this as needed
  6633. ];
  6634. }
  6636. $result[$cityKey]['parameters'][] = $parameterData;
  6637. }
  6638. }
  6640. // Convert the associative array to indexed array
  6641. $result = array_values($result);
  6642. if (isset($params['report_type_id']) && !empty($params['report_type_id'])) {
  6644. // $latestReport = new Report\Listing();
  6645. // $reportType = \Pimcore\Model\DataObject::getById($params['report_type_id']);
  6646. // $latestReport->filterByReportType($reportType);
  6647. // $latestReport->setOrderKey("createdOn");
  6648. // $latestReport->setOrder("desc");
  6649. // $latestReport = $latestReport->current();
  6651. if ($latestReport) {
  6652. $jsonData = json_decode($latestReport->getJsonData(), true);
  6653. foreach ($result as &$value) {
  6654. // Compare latitude and longitude
  6655. foreach ($jsonData as $jsonEntry) {
  6656. if (isset($value['lat']) && isset($jsonEntry['lat']) && ($value['lat'] == $jsonEntry['lat']) && isset($value['lon']) && isset($jsonEntry['lon']) && ($value['lon'] == $jsonEntry['lon'])) {
  6657. // Latitude and longitude match, proceed with parameter comparison
  6658. foreach ($value['parameters'] as &$paramValue) {
  6659. foreach ($jsonEntry['parameters'] as $jsonParam) {
  6660. if ($jsonParam['parameter'] == $paramValue['parameter']) {
  6661. // Parameter matches, check dates now
  6662. foreach ($paramValue['dates'] as &$dateValue) {
  6663. foreach ($jsonParam['dates'] as $jsonDate) {
  6664. if ($dateValue['date'] == $jsonDate['date']) {
  6665. // Exact match found, override the value
  6666. $dateValue['value'] = $jsonDate['value'];
  6667. // Continue checking all dates, no break here
  6668. }
  6669. }
  6670. }
  6671. unset($dateValue); // Ensure reference is not carried over
  6672. }
  6673. }
  6674. }
  6675. unset($paramValue); // Ensure reference is not carried over
  6676. }
  6677. }
  6678. }
  6679. unset($value); // Ensure reference is not carried over
  6680. }
  6681. }
  6682. } else {
  6684. if ($coordinates) {
  6685. $latitude = $coordinates[0][0];
  6686. $longitude = $coordinates[0][1];
  6687. }
  6688. // Validate the input parameters
  6689. if (!preg_match('/^[-]?[0-9]{1,2}\.[0-9]+/', $latitude)) {
  6690. // throw new \InvalidArgumentException('Invalid latitude');
  6691. return ["success" => false, "message" => $translator->trans("invalid_latitude")];
  6692. }
  6693. if (!preg_match('/^[-]?[0-9]{1,3}\.[0-9]+/', $longitude)) {
  6694. // throw new \InvalidArgumentException('Invalid longitude');
  6695. return ["success" => false, "message" => $translator->trans("invalid_longitude")];
  6696. }
  6697. if (empty($startDate) || empty($endDate)) {
  6698. return ["success" => false, "message" => $translator->trans("invalid_dates")];
  6699. }
  6702. // Create a Redis key for the cache
  6703. $cacheKey = sprintf('daily_forecast_%s_%s_%s_%s', implode('_', array_map(function ($coordinate) {
  6704. return implode('_', $coordinate);
  6705. }, $coordinates)), (($startDate) . '-' . ($endDate)) . $model, implode('_', $parameters12h), implode('_', $parameters24h));
  6706. // Try to get the data from Redis cache
  6707. $cachedData = $this->redisCache->get($cacheKey);
  6708. if ($cachedData !== null) {
  6709. // Return the cached data if available
  6710. return $cachedData;
  6711. }
  6714. // If cache is empty, get the data from the API
  6715. $client = new Client(['verify' => false]);
  6716. $coordinateString = implode('+', array_map(fn($coords) => implode(',', $coords), $coordinates));
  6717. $dataFinal = [];
  6718. // Function to perform the API requests for given parameters and hours
  6719. $performApiRequests = function ($parameters, $hours, $startDate, $endDate) use ($client, $latitude, $longitude, $model) {
  6720. $data = [];
  6721. while (!empty($parameters)) {
  6722. $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  6723. $batchQueryString = implode(',', $batchParameters);
  6724. $url = sprintf(
  6725. '%s/%s--%s:PT%sH/%s/%s,%s/json?model=%s',
  6726. $this->apiBaseUrl,
  6727. $startDate,
  6728. $endDate,
  6729. $hours,
  6730. $batchQueryString,
  6731. $latitude,
  6732. $longitude,
  6733. $model
  6734. );
  6735. $response = $client->request('GET', $url, [
  6736. 'auth' => [$this->username, $this->password],
  6737. 'timeout' => 600
  6738. ]);
  6739. $statusCode = $response->getStatusCode();
  6740. $dataBatch = json_decode($response->getBody(), true);
  6741. // Merge data from the current API call into the data array
  6742. $data['data'] = array_merge($data['data'] ?? [], $dataBatch['data']);
  6743. }
  6744. return $data;
  6745. };
  6749. // Process 24h parameters
  6750. if (!empty($parameters24h)) {
  6752. $startDateUpdated = new DateTime($startDate);
  6753. $endDateUpdated = new DateTime($endDate);
  6755. $startDateUpdated = $startDateUpdated->modify('+1 day')->format('Y-m-d\TH:i:s\Z');
  6756. $endDateUpdated = $endDateUpdated->modify('+1 day')->format('Y-m-d\TH:i:s\Z');
  6759. $data24h = $performApiRequests($parameters24h, 24, $startDateUpdated, $endDateUpdated);
  6761. if (!empty($data24h)) {
  6762. foreach ($data24h['data'] as &$datum) {
  6764. if (isset($datum['coordinates'])) {
  6765. foreach ($datum['coordinates'] as &$coordinate) {
  6766. foreach ($coordinate['dates'] as &$date) {
  6767. $dateObj = new DateTime($date['date']);
  6768. $date['date'] = $dateObj->modify('-1 day')->format('Y-m-d\TH:i:s\Z');
  6769. }
  6770. }
  6771. }
  6772. }
  6774. // Correctly append 24h data to $datainal
  6775. if (!empty($data24h['data'])) {
  6776. // Existing code to adjust dates in $data24h['data']
  6777. if (empty($dataFinal['data'])) {
  6778. $dataFinal['data'] = $data24h['data'];
  6779. } else {
  6780. $dataFinal['data'] = array_merge($dataFinal['data'], $data24h['data']);
  6781. }
  6782. }
  6783. }
  6784. }
  6786. // Process 12h parameters
  6787. if (!empty($parameters12h)) {
  6789. $startDateUpdated = new DateTime($startDate);
  6790. $endDateUpdated = new DateTime($endDate);
  6792. $startDateUpdated = $startDateUpdated->modify('+1 day')->format('Y-m-d\T12\Z');
  6793. $endDateUpdated = $endDateUpdated->modify('+1 day')->format('Y-m-d\T00\Z');
  6795. $data12h = $performApiRequests($parameters12h, 12, $startDateUpdated, $endDateUpdated);
  6797. if (!empty($data12h)) {
  6799. foreach ($data12h['data'] as &$datum) {
  6801. if (isset($datum['coordinates'])) {
  6802. foreach ($datum['coordinates'] as &$coordinate) {
  6803. foreach ($coordinate['dates'] as &$date) {
  6804. $dateObj = new DateTime($date['date']);
  6805. $date['date'] = $dateObj->modify('-1 day')->format('Y-m-d\TH:i:s\Z');
  6806. }
  6807. }
  6808. }
  6809. }
  6810. // Correctly append 12h data to $dataFinal
  6811. if (!empty($data12h['data'])) {
  6812. // Existing code to adjust dates in $data12h['data']
  6813. if (empty($dataFinal['data'])) {
  6814. $dataFinal['data'] = $data12h['data'];
  6815. } else {
  6816. $dataFinal['data'] = array_merge($dataFinal['data'], $data12h['data']);
  6817. }
  6818. }
  6819. }
  6820. }
  6822. foreach ($coordinates as $coOrd) {
  6823. $weatherSymbols = $this->getWeatherSymbols([$coOrd], $startDate, $endDate, 'PT12H', '12h');
  6824. if (isset($weatherSymbols['data'][0]['parameter'])) {
  6825. $dataFinal['symbols'][$coOrd[0] . '|' . $coOrd[1]] = $weatherSymbols['data'][0];
  6826. }
  6827. }
  6831. $result = [];
  6833. foreach ($dataFinal['data'] as $param) {
  6834. foreach ($param['coordinates'] as $paramCoordinates) {
  6835. $paramCoordinates['lat'] = number_format($paramCoordinates['lat'], 6, '.', '');
  6836. $paramCoordinates['lon'] = number_format($paramCoordinates['lon'], 6, '.', '');
  6837. $cityKey = $paramCoordinates['lat'] . '|' . $paramCoordinates['lon'];
  6839. if (!isset($result[$cityKey])) {
  6840. $result[$cityKey] = [];
  6841. if (isset($cities[$cityKey]['en'])) {
  6843. $result[$cityKey] = [
  6844. 'cityEn' => $cities[$cityKey]['en'],
  6845. 'cityAr' => $cities[$cityKey]['ar'],
  6846. 'lat' => $paramCoordinates['lat'],
  6847. 'lon' => $paramCoordinates['lon'],
  6848. 'parameters' => [],
  6849. ];
  6850. } else {
  6851. $result[$cityKey] = [
  6852. 'city' => $cities[$cityKey],
  6853. 'lat' => $paramCoordinates['lat'],
  6854. 'lon' => $paramCoordinates['lon'],
  6855. 'parameters' => [],
  6856. ];
  6857. }
  6858. }
  6860. $parameterData = [
  6861. 'parameter' => $param['parameter'],
  6862. 'dates' => [],
  6863. ];
  6865. foreach ($paramCoordinates['dates'] as $date) {
  6866. $parameterData['dates'][] = [
  6867. 'date' => $date['date'], // You can modify this as needed
  6868. 'value' => $date['value'], // You can modify this as needed
  6869. ];
  6870. }
  6872. $result[$cityKey]['parameters'][] = $parameterData;
  6873. }
  6874. }
  6876. // Convert the associative array to indexed array
  6877. $result = array_values($result);
  6878. if (isset($params['report_type_id']) && !empty($params['report_type_id'])) {
  6879. // $latestReport = new Report\Listing();
  6880. // $reportType = \Pimcore\Model\DataObject::getById($params['report_type_id']);
  6881. // $latestReport->filterByReportType($reportType);
  6882. // $latestReport->setOrderKey("createdOn");
  6883. // $latestReport->setOrder("desc");
  6884. // $latestReport = $latestReport->current();
  6885. if ($latestReport) {
  6886. $jsonData = json_decode($latestReport->getJsonData(), true);
  6887. foreach ($result as &$value) {
  6888. // Compare latitude and longitude
  6889. foreach ($jsonData as $jsonEntry) {
  6890. if ($value['lat'] == $jsonEntry['lat'] && $value['lon'] == $jsonEntry['lon']) {
  6891. // Latitude and longitude match, proceed with parameter comparison
  6892. foreach ($value['parameters'] as &$paramValue) {
  6893. foreach ($jsonEntry['parameters'] as $jsonParam) {
  6894. if ($jsonParam['parameter'] == $paramValue['parameter']) {
  6895. // Parameter matches, check dates now
  6896. foreach ($paramValue['dates'] as &$dateValue) {
  6897. foreach ($jsonParam['dates'] as $jsonDate) {
  6898. if ($dateValue['date'] == $jsonDate['date']) {
  6899. // Exact match found, override the value
  6900. $dateValue['value'] = $jsonDate['value'];
  6901. // Continue checking all dates, no break here
  6902. }
  6903. }
  6904. }
  6905. unset($dateValue); // Ensure reference is not carried over
  6906. }
  6907. }
  6908. }
  6909. unset($paramValue); // Ensure reference is not carried over
  6910. }
  6911. }
  6912. }
  6913. unset($value); // Ensure reference is not carried over
  6914. }
  6915. }
  6916. }
  6917. // Set the data to Redis cache
  6918. // $this->redisCache->set($cacheKey, $dataFinal);
  6919. return $result;
  6920. } catch (GuzzleHttp\Exception\RequestException $e) {
  6921. // p_r($e->getMessage());
  6922. return throw new \Exception($e->getMessage());
  6923. } catch (\Exception $e) {
  6924. return throw new \Exception($e->getMessage());
  6925. }
  6926. }
  6929. public function getBarbs(string $windSpeed, string $dateTime, string $resolution, string $accessToken): array
  6930. {
  6931. try {
  6932. $client = new Client(['verify' => false]);
  6933. $url = sprintf(
  6934. "%s/mvt/barbs/%s/style.json?datetime=%s&resolution=%s&access_token=%s",
  6935. $this->apiBaseUrl,
  6936. $windSpeed,
  6937. $dateTime,
  6938. $resolution,
  6939. $accessToken
  6940. );
  6942. $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  6943. $data = json_decode($response->getBody(), true);
  6944. return $data;
  6945. } catch (RequestException $e) {
  6946. throw new \Exception($e->getMessage());
  6947. } catch (\Exception $e) {
  6948. throw new \Exception($e->getMessage());
  6949. }
  6950. }
  6952. public function getIsolines(string $measure, string $dateTime, string $accessToken): array
  6953. {
  6954. try {
  6955. $client = new Client(['verify' => false]);
  6956. $url = sprintf(
  6957. "%s/mvt/isolines/%s/style.json?datetime=%s&access_token=%s",
  6958. $this->apiBaseUrl,
  6959. $measure,
  6960. $dateTime,
  6961. $accessToken
  6962. );
  6964. $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  6965. $data = json_decode($response->getBody(), true);
  6966. return $data;
  6967. } catch (RequestException $e) {
  6968. throw new \Exception($e->getMessage());
  6969. } catch (\Exception $e) {
  6970. throw new \Exception($e->getMessage());
  6971. }
  6972. }
  6974. public function getAviationReports(string $meter, string $dateTime, string $accessToken): array
  6975. {
  6976. try {
  6977. $client = new Client(['verify' => false]);
  6978. $url = sprintf(
  6979. "%s/mvt/aviation_reports/%s/style.json?datetime=%s&access_token=%s",
  6980. $this->apiBaseUrl,
  6981. $meter,
  6982. $dateTime,
  6983. $accessToken
  6984. );
  6986. $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  6987. $data = json_decode($response->getBody(), true);
  6988. return $data;
  6989. } catch (RequestException $e) {
  6990. throw new \Exception($e->getMessage());
  6991. } catch (\Exception $e) {
  6992. throw new \Exception($e->getMessage());
  6993. }
  6994. }
  6996. public function getOceanCurrentSpeed(string $dateTime, string $bBox): array
  6997. {
  6998. try {
  6999. $client = new Client(['verify' => false]);
  7000. $url = sprintf(
  7001. "%s/%s/ocean_current_u:ms,ocean_current_v:ms/%s/json",
  7002. $this->apiBaseUrl,
  7003. $dateTime,
  7004. $bBox
  7005. );
  7007. $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7008. $data = json_decode($response->getBody(), true);
  7009. return $data;
  7010. } catch (RequestException $e) {
  7011. throw new \Exception($e->getMessage());
  7012. } catch (\Exception $e) {
  7013. throw new \Exception($e->getMessage());
  7014. }
  7015. }
  7017. public function getWMSMAP(string $legendGraphics, string $format, string $layer, string $style = '')
  7018. {
  7019. try {
  7020. $client = new Client(['verify' => false]);
  7022. // Conditionally add the STYLE parameter to the URL if it's provided
  7023. $stylePart = $style ? "&STYLE=" . urlencode($style) : '';
  7025. $url = sprintf(
  7026. "%s/wms?VERSION=1.3.0&REQUEST=%s&FORMAT=%s&LAYER=%s%s",
  7027. $this->apiBaseUrl,
  7028. $legendGraphics,
  7029. $format,
  7030. $layer,
  7031. $stylePart
  7032. );
  7034. $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7036. // Get the raw body content
  7037. $content = $response->getBody()->getContents();
  7039. // Set headers and create a response object for the PNG image
  7040. $httpResponse = new Response($content, Response::HTTP_OK, [
  7041. 'Content-Type' => $format
  7042. ]);
  7044. return $httpResponse;
  7045. } catch (RequestException $e) {
  7046. throw new \Exception($e->getMessage());
  7047. } catch (\Exception $e) {
  7048. throw new \Exception($e->getMessage());
  7049. }
  7050. }
  7053. public function getWeatherStationData(string $typeName, string $parameters, string $dateTime, string $bBox)
  7054. {
  7055. try {
  7056. $client = new Client(['verify' => false]);
  7057. $url = sprintf(
  7058. "%s/wfs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME=%s&PARAMETERS=%s&TIME=%s&BBOX=%s",
  7059. $this->apiBaseUrl,
  7060. $typeName,
  7061. $parameters,
  7062. $dateTime,
  7063. $bBox
  7064. );
  7066. $response = $client->request('GET', $url, ['auth' => [$this->username, $this->password]]);
  7068. // Get the raw body content
  7069. $content = $response->getBody()->getContents();
  7071. // Set headers and create a response object for the XML File
  7072. $httpResponse = new Response($content, Response::HTTP_OK, [
  7073. 'Content-Type' => 'application/xml'
  7074. ]);
  7076. return $httpResponse;
  7078. // return $response->getBody();
  7079. } catch (RequestException $e) {
  7080. throw new \Exception($e->getMessage());
  7081. } catch (\Exception $e) {
  7082. throw new \Exception($e->getMessage());
  7083. }
  7084. }
  7086. function getGridLayer($dateTime, $parameter, $coordinates, $resolution, $format, $source, $bbox, $calibrated, $translator)
  7087. {
  7088. try {
  7090. if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $dateTime)) {
  7091. throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7092. }
  7094. if (!$parameter) {
  7095. throw new \InvalidArgumentException($translator->trans('invalid_unit'));
  7096. }
  7098. if (count($coordinates) < 1 || !is_array($coordinates[0]) || count($coordinates[0]) < 2) {
  7099. throw new \InvalidArgumentException($translator->trans('invalid_co_ordinates'));
  7100. }
  7102. if (!preg_match('/^\d+x\d+$/', $resolution)) {
  7103. throw new \InvalidArgumentException($translator->trans('invalid_resolution'));
  7104. }
  7106. if (!in_array($format, ['json', 'xml', 'csv'])) {
  7107. throw new \InvalidArgumentException($translator->trans('invalid_format'));
  7108. }
  7110. if (!is_string($source)) {
  7111. throw new \InvalidArgumentException($translator->trans('invalid_source'));
  7112. }
  7114. if (count($bbox) !== 4) {
  7115. throw new \InvalidArgumentException($translator->trans('invalid_bbox_elements'));
  7116. }
  7118. if (!in_array($calibrated, ['true', 'false'])) {
  7119. throw new \InvalidArgumentException($translator->trans('invalid_calibrated_value'));
  7120. }
  7122. $dateTime = urlencode($dateTime);
  7123. $coordinateString = implode('_', array_map(fn($coords) => implode(',', $coords), $coordinates));
  7124. $bboxString = implode(',', $bbox);
  7126. $cacheKey = \App\Lib\Utility::generateKey($dateTime, $coordinateString, $bboxString, $parameter);
  7127. $cachedData = $this->redisCache->get($cacheKey);
  7129. if ($cachedData !== null) {
  7130. // Return the cached data if available
  7131. return $cachedData;
  7132. }
  7134. // Construct the URL
  7135. $url = "{$this->apiBaseUrl}/{$dateTime}/{$parameter}/{$coordinateString}:{$resolution}/{$format}?source={$source}&bbox={$bboxString}&calibrated={$calibrated}";
  7137. $client = new Client(['verify' => false]);
  7139. $response = $client->request('GET', $url, [
  7140. 'auth' => [$this->username, $this->password],
  7141. ]);
  7143. $statusCode = $response->getStatusCode();
  7144. $data = json_decode($response->getBody(), true);
  7146. if ($statusCode != 200) {
  7147. return $this->createErrorResponse($statusCode);
  7148. }
  7150. // Set the data to Redis cache
  7151. $this->redisCache->set($cacheKey, $data);
  7152. return $data;
  7153. } catch (RequestException $e) {
  7154. throw new \Exception($e->getMessage());
  7155. } catch (\Exception $e) {
  7156. throw new \Exception($e->getMessage());
  7157. }
  7158. }
  7161. public function getMetarData($startDate, $endDate, $metar, $duration, $translator, $parameter, $genExcel)
  7162. {
  7163. try {
  7164. // if (!preg_match('/^20\d{2}-\d{2}-\d{2}T\d{2}Z$/', $startDate)) {
  7165. // throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7166. // }
  7167. // if (!preg_match('/^20\d{2}-\d{2}-\d{2}T\d{2}Z$/', $endDate)) {
  7168. // throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7169. // }
  7170. if (!preg_match('/^20\d{2}-\d{2}-\d{2}T\d{2}(:\d{2}(:\d{2}(\.\d{3})?)?)?Z$/', $startDate)) {
  7171. throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7172. }
  7173. if (!preg_match('/^20\d{2}-\d{2}-\d{2}T\d{2}(:\d{2}(:\d{2}(\.\d{3})?)?)?Z$/', $endDate)) {
  7174. throw new \InvalidArgumentException($translator->trans('invalid_date_format'));
  7175. }
  7176. $cacheKey = \App\Lib\Utility::generateKey($startDate, $endDate, $metar, $duration, $parameter);
  7177. $cachedData = $this->redisCache->get($cacheKey);
  7178. if ($cachedData !== null && !$genExcel) {
  7179. // Return the cached data if available
  7180. return $cachedData;
  7181. }
  7182. if ($genExcel) {
  7183. $parameters[] = $parameter;
  7184. } elseif (!empty($parameter) && !$genExcel) {
  7185. $parameters = $parameter;
  7186. } else {
  7187. $parameters = [
  7188. 't_2m:C',
  7189. 'wind_speed_10m:kmh',
  7190. 'wind_dir_10m:d',
  7191. 'msl_pressure:hPa',
  7192. 'precip_1h:mm',
  7193. 'relative_humidity_2m:p',
  7194. 'visibility:km',
  7195. 'dew_point_2m:c',
  7196. 'wind_gusts_10m_1h:kmh',
  7197. 'ceiling_height_agl:m',
  7198. 'geopotential_height:m',
  7199. 't_min_2m_24h:C',
  7200. 't_max_2m_24h:C',
  7201. 'precip_24h:mm',
  7202. 'total_cloud_cover:octas'
  7203. ];
  7204. }
  7206. $timeResolutions = [
  7207. '_24h' => '+1 day',
  7208. '_12h' => '+12 hours',
  7209. '_6h' => '+6 hours',
  7210. '_3h' => '+3 hours',
  7211. '_1h' => '+1 hour'
  7212. ];
  7214. $adjustedParameters = [];
  7215. $nonAdjustedParameters = [];
  7217. foreach ($parameters as $parameter) {
  7218. $matched = false;
  7219. foreach ($timeResolutions as $key => $adjustment) {
  7220. if (strpos($parameter, $key) !== false) {
  7221. $matched = true;
  7222. $adjustedParameters[$adjustment][] = $parameter;
  7223. break;
  7224. }
  7225. }
  7226. if (!$matched) {
  7227. $nonAdjustedParameters[] = $parameter;
  7228. }
  7229. }
  7230. // Construct the URL
  7231. // $url = "{$this->apiBaseUrl}/{$startDate}--{$endDate}:{$duration}/t_2m:C,wind_speed_10m:kmh,wind_dir_10m:d,sfs_pressure:hPa,precip_10min:mm,relative_humidity_2m:p,visibility:km,dew_point_2m:c,wind_gusts_10m_1h:kmh,ceiling_height_agl:m,geopotential_height:m,t_min_2m_24h:C,t_max_2m_24h:C,precip_24h:mm,total_cloud_cover:octas/metar_{$metar}/json?source=mix-obs&on_invalid=fill_with_invalid";
  7232. $dataFinal = [
  7233. 'version' => null,
  7234. 'user' => null,
  7235. 'dateGenerated' => null,
  7236. 'status' => null,
  7237. 'data' => []
  7238. ];
  7240. foreach ($adjustedParameters as $adjustment => $params) {
  7241. $adjustedStartDate = (new \DateTime($startDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  7242. $adjustedEndDate = (new \DateTime($endDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  7243. $data = $this->fetchMetarData($adjustedStartDate, $adjustedEndDate, $metar, $duration, $params);
  7244. // Revert dates to original range
  7245. if (isset($data['data']) && is_array($data['data'])) {
  7247. foreach ($data['data'] as &$datum) {
  7249. if (isset($datum['coordinates'][0]['dates']) && is_array($datum['coordinates'][0]['dates'])) {
  7250. foreach ($datum['coordinates'][0]['dates'] as &$date) {
  7251. if (isset($date['date'])) {
  7252. $date['date'] = (new \DateTime($date['date']))
  7253. ->modify('-' . ltrim($adjustment, '+'))
  7254. ->format('Y-m-d\TH:i:s.v\Z');
  7255. }
  7256. }
  7257. }
  7258. }
  7259. } else {
  7260. $data['data'] = []; // Ensure 'data' exists
  7261. }
  7263. // Merge into $dataFinal
  7264. if (empty($dataFinal['version'])) {
  7265. $dataFinal['version'] = $data['version'] ?? null;
  7266. $dataFinal['user'] = $data['user'] ?? null;
  7267. $dataFinal['dateGenerated'] = $data['dateGenerated'] ?? null;
  7268. $dataFinal['status'] = $data['status'] ?? null;
  7269. }
  7271. if (isset($data['data']) && is_array($data['data'])) {
  7272. $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  7273. }
  7274. }
  7275. if (!empty($nonAdjustedParameters)) {
  7276. $data = $this->fetchMetarData($startDate, $endDate, $metar, $duration, $nonAdjustedParameters);
  7277. if (isset($data['data']) && is_array($data['data'])) {
  7278. $dataFinal['version'] = $data['version'] ?? null;
  7279. $dataFinal['user'] = $data['user'] ?? null;
  7280. $dataFinal['dateGenerated'] = $data['dateGenerated'] ?? null;
  7281. $dataFinal['status'] = $data['status'] ?? null;
  7282. $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  7283. }
  7284. }
  7286. // Reorder data based on parameters
  7287. $dataFinal['data'] = isset($dataFinal['data']) && is_array($dataFinal['data'])
  7288. ? $this->orderResults($dataFinal['data'], $parameters)
  7289. : [];
  7292. if (strpos($metar, ',') === false) {
  7294. //get station name and alternative id
  7295. if (count($dataFinal['data']) > 0) {
  7296. $metarData = $this->getWeatherStationDataByHashId($dataFinal['data']);
  7297. $dataFinal['data'] = $metarData;
  7298. }
  7299. }
  7300. if ($genExcel) {
  7301. $csvData[] = ['Station ID', 'Station Name', 'Parameter(c)', 'Last Update'];
  7302. if (count($dataFinal['data']) > 0) {
  7303. foreach ($dataFinal['data'] as $key => $value) {
  7304. foreach ($value as $key1 => $value1) {
  7305. if (!is_array($value1)) {
  7306. $parameter = $value1;
  7307. }
  7308. if (is_array($value1)) {
  7309. foreach ($value1 as $key2 => $value2) {
  7310. $station_hash = $value2['station_id'] ?? null;
  7311. $station_name = $value2['station_name'] ?? null;
  7312. $station_id = $value2['station_alternativeIds'] ?? null;
  7313. if (is_array($value2['dates'])) {
  7314. foreach ($value2['dates'] as $key3 => $value3) {
  7315. $date = $value3['date'];
  7316. $value = $value3['value'];
  7317. $csvData[] = [$station_id, $station_name, $value, $date];
  7318. }
  7319. }
  7320. }
  7321. }
  7322. }
  7323. }
  7324. }
  7325. $xlsxReport = \Pimcore\Model\Asset::getByPath("/report/StationCsv/metar_station_weather_data.xlsx");
  7326. if ($xlsxReport !== null) {
  7327. $xlsxReport->delete();
  7328. }
  7329. $excelData = ExcelGenerator::createAndSaveXlsx($csvData, "metar_station_weather_data", true, 'StationCsv');
  7330. return $excelData;
  7331. }
  7332. // Set the data to Redis cache
  7333. $this->redisCache->set($cacheKey, $dataFinal);
  7334. return $dataFinal;
  7335. } catch (RequestException $e) {
  7336. throw new \Exception($e->getMessage());
  7337. } catch (\Exception $e) {
  7338. throw new \Exception($e->getMessage());
  7339. }
  7340. }
  7341. private function fetchMetarData($startDate, $endDate, $metar, $duration, $parameters)
  7342. {
  7343. $dataFinal = [];
  7344. while (!empty($parameters)) {
  7345. $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  7346. $batchQueryString = implode(',', $batchParameters);
  7347. $url = sprintf(
  7348. '%s/%s--%s:%s/%s/%s/json?source=mix-obs&on_invalid=fill_with_invalid',
  7349. $this->apiBaseUrl,
  7350. $startDate,
  7351. $endDate,
  7352. $duration,
  7353. $batchQueryString,
  7354. $metar
  7356. );
  7357. $client = new Client(['verify' => false]);
  7358. $response = $client->request('GET', $url, [
  7359. 'auth' => [$this->username, $this->password],
  7360. ]);
  7361. $statusCode = $response->getStatusCode();
  7362. $data = json_decode($response->getBody(), true);
  7363. if ($statusCode != 200) {
  7364. return $this->createErrorResponse($statusCode);
  7365. }
  7366. // Merge data from the current API call into the final data
  7367. $dataFinal['version'] = $data['version'];
  7368. $dataFinal['user'] = $data['user'];
  7369. $dataFinal['dateGenerated'] = $data['dateGenerated'];
  7370. $dataFinal['status'] = $data['status'];
  7371. $dataFinal['data'] = array_merge($dataFinal['data'] ?? [], $data['data']);
  7372. }
  7374. // Check if there is no comma in $metar
  7376. return $dataFinal;
  7377. }
  7380. public function getWeatherStationDataByHashId($metarData)
  7381. {
  7382. $response = [];
  7384. foreach ($metarData as &$metarParam) {
  7385. if (count($metarParam['coordinates']) > 0) {
  7386. foreach ($metarParam['coordinates'] as &$coordinates) {
  7387. $stationData = \Pimcore\Model\DataObject\WeatherStations::getByHash($coordinates['station_id'], true);
  7389. if ($stationData) {
  7390. $newData = [
  7391. 'station_name' => $stationData->getName(),
  7392. 'station_name_ar' => $stationData->getName('ar'),
  7393. 'station_wmo_id' => $stationData->getWmoId(),
  7394. 'station_alternativeIds' => $stationData->getAlternativeIds(),
  7395. ];
  7397. // Append the new data to the existing coordinates without reindexing
  7398. $coordinates += $newData;
  7399. }
  7400. }
  7401. // Reset array keys to be sequential
  7402. $metarParam['coordinates'] = array_values($metarParam['coordinates']);
  7403. }
  7404. }
  7406. return $metarData;
  7407. }
  7408. // public function getWeatherStatioData($startDate, $endDate, $parameters, $hash, $genExcel, $translator, $interval = 'PT24H')
  7409. // {
  7410. // try {
  7411. // if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $startDate)) {
  7412. // throw new \InvalidArgumentException($translator->trans('invalid_start_date_format'));
  7413. // }
  7414. // if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $startDate)) {
  7415. // throw new \InvalidArgumentException($translator->trans('invalid_end_date_format'));
  7416. // }
  7417. // $cacheKey = \App\Lib\Utility::generateKey($startDate, $endDate, $parameters, $hash);
  7418. // $cachedData = $this->redisCache->get($cacheKey);
  7420. // if ($cachedData !== null && !$genExcel) {
  7421. // // Return the cached data if available
  7422. // return $cachedData;
  7423. // }
  7424. // $dataFinal = [];
  7425. // while (!empty($parameters)) {
  7426. // $batchParameters = array_splice($parameters, 0, 10); // Take up to 10 parameters
  7427. // $batchQueryString = implode(',', $batchParameters);
  7428. // $url = sprintf(
  7429. // "%s/%s--%s:%s/%s/%s/json?source=mix-obs&on_invalid=fill_with_invalid",
  7430. // $this->apiBaseUrl,
  7431. // $startDate,
  7432. // $endDate,
  7433. // $interval,
  7434. // $batchQueryString,
  7435. // $hash
  7436. // );
  7437. // $client = new Client(['verify' => false]);
  7438. // $response = $client->request('GET', $url, [
  7439. // 'auth' => [$this->username, $this->password],
  7440. // ]);
  7441. // $statusCode = $response->getStatusCode();
  7442. // $data = json_decode($response->getBody(), true);
  7443. // if ($statusCode != 200) {
  7444. // return $this->createErrorResponse($statusCode);
  7445. // }
  7446. // // Merge data from the current API call into the final data
  7447. // $dataFinal['version'] = $data['version'];
  7448. // $dataFinal['user'] = $data['user'];
  7449. // $dataFinal['dateGenerated'] = $data['dateGenerated'];
  7450. // $dataFinal['status'] = $data['status'];
  7451. // $dataFinal['data'] = array_merge($dataFinal['data'] ?? [], $data['data']);
  7452. // }
  7453. // if (count($dataFinal['data']) > 0) {
  7454. // $metarData = $this->getWeatherStationDataByHashId($dataFinal['data']);
  7455. // $dataFinal['data'] = $metarData;
  7456. // }
  7457. // if ($genExcel) {
  7458. // $csvData[] = ['parameter', 'station id', 'station name', 'date', 'value'];
  7459. // if (count($dataFinal['data']) > 0) {
  7460. // foreach ($dataFinal['data'] as $key => $value) {
  7461. // foreach ($value as $key1 => $value1) {
  7462. // if (!is_array($value1)) {
  7463. // $parameter = $value1;
  7464. // }
  7465. // if (is_array($value1)) {
  7466. // foreach ($value1 as $key2 => $value2) {
  7467. // $station_hash = $value2['station_id'];
  7468. // $station_name = $value2['station_name'];
  7469. // $station_id = $value2['station_alternativeIds'];
  7470. // if (is_array($value2['dates'])) {
  7471. // foreach ($value2['dates'] as $key3 => $value3) {
  7472. // $date = $value3['date'];
  7473. // $value = $value3['value'];
  7474. // $csvData[] = [$parameter, $station_id, $station_name, $date, $value];
  7475. // }
  7476. // }
  7477. // }
  7478. // }
  7479. // }
  7480. // }
  7481. // }
  7482. // $xlsxReport = \Pimcore\Model\Asset::getByPath("/report/StationCsv/historical_weather_data.xlsx");
  7483. // if ($xlsxReport !== null) {
  7484. // $xlsxReport->delete();
  7485. // }
  7486. // $excelData = ExcelGenerator::createAndSaveXlsx($csvData, "historical_weather_data", true, 'StationCsv');
  7487. // return $excelData;
  7488. // }
  7490. // // Set the data to Redis cache
  7491. // $this->redisCache->set($cacheKey, $dataFinal);
  7492. // return $dataFinal;
  7493. // } catch (RequestException $e) {
  7494. // throw new \Exception($e->getMessage());
  7495. // } catch (\Exception $e) {
  7496. // throw new \Exception($e->getMessage());
  7497. // }
  7498. // }
  7502. public function getWeatherStatioData($startDate, $endDate, $parameters, $hash, $genExcel, $translator, $interval = 'PT24H')
  7503. {
  7504. try {
  7505. if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $startDate)) {
  7506. throw new \InvalidArgumentException($translator->trans('invalid_start_date_format'));
  7507. }
  7508. if (!preg_match('/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/', $endDate)) {
  7509. throw new \InvalidArgumentException($translator->trans('invalid_end_date_format'));
  7510. }
  7512. $timeResolutions = [
  7513. '_24h' => '+1 day',
  7514. '_12h' => '+12 hours',
  7515. '_6h' => '+6 hours',
  7516. '_3h' => '+3 hours',
  7517. '_1h' => '+1 hour'
  7518. ];
  7520. $adjustedParameters = [];
  7521. $nonAdjustedParameters = [];
  7523. foreach ($parameters as $parameter) {
  7524. $matched = false;
  7525. foreach ($timeResolutions as $key => $adjustment) {
  7526. if (strpos($parameter, $key) !== false) {
  7527. $matched = true;
  7528. $adjustedParameters[$adjustment][] = $parameter;
  7529. break;
  7530. }
  7531. }
  7532. if (!$matched) {
  7533. $nonAdjustedParameters[] = $parameter;
  7534. }
  7535. }
  7537. // Initialize $dataFinal
  7538. $dataFinal = [
  7539. 'version' => null,
  7540. 'user' => null,
  7541. 'dateGenerated' => null,
  7542. 'status' => null,
  7543. 'data' => []
  7544. ];
  7546. // Process adjusted parameters
  7547. foreach ($adjustedParameters as $adjustment => $params) {
  7548. $adjustedStartDate = (new \DateTime($startDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  7549. $adjustedEndDate = (new \DateTime($endDate))->modify($adjustment)->format('Y-m-d\TH:i:s.v\Z');
  7550. $data = $this->fetchWeatherData($adjustedStartDate, $adjustedEndDate, $params, $hash, $interval);
  7552. // Revert dates to original range
  7553. if (isset($data['data']) && is_array($data['data'])) {
  7555. foreach ($data['data'] as &$datum) {
  7557. if (isset($datum['coordinates'][0]['dates']) && is_array($datum['coordinates'][0]['dates'])) {
  7558. foreach ($datum['coordinates'][0]['dates'] as &$date) {
  7559. if (isset($date['date'])) {
  7560. $date['date'] = (new \DateTime($date['date']))
  7561. ->modify('-' . ltrim($adjustment, '+'))
  7562. ->format('Y-m-d\TH:i:s.v\Z');
  7563. }
  7564. }
  7565. }
  7566. }
  7567. } else {
  7568. $data['data'] = []; // Ensure 'data' exists
  7569. }
  7571. // Merge into $dataFinal
  7572. if (empty($dataFinal['version'])) {
  7573. $dataFinal['version'] = $data['version'] ?? null;
  7574. $dataFinal['user'] = $data['user'] ?? null;
  7575. $dataFinal['dateGenerated'] = $data['dateGenerated'] ?? null;
  7576. $dataFinal['status'] = $data['status'] ?? null;
  7577. }
  7579. if (isset($data['data']) && is_array($data['data'])) {
  7580. $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  7581. }
  7582. }
  7584. // Process non-adjusted parameters
  7585. if (!empty($nonAdjustedParameters)) {
  7586. $data = $this->fetchWeatherData($startDate, $endDate, $nonAdjustedParameters, $hash, $interval);
  7588. if (isset($data['data']) && is_array($data['data'])) {
  7589. $dataFinal['data'] = array_merge($dataFinal['data'], $data['data']);
  7590. }
  7591. }
  7593. // Reorder data based on parameters
  7594. $dataFinal['data'] = isset($dataFinal['data']) && is_array($dataFinal['data'])
  7595. ? $this->orderResults($dataFinal['data'], $parameters)
  7596. : [];
  7599. if (count($dataFinal['data']) > 0) {
  7600. $metarData = $this->getWeatherStationDataByHashId($dataFinal['data']);
  7601. $dataFinal['data'] = $metarData;
  7602. }
  7604. if ($genExcel) {
  7605. return $this->generateExcel($dataFinal);
  7606. }
  7608. return $dataFinal;
  7609. } catch (RequestException $e) {
  7610. throw new \Exception($e->getMessage());
  7611. } catch (\Exception $e) {
  7612. throw new \Exception($e->getMessage());
  7613. }
  7614. }
  7616. private function fetchWeatherData($startDate, $endDate, $parameters, $hash, $interval)
  7617. {
  7618. $dataFinal = [];
  7619. while (!empty($parameters)) {
  7621. $batchParameters = array_splice($parameters, 0, 10);
  7622. $batchQueryString = implode(',', $batchParameters);
  7623. $url = sprintf(
  7624. "%s/%s--%s:%s/%s/%s/json?source=mix-obs&on_invalid=fill_with_invalid",
  7625. $this->apiBaseUrl,
  7626. $startDate,
  7627. $endDate,
  7628. $interval,
  7629. $batchQueryString,
  7630. $hash
  7631. );
  7633. $client = new Client(['verify' => false]);
  7634. $response = $client->request('GET', $url, [
  7635. 'auth' => [$this->username, $this->password],
  7636. ]);
  7637. if ($response->getStatusCode() != 200) {
  7638. throw new \Exception("Failed to fetch data from API");
  7639. }
  7640. $data = json_decode($response->getBody(), true);
  7641. $dataFinal = array_merge_recursive($dataFinal, $data);
  7642. }
  7643. return $dataFinal;
  7644. }
  7646. private function generateExcel($data)
  7647. {
  7648. $csvData[] = ['parameter', 'station id', 'station name', 'date', 'value'];
  7649. if (count($data['data']) > 0) {
  7650. foreach ($data['data'] as $key => $value) {
  7651. foreach ($value as $key1 => $value1) {
  7652. if (!is_array($value1)) {
  7653. $parameter = $value1;
  7654. }
  7655. if (is_array($value1)) {
  7656. foreach ($value1 as $key2 => $value2) {
  7657. $station_hash = $value2['station_id'];
  7658. $station_name = $value2['station_name'];
  7659. $station_id = $value2['station_alternativeIds'];
  7660. if (is_array($value2['dates'])) {
  7661. foreach ($value2['dates'] as $key3 => $value3) {
  7662. $date = $value3['date'];
  7663. $value = $value3['value'];
  7664. $csvData[] = [$parameter, $station_id, $station_name, $date, $value];
  7665. }
  7666. }
  7667. }
  7668. }
  7669. }
  7670. }
  7671. }
  7672. $xlsxReport = \Pimcore\Model\Asset::getByPath("/report/StationCsv/historical_weather_data.xlsx");
  7673. if ($xlsxReport !== null) {
  7674. $xlsxReport->delete();
  7675. }
  7676. $excelData = ExcelGenerator::createAndSaveXlsx($csvData, "historical_weather_data", true, 'StationCsv');
  7677. return $excelData;
  7678. }
  7680. private function orderResults($data, $parameters)
  7681. {
  7683. $orderedResults = [];
  7684. foreach ($parameters as $parameter) {
  7685. foreach ($data as $key => $item) {
  7686. if ($item['parameter'] === $parameter) {
  7687. $orderedResults[] = $item;
  7688. break;
  7689. }
  7690. }
  7691. }
  7692. return $orderedResults;
  7693. }
  7696. // Assuming $data1 and $data2 contain the response data from URL1 and URL2 respectively
  7697. // and that the relevant date fields in these responses are in a format that can be converted to a timestamp
  7699. function adjustResponseDates(&$data, $hours)
  7700. {
  7701. error_log(print_r($data, true)); // Log the initial data
  7703. if ($hours == 24) {
  7704. $timeAdjustment = '-1 day';
  7705. } elseif ($hours == 1) {
  7706. $timeAdjustment = '-1 hour';
  7707. } elseif ($hours == 12) {
  7708. $timeAdjustment = '-12 hour';
  7709. } else {
  7710. $timeAdjustment = '';
  7711. }
  7714. foreach ($data as &$parameter) { // Iterate through each parameter
  7716. if ($timeAdjustment && isset($parameter['coordinates'])) {
  7717. foreach ($parameter['coordinates'] as $coordKey => $coordinate) {
  7719. if (isset($coordinate['dates']) && is_array($coordinate['dates'])) {
  7720. foreach ($coordinate['dates'] as $dateKey => $dateInfo) {
  7722. if (isset($dateInfo['date'])) {
  7723. // p_r($dateInfo['date']);exit;
  7724. $adjustedDate = date('Y-m-d\TH:i:s.v\Z', strtotime($timeAdjustment, strtotime($dateInfo['date'])));
  7726. $parameter['coordinates'][$coordKey]['dates'][$dateKey]['date'] = $adjustedDate;
  7727. error_log("Adjusted Date: " . $adjustedDate); // Log each adjusted date
  7728. }
  7729. }
  7730. }
  7731. }
  7732. }
  7733. }
  7734. unset($parameter); // Break the reference with the last element
  7735. error_log("Final Data: " . print_r($data, true)); // Log the final modified data
  7736. }
  7737. }