src/Controller/PublicApiController.php line 50

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\C2IntegrationBundle\Service\C2Service;
  6. use Carbon\Carbon;
  7. use Knp\Snappy\Pdf;
  8. use Knp\Snappy\Image;
  9. use Pimcore\Model\Asset;
  10. use App\Service\RedisCache;
  11. use App\Model\ReportLogModel;
  12. use App\Service\EmailService;
  13. use App\Service\ReportService;
  14. use DateTime;
  15. use Pimcore\Log\ApplicationLogger;
  16. use App\Model\EwsNotificationModel;
  17. use App\Service\NotificationService;
  18. use Pimcore\Model\DataObject\Report;
  19. use App\Service\MeteomaticApiService;
  20. use App\Model\WeatherForecastCityModel;
  21. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  22. use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
  23. use App\Service\CustomNotificationService;
  24. use App\Service\MeteomaticsWeatherService;
  25. use Pimcore\Controller\FrontendController;
  26. use Knp\Component\Pager\PaginatorInterface;
  27. use App\Service\PublicUserPermissionService;
  28. use App\Service\NCMWeatherAPIService;
  29. use GuzzleHttp\Client;
  30. use App\Model\ReportingPortalModel;
  31. use Symfony\Component\HttpFoundation\Request;
  32. use Symfony\Component\HttpFoundation\Response;
  33. use Symfony\Component\Routing\Annotation\Route;
  34. use Pimcore\Model\DataObject\ReportWeatherSymbols;
  35. use Symfony\Component\HttpFoundation\JsonResponse;
  36. use Symfony\Contracts\Translation\TranslatorInterface;
  37. use Lexik\Bundle\JWTAuthenticationBundle\Services\JWTTokenManagerInterface;
  38. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  39. use Symfony\Component\Templating\EngineInterface;
  40. use App\Service\InsuranceIndustryService;
  41. use App\Model\WeatherStationModel;
  42. use App\Service\WeatherStationService;
  43. use Pimcore\Model\DataObject\HistoricalDataParameters;
  44. use App\Model\AgricultureModel;
  45. use App\Service\ChillUnitService;
  46. use Pimcore\Model\DataObject;
  47. use App\Model\LocationModel;
  48. use App\Model\WeatherParameterModel;
  49. use Pimcore\Model\DataObject\WeatherParameterLocationTags;
  50. class PublicApiController extends FrontendController
  51. {
  52.     private $ewsNotificationModel;
  53.     private $reportModel;
  54.     private $c2Service;
  55.     private $reportingPortalModel;
  56.     private $weatherStationModel;
  57.     private $agricultureModel;
  58.     private $chillUnitService;
  59.     private $locationModel;
  60.     private $weatherParameterModel;
  61.     public function __construct(
  62.         private TokenStorageInterface $tokenStorageInterface,
  63.         private JWTTokenManagerInterface $jwtManager,
  64.         private PublicUserPermissionService $publicUserPermissionService,
  65.         protected TranslatorInterface $translator,
  66.         private ApplicationLogger $logger,
  67.         private MeteomaticApiService $meteomaticApiService,
  68.         private \Doctrine\DBAL\Connection $connection,
  69.         private RedisCache $redisCache,
  70.         private MeteomaticsWeatherService $meteomaticsWeatherService,
  71.         private Pdf $snappy,
  72.         private CustomNotificationService $customNotificationService,
  73.         private ReportService $reportService,
  74.         private NotificationService $notificationService,
  75.         private Image $snappyImage,
  76.         private EmailService $emailService,
  77.         private EngineInterface $templating,
  78.         private NCMWeatherAPIService $ncmWeatherApiService,
  79.         private InsuranceIndustryService $insuranceIndustryService,
  80.         private WeatherStationService $weatherStationService,
  81.     ) {
  82.         header('Content-Type: application/json; charset=UTF-8');
  83.         header("Access-Control-Allow-Origin: *");
  84.         $this->meteomaticApiService = $meteomaticApiService;
  85.         $this->publicUserPermissionService = $publicUserPermissionService;
  86.         $this->ewsNotificationModel = new EwsNotificationModel();
  87.         $this->reportModel = new ReportLogModel();
  88.         $this->c2Service = new C2Service();
  89.         $this->templating =  $templating;
  90.         $this->reportingPortalModel = new ReportingPortalModel();
  91.         $this->weatherStationModel = new WeatherStationModel();
  92.         $this->agricultureModel = new AgricultureModel();
  93.         $this->chillUnitService = new ChillUnitService();
  94.         $this->locationModel = new LocationModel();
  95.         $this->weatherParameterModel = new WeatherParameterModel();
  96.     }
  98.     /**
  99.      * @Route("/api/public/{startdate}/{enddate}/{resolution}/{parameter}/{coordinate}/{format}", name="api_public_route_query", methods={"GET"})
  100.      */
  101.     public function publicRouteQueryData(Request $request): JsonResponse
  102.     {
  103.         try {
  104.             // check user credentials and expiry
  105.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  106.             if ($response['success'] !== true) {
  107.                 return $this->json($response);
  108.             }
  110.             $startDate = $request->get('startdate');
  111.             $endDate = $request->get('enddate');
  112.             $resolution = $request->get('resolution');
  113.             $parameter = $request->get('parameter');
  114.             $coordinate = $request->get('coordinate');
  115.             $format = $request->get('format');
  117.             // Optional Parameter
  118.             $source = $request->get('source');
  119.             $onInvalid = $request->get('on_invalid');
  120.             $model = $request->get('model');
  122.             if (!$startDate) {
  123.                 throw new \InvalidArgumentException("Missing mandatory parameter: start date");
  124.             }
  125.             if (!$endDate) {
  126.                 throw new \InvalidArgumentException("Missing mandatory parameter: end date");
  127.             }
  128.             if (!$resolution) {
  129.                 throw new \InvalidArgumentException("Missing mandatory parameter: resolution");
  130.             }
  131.             if (!$parameter) {
  132.                 throw new \InvalidArgumentException("Missing mandatory parameter: parameters");
  133.             }
  134.             if (!$coordinate) {
  135.                 throw new \InvalidArgumentException("Missing mandatory parameter: coordinate");
  136.             }
  137.             if (!$format) {
  138.                 throw new \InvalidArgumentException("Missing mandatory parameter: format");
  139.             }
  140.             $startDate = new DateTime($startDate);
  141.             $endDate = new DateTime($endDate);
  142.             $user = $response['user'];
  143.             $parametersArray = explode(',', $parameter);
  144.             // Varify user allowed permissions
  145.             // $reslult = $this->publicUserPermissionService->publicUserPermissionCheck($user, $parametersArray, $this->translator);
  146.             // if ($reslult['success'] !== true) {
  147.             //     return $this->json($reslult);
  148.             // }
  149.             $response = $this->meteomaticApiService->publicRouteQuery(
  150.                 $startDate,
  151.                 $endDate,
  152.                 $resolution,
  153.                 $parametersArray,
  154.                 $coordinate,
  155.                 $format,
  156.                 $model,
  157.                 $source,
  158.                 $onInvalid
  159.             );
  160.             // For demonstration purposes, we will just return a JSON response
  161.             return $this->json($response);
  162.         } catch (\Exception $ex) {
  163.             $this->logger->error($ex->getMessage());
  164.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  165.         }
  166.     }
  168.     /**
  169.      * @Route("/api/public/cfo-report", name="public_cfo_report", methods={"POST"})
  170.      */
  171.     public function getCfoReport(Request $request): JsonResponse
  172.     {
  173.         try {
  174.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  175.             if ($permissions['success'] !== true) {
  176.                 return $this->json($permissions);
  177.             }
  179.             $params = json_decode($request->getContent(), true) ?: [];
  180.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  181.             $reportType = '10-day-forecast-report';
  183.             // Pull raw airport/station forecast (weatherinfo) for first 6 days
  184.             $ccode = $params['ccode'] ?? null;
  185.             $baseUrl = rtrim(NCM_WEATHER_API_URL, '/');
  186.             $url = $baseUrl . '/api/weather/getweatherinfo';
  187.             $client = new Client(['verify' => false]);
  188.             $options = [];
  189.             if ($ccode !== null && $ccode !== '') {
  190.                 $options['query'] = ['ccode' => $ccode];
  191.             }
  192.             $wxRes = $client->request('GET', $url, $options);
  193.             $wxBody = $wxRes->getBody()->getContents();
  194.             $wxData = json_decode($wxBody, true);
  196.             // Normalize weatherinfo items array
  197.             $wxItems = [];
  198.             if (is_array($wxData)) {
  199.                 $wxItems = isset($wxData[0]) ? $wxData : [$wxData];
  200.             }
  202.             // Index weatherinfo by Arabic and English city names (normalized with synonyms)
  203.             $wxByCityAr = [];
  204.             $wxByCityEn = [];
  205.             $norm = function ($v) {
  206.                 return $v !== null ? trim(mb_strtolower((string)$v)) : null;
  207.             };
  208.             $normAr = function ($v) use ($norm) {
  209.                 $s = $norm($v);
  210.                 if ($s === null) { return null; }
  211.                 // strip common prefixes
  212.                 $s = preg_replace('/^(مدينة|محافظة)\s+/u', '', $s);
  213.                 // normalize spaces
  214.                 $s = preg_replace('/\s+/u', ' ', $s);
  215.                 return trim($s);
  216.             };
  217.             $normEn = function ($v) use ($norm) {
  218.                 $s = $norm($v);
  219.                 if ($s === null) { return null; }
  220.                 // remove Arabic article transliterations anywhere: al, ar, ad, as, at
  221.                 $s = preg_replace('/\b(al|ar|ad|as|at)\s+/u', '', $s);
  222.                 $s = str_replace(['-', '_'], ' ', $s);
  223.                 $s = preg_replace('/\s+/u', ' ', $s);
  224.                 return trim($s);
  225.             };
  226.             foreach ($wxItems as $it) {
  227.                 if (!is_array($it)) { continue; }
  228.                 $ar = $normAr($it['city_Ar'] ?? null);
  229.                 $en = $normEn($it['city_En'] ?? null);
  230.                 if ($ar) { $wxByCityAr[$ar] = $it; }
  231.                 if ($en) { $wxByCityEn[$en] = $it; }
  232.             }
  234.             // Latest 10-day report (full jsonData kept for fallback and for last 4 days)
  235.             $latest = $this->reportingPortalModel->getLatestReport([
  236.                 'reportType' => $reportType
  237.             ]);
  239.             if (!is_array($latest) || !isset($latest['success']) || $latest['success'] !== true || !isset($latest['data'])) {
  240.                 return $this->json(['success' => false, 'message' => 'Failed to fetch latest report']);
  241.             }
  243.             $latestData = $latest['data'];
  244.             $jsonDataFull = isset($latestData['jsonData']) && is_array($latestData['jsonData']) ? $latestData['jsonData'] : [];
  245.             if (empty($jsonDataFull)) {
  246.                 return $this->json(['success' => false, 'message' => 'Empty jsonData in latest report']);
  247.             }
  249.             // Helpers to extract first 6 days from weatherinfo
  250.             $dayKeys = [
  251.                 ['date' => 'todayDate',   'max' => 'todayMaxTemperature',   'min' => 'todayMinTemperature',   'hum' => 'humidity',            'icon' => 'todayIcon'],
  252.                 ['date' => 'firstDate',   'max' => 'firstdayMaxTemperature','min' => 'firstdayMinTemperature','hum' => 'firstdayHumidity',    'icon' => 'firstdayIcon'],
  253.                 ['date' => 'secondDate',  'max' => 'seconddayMaxTemperature','min' => 'seconddayMinTemperature','hum' => 'seconddayHumidity', 'icon' => 'seconddayIcon'],
  254.                 ['date' => 'thirdDate',   'max' => 'thirddayMaxTemperature','min' => 'thirddayMinTemperature','hum' => 'thirddayHumidity',    'icon' => 'thirddayIcon'],
  255.                 ['date' => 'fourthDate',  'max' => 'fourthdayMaxTemperature','min' => 'fourthdayMinTemperature','hum' => 'fourthdayHumidity', 'icon' => 'fourthdayIcon'],
  256.                 ['date' => 'fifthDate',   'max' => 'fifthdayMaxTemperature','min' => 'fifthdayMinTemperature','hum' => 'fifthdayHumidity',    'icon' => 'fifthdayIcon'],
  257.             ];
  258.             $toIso = function ($s) {
  259.                 if (!$s) { return null; }
  260.                 try {
  261.                     $dt = new \DateTime($s);
  262.                     return $dt->format('Y-m-d\TH:i:s\Z');
  263.                 } catch (\Throwable $e) {
  264.                     return null;
  265.                 }
  266.             };
  267.             $extractIconIdx = function ($iconStr) {
  268.                 if (!is_string($iconStr) || $iconStr === '') { return null; }
  269.                 if (preg_match('/wt_([0-9]+)/', $iconStr, $m)) {
  270.                     return (int)$m[1];
  271.                 }
  272.                 return null;
  273.             };
  274.             $first6FromWx = function (array $wxItem, string $param) use ($toIso, $extractIconIdx) {
  275.                 $getNum = function ($v) {
  276.                     if ($v === null) { return null; }
  277.                     if (is_string($v)) { $v = trim($v); }
  278.                     return is_numeric($v) ? (float)$v : null;
  279.                 };
  281.                 $rows = [];
  283.                 // Today (always use today* keys)
  284.                 $date = $toIso($wxItem['todayDate'] ?? null);
  285.                 if ($date) {
  286.                     $value = null;
  287.                     if ($param === 't_max_2m_24h:C') {
  288.                         $value = $getNum($wxItem['todayMaxTemperature'] ?? null);
  289.                     } elseif ($param === 't_min_2m_24h:C') {
  290.                         $value = $getNum($wxItem['todayMinTemperature'] ?? null);
  291.                     } elseif ($param === 'relative_humidity_2m:p') {
  292.                         $value = $getNum($wxItem['humidity'] ?? null);
  293.                     } elseif ($param === 'weather_symbol_24h:idx') {
  294.                         $value = $extractIconIdx($wxItem['todayIcon'] ?? null);
  295.                     }
  296.                     $rows[] = ['date' => $date, 'value' => $value, 'weatherinfo' => true];
  297.                 }
  299.                 // Next 5 days (first..fifth)
  300.                 $map = [
  301.                     ['date' => 'firstDate',  'max' => 'firstdayMaxTemperature',  'min' => 'firstdayMinTemperature',  'hum' => 'firstdayHumidity',  'icon' => 'firstdayIcon'],
  302.                     ['date' => 'secondDate', 'max' => 'seconddayMaxTemperature', 'min' => 'seconddayMinTemperature', 'hum' => 'seconddayHumidity', 'icon' => 'seconddayIcon'],
  303.                     ['date' => 'thirdDate',  'max' => 'thirddayMaxTemperature',  'min' => 'thirddayMinTemperature',  'hum' => 'thirddayHumidity',  'icon' => 'thirddayIcon'],
  304.                     ['date' => 'fourthDate', 'max' => 'fourthdayMaxTemperature', 'min' => 'fourthdayMinTemperature', 'hum' => 'fourthdayHumidity', 'icon' => 'fourthdayIcon'],
  305.                     ['date' => 'fifthDate',  'max' => 'fifthdayMaxTemperature',  'min' => 'fifthdayMinTemperature',  'hum' => 'fifthdayHumidity',  'icon' => 'fifthdayIcon'],
  306.                 ];
  307.                 foreach ($map as $dk) {
  308.                     $d = $toIso($wxItem[$dk['date']] ?? null);
  309.                     if (!$d) { continue; }
  310.                     $value = null;
  311.                     if ($param === 't_max_2m_24h:C') {
  312.                         $value = $getNum($wxItem[$dk['max']] ?? null);
  313.                     } elseif ($param === 't_min_2m_24h:C') {
  314.                         $value = $getNum($wxItem[$dk['min']] ?? null);
  315.                     } elseif ($param === 'relative_humidity_2m:p') {
  316.                         $value = $getNum($wxItem[$dk['hum']] ?? null);
  317.                     } elseif ($param === 'weather_symbol_24h:idx') {
  318.                         $value = $extractIconIdx($wxItem[$dk['icon']] ?? null);
  319.                     }
  320.                     $rows[] = ['date' => $d, 'value' => $value, 'weatherinfo' => true];
  321.                 }
  323.                 return $rows;
  324.             };
  326.             // Build merged jsonData
  327.             $mergedJsonData = [];
  328.             foreach ($jsonDataFull as $cityRowFull) {
  329.                 $cityEn = $cityRowFull['cityEn'] ?? null;
  330.                 $cityAr = $cityRowFull['cityAr'] ?? null;
  331.                 $keyAr = $normAr($cityAr);
  332.                 $keyEn = $normEn($cityEn);
  333.                 $wxItem = null;
  334.                 if ($keyAr && isset($wxByCityAr[$keyAr])) {
  335.                     $wxItem = $wxByCityAr[$keyAr];
  336.                 } elseif ($keyEn && isset($wxByCityEn[$keyEn])) {
  337.                     $wxItem = $wxByCityEn[$keyEn];
  338.                 } else {
  339.                     // Fallback: substring/containment match (English first, then Arabic)
  340.                     if (!$wxItem && $keyEn) {
  341.                         foreach ($wxByCityEn as $wxKey => $candidate) {
  342.                             if ($wxKey !== '' && (str_contains($keyEn, $wxKey) || str_contains($wxKey, $keyEn))) {
  343.                                 $wxItem = $candidate;
  344.                                 break;
  345.                             }
  346.                         }
  347.                     }
  348.                     if (!$wxItem && $keyAr) {
  349.                         foreach ($wxByCityAr as $wxKey => $candidate) {
  350.                             if ($wxKey !== '' && (str_contains($keyAr, $wxKey) || str_contains($wxKey, $keyAr))) {
  351.                                 $wxItem = $candidate;
  352.                                 break;
  353.                             }
  354.                         }
  355.                     }
  356.                 }
  358.                 // Build a map of param -> dates from full report for fallback and for last 4 days
  359.                 $paramToDates = [];
  360.                 foreach (($cityRowFull['parameters'] ?? []) as $p) {
  361.                     $pName = $p['parameter'] ?? null;
  362.                     if (!$pName || !isset($p['dates']) || !is_array($p['dates'])) { continue; }
  363.                     $paramToDates[$pName] = $p['dates'];
  364.                 }
  366.                 $newParams = [];
  367.                 foreach (($cityRowFull['parameters'] ?? []) as $p) {
  368.                     $pName = $p['parameter'] ?? null;
  369.                     if (!$pName) { continue; }
  371.                     // First 6 from weatherinfo (if available), else fallback to first 6 from original
  372.                     $first6 = [];
  373.                     if ($wxItem) {
  374.                         $first6 = $first6FromWx($wxItem, $pName);
  375.                     }
  376.                     if (empty($first6)) {
  377.                         $orig = $paramToDates[$pName] ?? [];
  378.                         $slice = array_slice($orig, 0, 6);
  379.                         $first6 = array_map(function ($d) {
  380.                             return [
  381.                                 'date' => $d['date'] ?? null,
  382.                                 'value' => $d['value'] ?? null,
  383.                                 'weatherinfo' => false
  384.                             ];
  385.                         }, $slice);
  386.                     }
  388.                     // Last 4 from original report
  389.                     $origDates = $paramToDates[$pName] ?? [];
  390.                     $last4 = array_slice($origDates, -4);
  391.                     $last4 = array_map(function ($d) {
  392.                         return [
  393.                             'date' => $d['date'] ?? null,
  394.                             'value' => $d['value'] ?? null,
  395.                             'weatherinfo' => false
  396.                         ];
  397.                     }, $last4);
  399.                     $newParams[] = [
  400.                         'parameter' => $pName,
  401.                         'dates' => array_values(array_merge($first6, $last4)),
  402.                     ];
  403.                 }
  405.                 // Build currentParameters from weatherinfo (flat object), or null if not matched
  406.                 $currentParams = null;
  407.                 if ($wxItem) {
  408.                     $trimScalar = function ($v) {
  409.                         return is_string($v) ? trim($v) : $v;
  410.                     };
  411.                     $abbrWindEn = function ($v) {
  412.                         if (!is_string($v) || $v === '') { return $v; }
  413.                         $s = trim($v);
  414.                         $s = str_replace(['-', '_'], ' ', $s);
  415.                         $s = preg_replace('/\s+/u', ' ', $s);
  416.                         $lower = mb_strtolower($s);
  417.                         $map = [
  418.                             'north' => 'N',
  419.                             'south' => 'S',
  420.                             'east' => 'E',
  421.                             'west' => 'W',
  422.                             'northeast' => 'NE',
  423.                             'north east' => 'NE',
  424.                             'northwest' => 'NW',
  425.                             'north west' => 'NW',
  426.                             'southeast' => 'SE',
  427.                             'south east' => 'SE',
  428.                             'southwest' => 'SW',
  429.                             'south west' => 'SW',
  430.                         ];
  431.                         if (isset($map[$lower])) {
  432.                             return $map[$lower];
  433.                         }
  434.                         $words = explode(' ', $lower);
  435.                         $abbr = '';
  436.                         foreach ($words as $w) {
  437.                             if ($w === 'north') { $abbr .= 'N'; }
  438.                             elseif ($w === 'south') { $abbr .= 'S'; }
  439.                             elseif ($w === 'east') { $abbr .= 'E'; }
  440.                             elseif ($w === 'west') { $abbr .= 'W'; }
  441.                         }
  442.                         return $abbr !== '' ? $abbr : $s;
  443.                     };
  444.                     $currentParams = [
  445.                         'currentDate' => $trimScalar($wxItem['currentDate'] ?? null),
  446.                         'currentIcon' => $extractIconIdx($wxItem['currentIcon'] ?? null),
  447.                         'currentWeather_PhenomenonAr' => $trimScalar($wxItem['currentWeather_PhenomenonAr'] ?? ($wxItem['weather_PhenomenonAr'] ?? null)),
  448.                         'currentWeather_PhenomenonEn' => $trimScalar($wxItem['currentWeather_PhenomenonEn'] ?? ($wxItem['weather_PhenomenonEn'] ?? null)),
  449.                         'currentHumidity' => $trimScalar($wxItem['currentHumidity'] ?? ($wxItem['humidity'] ?? null)),
  450.                         'pressure' => $trimScalar($wxItem['pressure'] ?? null),
  451.                         'currentTemperature' => $trimScalar($wxItem['currentTemperature'] ?? null),
  452.                         'windspeed' => $trimScalar($wxItem['windspeed'] ?? null),
  453.                         'winddirection_Ar' => $trimScalar($wxItem['winddirection_Ar'] ?? ($wxItem['winddirection_AR'] ?? null)),
  454.                         'winddirection_EN' => $abbrWindEn($wxItem['winddirection_EN'] ?? null),
  455.                         'visibility' => $trimScalar($wxItem['visibility'] ?? null),
  456.                         'dewpoint' => $trimScalar($wxItem['dewpoint'] ?? null),
  457.                     ];
  458.                 }
  460.                 $mergedJsonData[] = [
  461.                     'cityEn' => $cityEn,
  462.                     'cityAr' => $cityAr,
  463.                     'lat' => $cityRowFull['lat'] ?? null,
  464.                     'lon' => $cityRowFull['lon'] ?? null,
  465.                     'parameters' => $newParams,
  466.                     'currentParameters' => $currentParams,
  467.                 ];
  468.             }
  470.             // Build final payload matching 10-day report schema
  471.             $finalData = $latestData;
  472.             $finalData['jsonData'] = $mergedJsonData;
  474.             return $this->json([
  475.                 'success' => true,
  476.                 'data' => $finalData
  477.             ]);
  478.         } catch (\Exception $ex) {
  479.             $this->logger->error($ex->getMessage());
  480.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  481.         }
  482.     }
  484.     /**
  485.      * @Route("/api/public/wms/tile", name="api_public_wms_tile", methods={"GET"})
  486.      */
  487.     public function getPublicWmsTile(Request $request): Response
  488.     {
  489.         try {
  490.             $layers = $request->query->get('layers');
  491.             $time = $request->query->get('time');
  492.             $bbox = $request->query->get('bbox');
  494.             if (empty($layers) || empty($time) || empty($bbox)) {
  495.                 return $this->json([
  496.                     'success' => false,
  497.                     'message' => 'Missing required parameters: layers, time, bbox'
  498.                 ], 400);
  499.             }
  501.             $format = $request->query->get('format', 'image/webp');
  502.             $width = (int) $request->query->get('width', 256);
  503.             $height = (int) $request->query->get('height', 256);
  504.             $crs = $request->query->get('crs', 'EPSG:3857');
  505.             $version = $request->query->get('version', '1.3.0');
  506.             $service = $request->query->get('service', 'WMS');
  507.             $wmsRequest = $request->query->get('request', 'GetMap');
  508.             $styles = $request->query->get('styles', '');
  509.             $transparent = $request->query->get('transparent', 'true');
  510.             $model = $request->query->get('model');
  511.             $webpQuality = $request->query->get('webp_quality_factor');
  513.             // Build query string for upstream WMS
  514.             $queryParams = [
  515.                 'service' => $service,
  516.                 'request' => $wmsRequest,
  517.                 'layers' => $layers,
  518.                 'styles' => $styles,
  519.                 'format' => $format,
  520.                 'transparent' => $transparent,
  521.                 'version' => $version,
  522.                 'time' => $time,
  523.                 'width' => $width,
  524.                 'height' => $height,
  525.                 'crs' => $crs,
  526.                 'bbox' => $bbox,
  527.             ];
  529.             if (!empty($model)) {
  530.                 $queryParams['model'] = $model;
  531.             }
  532.             if (!empty($webpQuality)) {
  533.                 $queryParams['webp_quality_factor'] = $webpQuality;
  534.             }
  536.             // Ensure RFC3986 encoding for characters like "/" and ":"
  537.             $paramString = http_build_query($queryParams, '', '&', PHP_QUERY_RFC3986);
  539.             // Fetch from Meteomatics service (auth handled by service)
  540.             $binary = $this->meteomaticsWeatherService->getWms(['param' => $paramString]);
  542.             // Determine content type
  543.             $contentType = strtolower($format);
  544.             if (strpos($contentType, 'image/') !== 0) {
  545.                 $contentType = 'image/' . ltrim($contentType, '/');
  546.             }
  548.             $response = new Response($binary);
  549.             $response->headers->set('Content-Type', $contentType);
  550.             $response->headers->set('Cache-Control', 'public, max-age=300');
  551.             return $response;
  552.         } catch (\Throwable $ex) {
  553.             return $this->json(['success' => false, 'message' => $ex->getMessage()], 500);
  554.         }
  555.     }
  557.     /**
  558.      * @Route("/api/public/get-report-detail", name="public_get_report_detail")
  559.      */
  560.     public function getReportDetails(Request $request)
  561.     {
  562.         try {
  563.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  564.             if ($response['success'] !== true) {
  565.                 return $this->json($response);
  566.             }
  567.             $user = $response['user'];
  568.             // $params = json_decode($request->getContent(), true);
  569.             $requestUri = $request->getRequestUri();
  571.             // Extract the last segment from the URL
  572.             $segments = explode('/', trim($requestUri, '/'));
  573.             $action = end($segments);
  574.             $action = str_replace("-", "_", $action);
  575.             $params[] = $action;
  576.             // $reslult = $this->publicUserPermissionService->publicUserPermissionCheck($user, $params, $this->translator);
  577.             // if ($reslult['success'] !== true) {
  578.             //     return $this->json($reslult);
  579.             // }
  580.             $latestReport = Report::getList([
  581.                 "limit" => 1,
  582.                 "orderKey" => "createdOn",
  583.                 "order" => "desc"
  584.             ]);
  585.             if ($latestReport->getCount() <= 0) {
  586.                 throw new \Exception('no_latest_report_found');
  587.             } else {
  588.                 $data = [];
  589.                 foreach ($latestReport as $report) {
  590.                     $data = [
  591.                         'name' => $report->getCreatedBy()?->getName(),
  592.                         'email' => $report->getCreatedBy()?->getEmail(),
  593.                         'jsonData' => json_decode($report->getJsonData(), true),
  594.                         'createdOn' => $report->getCreatedOn()
  595.                     ];
  596.                 }
  598.                 return $this->json(['success' => true, 'data' => $data]);
  599.             }
  600.         } catch (\Exception $ex) {
  601.             $this->logger->error($ex->getMessage());
  602.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  603.         }
  604.     }
  606.     /**
  607.      * @Route("/api/public/ews-analytics", methods={"POST"})
  608.      */
  609.     public function ewsAnalyticsAction(Request $request): JsonResponse
  610.     {
  611.         try {
  612.             $params = json_decode($request->getContent(), true);
  613.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  615.             $lang = ($request->headers->has('lang')) ? $request->headers->get('lang') : "en";
  616.             $result = $this->ewsNotificationModel->ewsAnalytics($params, $this->connection, $lang);
  617.             return $this->json($result);
  618.         } catch (\Exception $ex) {
  619.             $this->logger->error($ex->getMessage());
  620.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  621.         }
  622.     }
  624.     /**
  625.      * @Route("/api/public/generate-report", methods={"POST"})
  626.      */
  627.     public function generateReport(Request $request): JsonResponse
  628.     {
  629.         try {
  630.             $response = [];
  631.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  632.             if ($permissions['success'] !== true) {
  633.                 return $this->json($permissions);
  634.             }
  636.             $params = json_decode($request->getContent(), true);
  637.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  640.             if (
  641.                 !isset($params['from_date']) ||
  642.                 !isset($params['to_date']) ||
  643.                 !isset($params['hours']) ||
  644.                 !isset($params['parameters'])  ||
  645.                 !isset($params['locations'])
  646.             ) {
  647.                 throw new \Exception('Missing required parameters');
  648.             }
  649.             if (empty($params['parameters'] || !is_array($params['parameters']))) {
  650.                 throw new \Exception('Parameters should be non empty array');
  651.             }
  653.             if (empty($params['locations'] || !is_array($params['locations']))) {
  654.                 throw new \Exception('Locations should be non empty array');
  655.             }
  656.             $model = isset($params['model']) ? $params['model'] : 'mix';
  657.             $redisKey = md5('generate_city_report-' . $params['from_date'] . '-' . $params['to_date'] . '-' . $params['hours'] . '-' . implode('_', $params['locations'])) . '-' . implode('_', $params['parameters']) . '-' . $model;
  658.             $data = $this->redisCache->get($redisKey);
  659.             if (!$data) {
  660.                 $cities = new \Pimcore\Model\DataObject\City\Listing();
  661.                 if (!empty($params['locations'])) {
  662.                     $cities->setCondition('o_id IN (?)', [$params['locations']]);
  663.                 }
  664.                 $cities->load();
  665.                 if ($cities->getCount() > 0) {
  666.                     $params['coordinates'] = []; // Initialize an empty array for coordinates
  667.                     $result = [];
  668.                     $citiesArr = [];
  669.                     foreach ($cities as $city) {
  671.                         $params['coordinates'][] = [$city->getLatitude(), $city->getLongitude()];
  672.                         // Append the coordinates for each city
  673.                         $long = number_format($city->getLongitude(), 6, '.', '');
  674.                         $lat = number_format($city->getLatitude(), 6, '.', '');
  675.                         $citiesArr[$lat . '|' . $long]["en"] =  $city->getCityName("en");
  676.                         $citiesArr[$lat . '|' . $long]["ar"] =  $city->getCityName("ar");
  677.                     }
  679.                     $result = $this->meteomaticsWeatherService->getReportForecastData($params['coordinates'], $params['from_date'], $params['to_date'], $params['hours'], $model, $params['parameters'], $this->translator, $citiesArr, $params);
  681.                     $response[] = $result;
  682.                     $jsonResponse = ['success' => true, 'data' => $response];
  683.                     $this->redisCache->set($redisKey, $jsonResponse, REDIS_CACHE_TIME);
  684.                     return $this->json($jsonResponse);
  685.                 } else {
  686.                     return $this->json(['success' => true, 'message' => $this->translator->trans('no_city_found')]);
  687.                 }
  688.             } else {
  689.                 return $this->json($data);
  690.             }
  691.         } catch (\Exception $ex) {
  692.             $this->logger->error($ex->getMessage());
  693.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  694.         }
  695.     }
  697.     /**
  698.      * @Route("/api/public/update-report", methods={"POST"})
  699.      */
  700.     public function updateReport(Request $request)
  701.     {
  702.         try {
  703.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  704.             if ($permissions['success'] !== true) {
  705.                 return $this->json($permissions);
  706.             }
  707.             $user = $permissions['user'];
  708.             $params  = json_decode($request->getContent(), true);
  709.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  711.             // Perform parameter validation here
  712.             // || !isset($params['locations'])
  713.             if (!isset($params['data'])  || !isset($params['start_date']) || !isset($params['end_date']) || !isset($params['lang'])) {
  714.                 return $this->json(['success' => false, 'message' =>  $this->translator->trans('missing_required_parameters')]);
  715.             }
  716.             if (isset($params['organizations'])) {
  717.                 if (!is_array($params['organizations'])) {
  718.                     throw new \Exception($this->translator->trans('Organizations should be non empty array'), 400);
  719.                 }
  720.             }
  721.             if (isset($params['channels'])) {
  722.                 if (!is_array($params['channels']) || empty($params['channels'])) {
  723.                     throw new \Exception($this->translator->trans('Channels should be non empty array'), 400);
  724.                 }
  725.                 if (in_array('email', $params['channels'])) {
  726.                     if (!isset($params['emails']) || !is_array($params['emails']) || empty($params['emails'])) {
  727.                         throw new \Exception($this->translator->trans('Emails should be non empty array'), 400);
  728.                     }
  729.                 }
  730.             }
  731.             $result = $this->reportModel->editReport($user, $params, $this->translator, $this->logger);
  732.             return $this->json($result);
  733.         } catch (\Exception $ex) {
  734.             $this->logger->error($ex->getMessage());
  735.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  736.         }
  737.     }
  739.     /**
  740.      * @Route("/api/public/get-city-list", name="public-city-listing")
  741.      */
  742.     public function getCityListAction(Request $request)
  743.     {
  744.        
  745.         try {
  746.             $result = [];
  747.             $lang = ($request->headers->has('lang')) ? $request->headers->get('lang') : "en";
  749.             $params  = json_decode($request->getContent(), true);
  750.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  752.             $reportTypeId = $params['report_type_id'] ?? null;
  753.             $cities = new \Pimcore\Model\DataObject\City\Listing();
  754.             $cities->setOrderKey('cityName');
  755.             $cities->setOrder("ASC");
  756.             if ($reportTypeId) {
  757.                 $cities->setCondition("reportType REGEXP CONCAT('(^|,)', REPLACE('" . $reportTypeId . "', ',', '|'), '(,|$)')");
  758.             } else {
  759.                 $db = \Pimcore\Db::get();
  760.                 $selectedLocalities = $db->fetchAllAssociative("SELECT oo_id  FROM `object_query_ReportType` WHERE (`isAutomaticReport` = 0)");
  761.                 $ooIds = array_column($selectedLocalities, 'oo_id');
  762.                 $cities->setCondition("reportType REGEXP CONCAT('(^|,)', REPLACE('" . implode(',', $ooIds) . "', ',', '|'), '(,|$)')");
  763.             }
  764.             $cities->load();
  765.             if ($cities->getCount() > 0) {
  766.                 foreach ($cities as $city) {
  767.                     $result[] = [
  768.                         "id" => $city->getId(),
  769.                         "name" => $city->getCityName($lang),
  770.                         "nameEn" => $city->getCityName('en'),
  771.                         "nameAr" => $city->getCityName('ar'),
  772.                         "lat" => $city->getLatitude(),
  773.                         "long" => $city->getLongitude(),
  774.                         "googlePlaceName" => $city->getGooglePlaceName(),
  775.                     ];
  776.                 }
  777.                 return $this->json(["success" => true, "data" => $result]);
  778.             }
  779.             return $this->json(["success" => false, "message" => $this->translator->trans("no_city_is_available")]);
  780.         } catch (\Exception $ex) {
  781.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  782.         }
  783.     }
  785.     /**
  786.      * @Route("/api/public/list-report", name="public-report-listing")
  787.      */
  788.     public function getReportListAction(Request $request, PaginatorInterface $paginator)
  789.     {
  790.         try {
  791.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  792.             if ($permissions['success'] !== true) {
  793.                 return $this->json($permissions);
  794.             }
  795.             $user = $permissions['user'];
  796.             $params  = json_decode($request->getContent(), true);
  797.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  799.             if (!isset($params['page']) || !isset($params['limit'])) {
  800.                 throw new \Exception('Missing required params: page or limit');
  801.             }
  802.             $report_type = isset($params['report_type']) ? $params['report_type'] : null;
  803.             $lang = isset($params['lang']) ? $params['lang'] : DEFAULT_LOCALE;
  804.             $isPublicReports = isset($params['publicReports']) ? $params['publicReports'] : false; // sending this flag from public portal to get all reports accordong to our needs
  805.             $page = $params['page'];
  806.             $limit = $params['limit'];
  807.             $result = $this->reportModel->reportList($params, $page, $limit, $this->translator, $paginator, $report_type, $user, $lang, $isPublicReports);
  809.             return $this->json($result);
  810.         } catch (\Exception $ex) {
  811.             $this->logger->error($ex->getMessage());
  812.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  813.         }
  814.     }
  816.     /**
  817.      * @Route("/api/public/generate-report-pdf", name="public-report-pdf")
  818.      */
  819.     public function generateReportPdf(Request $request)
  820.     {
  821.         try {
  822.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  823.             if ($permissions['success'] !== true) {
  824.                 return $this->json($permissions);
  825.             }
  826.             $user = $permissions['user'];
  828.             $params  = json_decode($request->getContent(), true);
  829.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  831.             return $this->getPdfReport($request, $user, 'pdf/report_pdf_template.html.twig', $this->translator, '_manned_forecast_report.pdf');
  832.         } catch (\Exception $ex) {
  833.             $this->logger->error($ex->getMessage());
  834.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  835.         }
  836.     }
  838.     /**
  839.      * @Route("/api/public/get-report-types", name="public-report-types-listing")
  840.      */
  841.     public function getReportTypes(Request $request)
  842.     {
  843.         try {
  845.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  846.             if ($permissions['success'] !== true) {
  847.                 return $this->json($permissions);
  848.             }
  850.             $params  = json_decode($request->getContent(), true);
  851.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  853.             if (!isset($params['automatic'])) {
  854.                 throw new \Exception('missing_required_parameters');
  855.             }
  856.             $result = [];
  857.             $automatic = $params['automatic'] ? true : false;
  858.             $reportTypes = new \Pimcore\Model\DataObject\ReportType\Listing();
  859.             $reportTypes->setCondition('isAutomaticReport = ?', [$automatic]);
  860.             $reportTypes->load();
  862.             if ($reportTypes->getCount() > 0) {
  863.                 foreach ($reportTypes as $reportType) {
  864.                     $result[] = [
  865.                         "id" => $reportType->getId(),
  866.                         "key" => $reportType->getReportKey(),
  867.                         "nameEn" => $reportType->getName('en'),
  868.                         "nameAr" => $reportType->getName('ar'),
  869.                         "descriptionEn" => $reportType->getDescription('en'),
  870.                         "descriptionAr" => $reportType->getDescription('ar'),
  871.                         "titleEn" => $reportType->getTitle('en'),
  872.                         "titleAr" => $reportType->getTitle('ar'),
  873.                         "automatic" => $reportType->getIsAutomaticReport()
  874.                     ];
  875.                 }
  876.                 return $this->json(["success" => true, "data" => $result]);
  877.             }
  878.             return $this->json(["success" => false, "message" => $this->translator->trans("no_reportType_is_available")]);
  879.         } catch (\Exception $ex) {
  880.             $this->logger->error($ex->getMessage());
  881.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  882.         }
  883.     }
  885.     /**
  886.      * @Route("/api/public/get-weather-params-list", name="public-weather-params-listing")
  887.      */
  888.     public function getWeatherParamsListAction(Request $request)
  889.     {
  890.         try {
  891.             $result = [];
  892.             $lang = ($request->headers->has('lang')) ? $request->headers->get('lang') : "en";
  894.             $params  = json_decode($request->getContent(), true);
  895.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  897.             if (!isset($params['report_type_id'])) {
  898.                 return $this->json(['success' => false, 'message' =>  $this->translator->trans('missing_required_parameters')]);
  899.             }
  900.             $reportTypeId = $params['report_type_id'];
  901.             $parameters = new \Pimcore\Model\DataObject\ReportWeatherParameters\Listing();
  902.             $parameters->setCondition("reportType REGEXP CONCAT('(^|,)', REPLACE('" . $reportTypeId . "', ',', '|'), '(,|$)')");
  903.             $parameters->load();
  904.             if ($parameters->getCount() > 0) {
  905.                 foreach ($parameters as $paramter) {
  906.                     $result[] = [
  907.                         "id" => $paramter->getId(),
  908.                         "nameEn" => $paramter->getName('en'),
  909.                         "nameAr" => $paramter->getName('ar'),
  910.                         "meteoMaticsKey" => $paramter->getMeteoMaticsKey(),
  911.                         "units" => $paramter->getUnits(),
  912.                         "unitTitle" => $paramter->getUnitTitle()
  913.                     ];
  914.                 }
  915.                 return $this->json(["success" => true, "data" => $result]);
  916.             }
  917.             return $this->json(["success" => false, "message" => $this->translator->trans("no_weather_parameter_is_available")]);
  918.         } catch (\Exception $ex) {
  919.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  920.         }
  921.     }
  923.     /**
  924.      * @Route("/api/public/generate-excel", name="public-generate-excel")
  925.      */
  926.     public function generateExcelReport(Request $request)
  927.     {
  928.         $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  929.         if ($permissions['success'] !== true) {
  930.             return $this->json($permissions);
  931.         }
  932.         $user = $permissions['user'];
  934.         $params  = json_decode($request->getContent(), true);
  935.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  937.         if (!isset($params['id'])) {
  938.             throw new \Exception('missing_required_parameters');
  939.         }
  940.         $report = Report::getById($params['id'], true);
  941.         if (!$report instanceof Report) {
  942.             throw new \Exception('no_report_found');
  943.         }
  944.         // Replace this with the actual data you want to use
  945.         $jsonData = json_decode($report->getJsonData(), true);
  947.         // Create a new PhpSpreadsheet instance
  948.         $spreadsheet = new Spreadsheet();
  950.         // Create a worksheet
  951.         $sheet = $spreadsheet->getActiveSheet();
  953.         // Determine headers dynamically based on the first item in the data
  954.         $firstItem = reset($jsonData);
  955.         $parameters = $firstItem['parameters'] ?? [];
  956.         $headers = ['City', 'Lat', 'Lon', 'Date']; // Initialize headers with common columns
  958.         // Extract parameter names and add them to headers
  959.         foreach ($parameters as $parameter) {
  960.             $headers[] = $parameter['parameter'];
  961.         }
  963.         // Add headers to the worksheet
  964.         foreach ($headers as $index => $header) {
  965.             $sheet->setCellValueByColumnAndRow($index + 1, 1, $header);
  966.         }
  968.         // Initialize row counter
  969.         $row = 2;
  971.         foreach ($jsonData as $item) {
  972.             // Extract city-related data
  973.             $cityData = [$item['city'] ?? '', $item['lat'] ?? '', $item['lon'] ?? ''];
  975.             // Loop through each date for all parameters
  976.             foreach ($item['parameters'][0]['dates'] as $dateIndex => $date) {
  977.                 // Initialize row data with city-related data and date
  978.                 $rowData = array_merge($cityData, [date('Y-m-d', strtotime($date['date']))]);
  980.                 // Loop through each parameter
  981.                 foreach ($item['parameters'] as $parameter) {
  982.                     // Check if the value is set for the current date, otherwise set it to 0
  983.                     $value = isset($parameter['dates'][$dateIndex]['value']) ? $parameter['dates'][$dateIndex]['value'] : 0;
  985.                     // Add parameter value for the current date to the row data
  986.                     $rowData[] = $value;
  987.                 }
  989.                 // Set cell values explicitly
  990.                 foreach ($rowData as $colIndex => $cellValue) {
  991.                     $sheet->setCellValueByColumnAndRow($colIndex + 1, $row, $cellValue);
  992.                 }
  994.                 // Increment the row counter
  995.                 $row++;
  996.             }
  997.         }
  1002.         // Save the Excel file to a temporary file
  1003.         $tempFile = tempnam(sys_get_temp_dir(), 'weather_report');
  1004.         $writer = new Xlsx($spreadsheet);
  1005.         $writer->save($tempFile);
  1007.         // Store the file in Pimcore Assets
  1008.         $assetFolder = '/report/ExcelReports'; // Change this to your actual asset folder path
  1009.         $filename = $user->getId() . '_' . time() . '_' . 'weather_report.xlsx';
  1010.         $assetPath =  API_BASE_URL . '/' . $assetFolder . '/' . $filename;
  1012.         // Create a new asset
  1013.         $asset = new \Pimcore\Model\Asset();
  1014.         $asset->setFilename($filename);
  1015.         $asset->setData(file_get_contents($tempFile));
  1016.         $asset->setParent(\Pimcore\Model\Asset\Service::createFolderByPath($assetFolder));
  1017.         $asset->save();
  1019.         // Remove the temporary file
  1020.         unlink($tempFile);
  1021.         $report->setAsset($asset);
  1022.         $report->setIsHistorical(true);
  1023.         $report->save();
  1024.         // Return the path to the stored Excel file in Pimcore
  1025.         return $this->json(['success' => true, 'data' => $assetPath]);
  1026.     }
  1028.     /**
  1029.      * @Route("/api/public/generate-historical-report", methods={"POST"})
  1030.      */
  1031.     public function generateHistoricalReport(Request $request): JsonResponse
  1032.     {
  1033.         try {
  1034.             $response = [];
  1035.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1036.             if ($permissions['success'] !== true) {
  1037.                 return $this->json($permissions);
  1038.             }
  1039.             $params = json_decode($request->getContent(), true);
  1040.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1042.             if (
  1043.                 !isset($params['from_date']) ||
  1044.                 !isset($params['to_date']) ||
  1045.                 !isset($params['hours']) ||
  1046.                 !isset($params['parameters'])  ||
  1047.                 !isset($params['locations'])
  1048.             ) {
  1049.                 throw new \Exception('Missing required parameters');
  1050.             }
  1051.             if (empty($params['parameters'] || !is_array($params['parameters']))) {
  1052.                 throw new \Exception('Parameters should be non empty array');
  1053.             }
  1055.             if (empty($params['locations'] || !is_array($params['locations']))) {
  1056.                 throw new \Exception('Locations should be non empty array');
  1057.             }
  1058.             if ($params['to_date'] > date('Y-m-d', strtotime(Carbon::now()))) {
  1060.                 $daysadd = date('Y-m-d', strtotime(Carbon::now()->addDays('17')));
  1061.                 if ($params['to_date'] >= $daysadd) {
  1062.                     throw new \Exception('End date limit exceeded');
  1063.                 }
  1064.             }
  1065.             $model = isset($params['model']) ? $params['model'] : 'mix';
  1066.             $redisKey = md5('generate_city_report-' . $params['from_date'] . '-' . $params['to_date'] . '-' . $params['hours'] . '-' . implode('_', $params['locations'])) . '-' . implode('_', $params['parameters']) . '-' . $model;
  1067.             $data = $this->redisCache->get($redisKey);
  1068.             if (!$data) {
  1069.                 $cities = new \Pimcore\Model\DataObject\Location\Listing();
  1070.                 if (!empty($params['locations'])) {
  1071.                     $cities->setCondition('o_id IN (?)', [$params['locations']]);
  1072.                 }
  1073.                 $cities->load();
  1074.                 if ($cities->getCount() > 0) {
  1075.                     $params['coordinates'] = []; // Initialize an empty array for coordinates
  1076.                     $result = [];
  1077.                     $citiesArr = [];
  1078.                     foreach ($cities as $city) {
  1079.                         $cityLocations = json_decode($city->getCoordinates(), true);
  1080.                         foreach ($cityLocations as $coordinates) {
  1081.                             $long = number_format($coordinates[1], 6, '.', '');
  1082.                             $lat = number_format($coordinates[0], 6, '.', '');
  1083.                             $params['coordinates'][] = $coordinates;
  1084.                             $citiesArr[$lat . '|' . $long] =  $city->getName();
  1085.                         }
  1086.                     }
  1088.                     $result = $this->meteomaticsWeatherService->getReportForecastData($params['coordinates'], $params['from_date'], $params['to_date'], $params['hours'], $model, $params['parameters'], $this->translator, $citiesArr, $params);
  1090.                     $response[] = $result;
  1091.                     $jsonResponse = ['success' => true, 'data' => $response];
  1092.                     $this->redisCache->set($redisKey, $jsonResponse, REDIS_CACHE_TIME);
  1093.                     return $this->json($jsonResponse);
  1094.                 } else {
  1095.                     return $this->json(['success' => true, 'message' => $this->translator->trans('no_city_found')]);
  1096.                 }
  1097.             } else {
  1098.                 return $this->json($data);
  1099.             }
  1100.         } catch (\Exception $ex) {
  1101.             $this->logger->error($ex->getMessage());
  1102.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1103.         }
  1104.     }
  1106.     /**
  1107.      * @Route("/api/public/get-latest-report", name="public-get-latest-report")
  1108.      */
  1109.     public function getLatestReport(Request $request)
  1110.     {
  1111.         try {
  1113.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1114.             if ($permissions['success'] !== true) {
  1115.                 return $this->json($permissions);
  1116.             }
  1118.             $params  = json_decode($request->getContent(), true);
  1119.             $reportType = (isset($params['report_type']) && !empty($params['report_type'])) ? $params['report_type'] : 'ten-day-forecast-report';
  1120.             $result = $this->reportModel->getLatestReport($reportType, $this->translator, false);
  1122.             return $this->json($result);
  1123.         } catch (\Exception $ex) {
  1124.             $this->logger->error($ex->getMessage());
  1125.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1126.         }
  1127.     }
  1129.     /**
  1130.      * @Route("/api/public/get-automatic-reports", name="public_get_automatic_reports")
  1131.      */
  1132.     public function getAutomaticReports(Request $request, PaginatorInterface $paginator)
  1133.     {
  1134.         try {
  1135.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1136.             if ($permissions['success'] !== true) {
  1137.                 return $this->json($permissions);
  1138.             }
  1139.             $user = $permissions['user'];
  1141.             $params  = json_decode($request->getContent(), true);
  1142.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1144.             if (!isset($params['page']) || !isset($params['limit']) || !isset($params['lang'])) {
  1145.                 throw new \Exception('Missing required parameters');
  1146.             }
  1147.             $search = isset($params['search']) ? $params['search'] : null;
  1148.             $orderKey = isset($params['orderKey']) ? $params['orderKey'] : 'createdOn';
  1149.             $order = isset($params['order']) ? $params['order'] : 'desc';
  1150.             $result = $this->reportModel->listAutomaticReports($params, $user, $search, $orderKey, $order, $this->translator, $paginator);
  1151.             return $this->json($result);
  1152.         } catch (\Exception $ex) {
  1153.             $this->logger->error($ex->getMessage());
  1154.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1155.         }
  1156.     }
  1158.     /**
  1159.      * @Route("/api/public/generate-automatic-report-pdf", name="public-automatic-report-pdf")
  1160.      */
  1161.     public function generateAutomaticReportPdf(Request $request)
  1162.     {
  1163.         try {
  1164.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1165.             if ($permissions['success'] !== true) {
  1166.                 return $this->json($permissions);
  1167.             }
  1168.             $user = $permissions['user'];
  1169.             $result = $this->reportModel->generatePdfReport($request, $user, $this->snappy, $this->translator);
  1170.             return  $this->json($result);
  1171.         } catch (\Exception $ex) {
  1172.             $this->logger->error($ex->getMessage());
  1173.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1174.         }
  1175.     }
  1177.     public function getPdfReport($request, $user, $template, $translator, $report_type)
  1178.     {
  1179.         $params  = json_decode($request->getContent(), true);
  1180.         if (!isset($params['id'])) {
  1181.             return $this->json(["success" => false, "message" => $translator->trans("missing_required_parameters")]);
  1182.         }
  1183.         $report = Report::getById($params['id'], true);
  1184.         $lang = isset($params['lang']) ? $params['lang'] : "en";
  1185.         if (!$report instanceof Report) {
  1186.             return $this->json(["success" => false, "message" => $translator->trans("no_report_found")]);
  1187.         }
  1188.         $asset = $lang == 'ar' ? $report->getAssetAr() : $report->getAsset();
  1189.         if ($asset) {
  1190.             $pdfasset = API_BASE_URL . $asset->getPath() . $asset->getFilename();
  1191.             return $this->json(['success' => true, 'data' => $pdfasset]);
  1192.         }
  1193.         //$template=$report->getReportType()?->getKey() == 'MannForecastReport'?'pdf/report_pdf_template.html.twig':'pdf/automatic_report_pdf_template.html.twig';
  1195.         $fileName = '_custom_weather_report.pdf';
  1196.         $reportPath = '/report/ReportPdf';
  1198.         if ($report->getReportType()?->getKey() == 'MannForecastReport') {
  1199.             $template =  'pdf/report_pdf_template.html.twig';
  1200.         } elseif ($report->getReportType()?->getKey() == 'advance-custom-weather-report') {
  1202.             $template = 'pdf/advance_custom_report_pdf_template.html.twig';
  1203.             $fileName = '_advance_custom_weather_report.pdf';
  1204.             $reportPath = '/report/advanceCustomReportPdf';
  1205.         } else {
  1206.             $template = 'pdf/automatic_report_pdf_template.html.twig';
  1207.         }
  1210.         $parameter = [
  1211.             'data' => $report,
  1212.             'reportTitleEn' => $report->getReportTitle('en'),
  1213.             'reportTitleAr' => $report->getReportTitle('ar'),
  1214.             'reportDescriptionEn' => $report->getDescription('en'),
  1215.             'reportDescriptionAr' => $report->getDescription('ar'),
  1216.             'reportDisclaimerEn' => $report->getReportDisclaimer('en'), // new 
  1217.             'reportDisclaimerAr' => $report->getReportDisclaimer('ar'), // new 
  1218.             'additionalNoteEn' => $report->getAdditionalNote('en'), // new 
  1219.             'additionalNoteAr' => $report->getAdditionalNote('ar'), // new 
  1220.             'template' => $template,
  1221.             'lang' => $lang
  1222.         ];
  1224.         // return $this->render('pdf/automatic_report_pdf_template_copy.html.twig',$parameter);
  1225.         $pdf = \App\Lib\Utility::generatePdf($parameter, $this->snappy);
  1226.         // $tempFilePath = tempnam(sys_get_temp_dir(), 'image_');
  1227.         // file_put_contents($tempFilePath, $pdf);
  1229.         // Create a BinaryFileResponse and set headers
  1230.         //    $response = new BinaryFileResponse($tempFilePath);
  1231.         //    $response->headers->set('Content-Type', 'application/pdf');
  1232.         //    $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_INLINE, 'image.pdf');
  1234.         // Return the response
  1235.         //    return $response;
  1236.         $asset = \App\Lib\Utility::createAsset($pdf, $user->getId() . '_' . time() . $report_type,  $reportPath);
  1237.         $pdfasset = '';
  1238.         if ($asset instanceof Asset) {
  1239.             $pdfasset = API_BASE_URL . $asset->getPath() . $asset->getFilename();
  1240.         }
  1241.         if ($lang == 'ar') {
  1242.             $report->setAssetAr($asset);
  1243.         } else {
  1244.             $report->setAsset($asset);
  1245.         }
  1246.         $report->save();
  1247.         return $this->json(['success' => true, 'data' => $pdfasset]);
  1248.     }
  1250.     /**
  1251.      * @Route("/api/public/get-today-weather-report", name="public_get_today_weather_report")
  1252.      */
  1253.     public function getTodayWeatherReports(Request $request, PaginatorInterface $paginator)
  1254.     {
  1255.         try {
  1256.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1257.             if ($permissions['success'] !== true) {
  1258.                 return $this->json($permissions);
  1259.             }
  1260.             $user = $permissions['user'];
  1262.             $params  = json_decode($request->getContent(), true);
  1263.             if (!isset($params['page']) || !isset($params['limit']) || !isset($params['lang'])) {
  1264.                 throw new \Exception('Missing required parameters');
  1265.             }
  1266.             $result = $this->reportModel->getTodayWeatherReports($params, $this->translator, $paginator);
  1267.             return $this->json($result);
  1268.         } catch (\Exception $ex) {
  1269.             $this->logger->error($ex->getMessage());
  1270.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1271.         }
  1272.     }
  1274.     /**
  1275.      * @Route("/api/public/get-report-weather-symbols", name="public_get_report_weather_symbols")
  1276.      */
  1277.     public function getReportWeatherSymbols(Request $request): JsonResponse
  1278.     {
  1279.         try {
  1280.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1281.             if ($permissions['success'] !== true) {
  1282.                 return $this->json($permissions);
  1283.             }
  1284.             $user = $permissions['user'];
  1286.             $data = [];
  1287.             $weatherSymbols = new ReportWeatherSymbols\Listing();
  1288.             foreach ($weatherSymbols as $weatherSymbol) {
  1289.                 if ($weatherSymbol) {
  1290.                     $weatherSymbolNames = $weatherSymbol->getWeatherSymbols();
  1291.                     $weatherSymbolIcons = $weatherSymbol->getWeatherIcons();
  1292.                     if ($weatherSymbolNames) {
  1293.                         foreach ($weatherSymbolNames as $weatherSymbolName) {
  1294.                             $response['symbols'][] = [
  1295.                                 'nameEn' => $weatherSymbolName->getSymbolName('en'),
  1296.                                 'nameAr' => $weatherSymbolName->getSymbolName('ar'),
  1297.                             ];
  1298.                         }
  1299.                     }
  1300.                     if ($weatherSymbolIcons) {
  1301.                         foreach ($weatherSymbolIcons as $weatherSymbolIcon) {
  1302.                             $response['icons'][] = [
  1303.                                 'iconValue' => $weatherSymbolIcon->getIconValue(),
  1304.                             ];
  1305.                         }
  1306.                     }
  1307.                 }
  1308.                 $data[] = $response;
  1309.             }
  1311.             return $this->json(['success' => true, 'data' => $data]);
  1312.         } catch (\Exception $ex) {
  1313.             $this->logger->error($ex->getMessage());
  1314.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1315.         }
  1316.     }
  1318.     /**
  1319.      * @Route("/api/public/get-forecast-cities", methods={"POST"})
  1320.      */
  1321.     public function getForecastCities(Request $request): Response
  1322.     {
  1323.         try {
  1325.             $params = json_decode($request->getContent(), true);
  1326.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1328.             // check user credentials and expiry
  1329.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1330.             if ($response['success'] !== true) {
  1331.                 return $this->json($response);
  1332.             }
  1335.             $forecastCityModel = new WeatherForecastCityModel();
  1336.             $cities = $forecastCityModel->getWeatherForecastCities();
  1338.             return $this->json(['success' => true, 'data' => $cities]);
  1339.         } catch (\Exception $ex) {
  1340.             $this->logger->error($ex->getMessage());
  1341.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1342.         }
  1343.     }
  1345.     /**
  1346.      * @Route("/api/public/get-regions-bbox", name="get-regions-bbox")
  1347.      */
  1348.     public function getRegionsBbox(Request $request)
  1349.     {
  1350.         try {
  1352.             $params = json_decode($request->getContent(), true);
  1353.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1355.             // check user credentials and expiry
  1356.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1357.             if ($response['success'] !== true) {
  1358.                 return $this->json($response);
  1359.             }
  1362.             $data = REGIONS_BBOX;
  1364.             return $this->json(['success' => true, 'data' => $data]);
  1365.         } catch (\Exception $ex) {
  1366.             $this->logger->error($ex->getMessage());
  1367.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1368.         }
  1369.     }
  1371.     /**
  1372.      * @Route("/api/public/get-station-data", methods={"GET"})
  1373.      */
  1374.     public function getWeatherStationDataAction(Request $request)
  1375.     {
  1376.         try {
  1377.             $params = json_decode($request->getContent(), true);
  1378.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1380.             // check user credentials and expiry
  1381.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1382.             if ($response['success'] !== true) {
  1383.                 return $this->json($response);
  1384.             }
  1387.             $typeName = $request->get('type_name');
  1388.             $parameters = $request->get('parameters');
  1389.             $dateTime = $request->get('date_time');
  1390.             $bBox = $request->get('b_box');
  1393.             if (!$typeName) {
  1394.                 throw new \InvalidArgumentException("Missing mandatory parameter: type_name");
  1395.             }
  1396.             if (!$parameters) {
  1397.                 throw new \InvalidArgumentException("Missing mandatory parameter: parameters");
  1398.             }
  1399.             if (!$dateTime) {
  1400.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  1401.             }
  1402.             if (!$bBox) {
  1403.                 throw new \InvalidArgumentException("Missing mandatory parameter: b_box");
  1404.             }
  1406.             $result = $this->meteomaticsWeatherService->getWeatherStationData($typeName, $parameters, $dateTime, $bBox);
  1407.             return $result;
  1408.         } catch (\Exception $ex) {
  1409.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1410.         }
  1411.     }
  1413.     /**
  1414.      * @Route("/api/public/daily-forecast", methods={"POST"})
  1415.      */
  1416.     public function dailyForecast(Request $request): JsonResponse
  1417.     {
  1418.         try {
  1419.             $params = json_decode($request->getContent(), true);
  1420.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1422.             // check user credentials and expiry
  1423.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1424.             if ($response['success'] !== true) {
  1425.                 return $this->json($response);
  1426.             }
  1428.             $requiredParameters = ['coordinates', 'from_date', 'to_date', 'model'];
  1429.             foreach ($requiredParameters as $param) {
  1430.                 if (!isset($params[$param])) {
  1431.                     $missingParams[] = $param;
  1432.                 }
  1433.             }
  1434.             if (!empty($missingParams)) {
  1435.                 // Throw an exception with a message that includes the missing parameters
  1436.                 $parameterList = implode(", ", $missingParams);
  1437.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1438.             }
  1439.             $result = $this->meteomaticsWeatherService->getForecastData($params['coordinates'], $params['from_date'], $params['to_date'], $params['hours'], $params['model'], $this->translator);
  1440.             return $this->json($result);
  1441.         } catch (\Exception $ex) {
  1442.             $this->logger->error($ex->getMessage());
  1443.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1444.         }
  1445.     }
  1447.     /**
  1448.      * @Route("/api/public/weather/{path}", name="api_meteomatics", requirements={"path"=".+"}, methods={"GET"})
  1449.      */
  1450.     public function getDynamicWeatherData(Request $request, string $path): Response
  1451.     {
  1452.         try {
  1453.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1454.             if ($response['success'] !== true) {
  1455.                 return $this->json($response);
  1456.             }
  1457.             $user = $response['user'];
  1458.             $queryParams = $request->query->all();
  1459.             $weatherData = $this->meteomaticApiService->getDynamicWeatherData($path, $queryParams, $user);
  1460.             return $weatherData;
  1461.         } catch (\Exception $ex) {
  1462.             $this->logger->error($ex->getMessage());
  1463.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1464.         }
  1465.     }
  1467.     /**
  1468.      * @Route("/api/public/create-manned-alert-subscription", methods={"POST"})
  1469.      */
  1470.     public function mannedAlertSubscription(Request $request): JsonResponse
  1471.     {
  1472.         try {
  1473.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1474.             if ($response['success'] !== true) {
  1475.                 return $this->json($response);
  1476.             }
  1477.             $user = $response['user'];
  1478.             $params = json_decode($request->getContent(), true);
  1479.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1481.             // $requiredParameters = ['region_id', 'governorate_id', 'alert_type_id'];
  1483.             // foreach ($requiredParameters as $param) {
  1484.             //     if (!isset($params[$param]) || empty($params[$param])) {
  1485.             //         $missingParams[] = $param;
  1486.             //     }
  1487.             // }
  1489.             // if (!empty($missingParams)) {
  1490.             //     // Throw an exception with a message that includes the missing parameters
  1491.             //     $parameterList = implode(", ", $missingParams);
  1492.             //     return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1493.             // }
  1495.             $result = $this->customNotificationService->mannedAlertSubscription($user, $params, $this->translator);
  1496.             return $this->json($result);
  1497.         } catch (\Exception $ex) {
  1498.             $this->logger->error($ex->getMessage());
  1499.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1500.         }
  1501.     }
  1503.     /**
  1504.      * @Route("/api/public/upload-bulk-locations", methods={"POST"})
  1505.      */
  1506.     public function uploadBulkLocations(Request $request): JsonResponse
  1507.     {
  1508.         try {
  1509.             $lang = $request->request->get('lang');
  1510.             $email = $request->request->get('email', 'umer.wasi@centricdxb.com');
  1511.             $name = $request->request->get('name', 'User');
  1512.             $reason = $request->request->get('request_reason', 'N/A');
  1513.             $file = $request->files->get('file');
  1514.             $this->translator->setlocale(isset($lang) ? $lang : DEFAULT_LOCALE);
  1516.             if (!$file || !$file->isValid()) {
  1517.                 return new JsonResponse(['success' => false, 'message' => 'Invalid or missing file'], 400);
  1518.             }
  1520.             // Upload file to c2service and get asset ID
  1521.             $assetId = $this->c2Service->uploadToC2service($file);
  1523.             if (!$assetId) {
  1524.                 throw new \Exception('Failed to upload to c2service');
  1525.             }
  1527.             $html = $this->templating->render('web2print/_request_location.html.twig', ['name' => $name, 'reason' => $reason]);
  1529.             $result = $this->c2Service->sendWeatherDashboardEmail($_ENV['WEATHER_DASHBOARD_LOCATIONS'], $email, $html, '', $assetId);
  1531.             return $this->json(['success' => true, 'message' => $this->translator->trans('file_successfully_submitted')]);
  1532.         } catch (\Exception $ex) {
  1533.             $this->logger->error($ex->getMessage());
  1534.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1535.         }
  1536.     }
  1538.     /**
  1539.      * @Route("/api/public/get-token", methods={"POST"})
  1540.      */
  1541.     public function getToken(Request $request): JsonResponse
  1542.     {
  1543.         try {
  1544.             $result = $this->meteomaticApiService->getToken();
  1545.             return $this->json($result);
  1546.         } catch (\Exception $ex) {
  1547.             $this->logger->error($ex->getMessage());
  1548.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1549.         }
  1550.     }
  1551.     /**
  1552.      * @Route("/api/public/weather/get-solar-power", methods={"POST"})
  1553.      */
  1554.     public function getSolarPowerAction(Request $request)
  1555.     {
  1556.         try {
  1557.             
  1558.             $params = json_decode($request->getContent(), true);
  1559.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1562.             // check user credentials and expiry// check user credentials and expiry
  1563.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1564.             if ($response['success'] !== true) {
  1565.                 return $this->json($response);
  1566.             }
  1568.             $mandatoryParams = ['latitude', 'longitude', 'hour', 'specification', 'interval_in_hours', 'start_date', 'end_date', 'unit'];
  1569.             foreach ($mandatoryParams as $param) {
  1570.                 if (!isset($params[$param]) || empty($params[$param])) {
  1571.                     $missingParams[] = $param;
  1572.                 }
  1573.             }
  1575.             if (!empty($missingParams)) {
  1576.                 // Throw an exception with a message that includes the missing parameters
  1577.                 $parameterList = implode(", ", $missingParams);
  1578.                 throw new \InvalidArgumentException(sprintf($this->translator->trans("missing_or_empty_mandatory_parameter: %s"), $parameterList));
  1579.             }
  1581.             // Extract the necessary parameters for getWeatherWarnings function  
  1582.             $coordinates = [[$params['latitude'], $params['longitude']]];
  1583.             $startDate = $params['start_date'];
  1584.             $endDate = $params['end_date'];
  1585.             $specification = $params['specification'];
  1586.             $intervalInHours = $params['interval_in_hours'];
  1587.             $hour = $params['hour'];
  1588.             $unit = $params['unit'];
  1589.             // Call the getWindPower function with validated parameters
  1590.             $result = $this->meteomaticsWeatherService->getSolarPower($coordinates, $startDate, $endDate, $intervalInHours, $hour, $unit, $specification, $this->translator);
  1591.             return $this->json($result);
  1592.         } catch (\Exception $ex) {
  1593.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1594.         }
  1595.     }
  1596.     /**
  1597.      * @Route("/api/public/weather/air-density", methods={"POST"})
  1598.      */
  1599.     public function airdensityData(Request $request): JsonResponse
  1600.     {
  1602.         try {
  1604.             // check user credentials and expiry
  1605.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1606.             if ($response['success'] !== true) {
  1607.                 return $this->json($response);
  1608.             }
  1610.             $params = json_decode($request->getContent(), true);
  1611.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1613.             $requiredParameters = ['hour', 'start_date', 'end_date', 'coordinates', 'level', 'unit', 'format'];
  1614.             foreach ($requiredParameters as $param) {
  1615.                 if (!isset($params[$param])) {
  1616.                     $missingParams[] = $param;
  1617.                 }
  1618.             }
  1619.             if (!empty($missingParams)) {
  1620.                 // Throw an exception with a message that includes the missing parameters
  1621.                 $parameterList = implode(", ", $missingParams);
  1622.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1623.             }
  1625.             $hour = $params['hour'];
  1626.             $startDate = $params['start_date'];
  1627.             $endDate = $params['end_date'];
  1628.             $coordinates = $params['coordinates'];
  1629.             $level = $params['level'];
  1630.             $unit = $params['unit'];
  1631.             $format = $params['format'];
  1635.             $response = $this->meteomaticsWeatherService->getAirdensity(
  1636.                 $hour,
  1637.                 $startDate,
  1638.                 $endDate,
  1639.                 $coordinates,
  1640.                 $level,
  1641.                 $unit,
  1642.                 $format
  1643.             );
  1645.             // You can return or process the $data as needed
  1646.             // For demonstration purposes, we will just return a JSON response
  1647.             return $this->json($response);
  1648.         } catch (\Exception $ex) {
  1649.             $this->logger->error($ex->getMessage());
  1650.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1651.         }
  1652.     }
  1653.     /**
  1654.      * @Route("/api/public/weather/get-metar-data", methods={"POST"})
  1655.      */
  1656.     public function getMetarData(Request $request): JsonResponse
  1657.     {
  1658.         try {
  1659.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1660.             if ($response['success'] !== true) {
  1661.                 return $this->json($response);
  1662.             }
  1664.             $params = json_decode($request->getContent(), true);
  1665.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1667.             $requiredParameters = ['startDate', 'endDate', 'metar', 'duration'];
  1668.             foreach ($requiredParameters as $param) {
  1669.                 if (!isset($params[$param])) {
  1670.                     $missingParams[] = $param;
  1671.                 }
  1672.             }
  1673.             if (!empty($missingParams)) {
  1674.                 // Throw an exception with a message that includes the missing parameters
  1675.                 $parameterList = implode(", ", $missingParams);
  1676.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1677.             }
  1679.             $startDate = $params['startDate'];
  1680.             $endDate = $params['endDate'];
  1681.             $metar = $params['metar'];
  1682.             $duration = $params['duration'];
  1683.             $parameters = $params['parameter'] ?? null;
  1684.             $genExcel = $request->get('gen_excel', false);
  1685.             $metarData = $this->meteomaticsWeatherService->getMetarData($startDate, $endDate, $metar, $duration, $this->translator, $parameters, $genExcel);
  1687.             return $this->json(['success' => true, 'message' => $this->translator->trans("excel_file_downloaded_successfully"), 'data' => $metarData]);
  1688.         } catch (\Exception $ex) {
  1689.             $this->logger->error($ex->getMessage());
  1690.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1691.         }
  1692.     }
  1693.     /**
  1694.      * @Route("/api/public/weather/frost-thaw-depth", methods={"POST"})
  1695.      */
  1696.     public function frostThawAndDepthData(Request $request): JsonResponse
  1697.     {
  1699.         try {
  1701.             // check user credentials and expiry
  1702.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1703.             if ($response['success'] !== true) {
  1704.                 return $this->json($response);
  1705.             }
  1707.             $params = json_decode($request->getContent(), true);
  1708.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1710.             $requiredParameters = ['hour', 'start_date', 'end_date', 'unit', 'coordinates', 'format'];
  1711.             foreach ($requiredParameters as $param) {
  1712.                 if (!isset($params[$param])) {
  1713.                     $missingParams[] = $param;
  1714.                 }
  1715.             }
  1716.             if (!empty($missingParams)) {
  1717.                 // Throw an exception with a message that includes the missing parameters
  1718.                 $parameterList = implode(", ", $missingParams);
  1719.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1720.             }
  1722.             $hour = $params['hour'];
  1723.             $startDate = $params['start_date'];
  1724.             $endDate = $params['end_date'];
  1725.             $unit = $params['unit'];
  1726.             $coordinates = $params['coordinates'];
  1727.             $format = $params['format'];
  1731.             $response = $this->meteomaticsWeatherService->getFrostThawAndDepth(
  1732.                 $hour,
  1733.                 $startDate,
  1734.                 $endDate,
  1735.                 $unit,
  1736.                 $coordinates,
  1737.                 $format
  1738.             );
  1740.             // You can return or process the $data as needed
  1741.             // For demonstration purposes, we will just return a JSON response
  1742.             return $this->json($response);
  1743.         } catch (\Exception $ex) {
  1744.             $this->logger->error($ex->getMessage());
  1745.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1746.         }
  1747.     }
  1748.     /**
  1749.      * @Route("/api/public/weather/get-hail-index", methods={"POST"})
  1750.      */
  1751.     public function getHailIndexAction(Request $request): JsonResponse
  1752.     {
  1753.         try {
  1754.             // check user credentials and expiry
  1755.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1756.             if ($response['success'] !== true) {
  1757.                 return $this->json($response);
  1758.             }
  1760.             $params = json_decode($request->getContent(), true);
  1761.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1763.             $mandatoryParams = ['coordinates', 'start_date', 'end_date', 'duration', 'interval_type'];
  1764.             foreach ($mandatoryParams as $param) {
  1765.                 if (!isset($params[$param]) || empty($params[$param])) {
  1766.                     $missingParams[] = $param;
  1767.                 }
  1768.             }
  1770.             if (!empty($missingParams)) {
  1771.                 // Throw an exception with a message that includes the missing parameters
  1772.                 $parameterList = implode(", ", $missingParams);
  1773.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1774.             }
  1776.             // Extract the necessary parameters for getWeatherWarnings function
  1777.             $coordinates = $params['coordinates'];
  1778.             $startDate = $params['start_date'];
  1779.             $endDate = $params['end_date'];
  1780.             $intervalType = $params['interval_type'];
  1781.             $duration = $params['duration'] ?? '5';
  1782.             $format = $params['format'] ?? 'json';
  1784.             // Call the getWeatherWarnings function with validated parameters
  1785.             $result = $this->meteomaticsWeatherService->getHailIndex($coordinates, $startDate, $endDate, $duration, $intervalType, $format, $this->translator);
  1786.             return $this->json($result);
  1787.         } catch (\Exception $ex) {
  1788.             $this->logger->error($ex->getMessage());
  1789.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1790.         }
  1791.     }
  1792.     /**
  1793.      * @Route("/api/public/weather/soil-moisture-index", methods={"POST"})
  1794.      */
  1795.     public function soilMoistureIndexData(Request $request): JsonResponse
  1796.     {
  1797.         try {
  1798.             // check user credentials and expiry
  1799.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1800.             if ($response['success'] !== true) {
  1801.                 return $this->json($response);
  1802.             }
  1804.             $params = json_decode($request->getContent(), true);
  1805.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1807.             $requiredParameters = ['hour', 'start_date', 'end_date', 'coordinates', 'level', 'unit', 'format'];
  1808.             foreach ($requiredParameters as $param) {
  1809.                 if (!isset($params[$param])) {
  1810.                     $missingParams[] = $param;
  1811.                 }
  1812.             }
  1813.             if (!empty($missingParams)) {
  1814.                 // Throw an exception with a message that includes the missing parameters
  1815.                 $parameterList = implode(", ", $missingParams);
  1816.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1817.             }
  1819.             $hour = $params['hour'];
  1820.             $startDate = $params['start_date'];
  1821.             $endDate = $params['end_date'];
  1822.             $coordinates = $params['coordinates'];
  1823.             $level = $params['level'];
  1824.             $unit = $params['unit'];
  1825.             $format = $params['format'];
  1829.             $response = $this->meteomaticsWeatherService->getSoilMoistureIndex(
  1830.                 $hour,
  1831.                 $startDate,
  1832.                 $endDate,
  1833.                 $coordinates,
  1834.                 $level,
  1835.                 $unit,
  1836.                 $format
  1837.             );
  1839.             // You can return or process the $data as needed
  1840.             // For demonstration purposes, we will just return a JSON response
  1841.             return $this->json($response);
  1842.         } catch (\Exception $ex) {
  1843.             $this->logger->error($ex->getMessage());
  1844.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1845.         }
  1846.     }
  1847.     /**
  1848.      * @Route("/api/public/weather/get-moving-average", methods={"POST"})
  1849.      */
  1850.     public function getMovingAverage(Request $request): JsonResponse
  1851.     {
  1852.         try {
  1853.             // check user credentials and expiry
  1854.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1855.             if ($response['success'] !== true) {
  1856.                 return $this->json($response);
  1857.             }
  1859.             $params  = json_decode($request->getContent(), true);
  1860.             $requiredParameters = ['start_from', 'days', 'location', "name"];
  1861.             foreach ($requiredParameters as $param) {
  1862.                 if (!isset($params[$param])) {
  1863.                     $missingParams[] = $param;
  1864.                 }
  1865.             }
  1866.             if (!empty($missingParams)) {
  1867.                 $parameterList = implode(", ", $missingParams);
  1868.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1869.             }
  1870.             switch ($params['name']) {
  1871.                 case 'temperature_day':
  1872.                     $data = $this->insuranceIndustryService->mmTemperatureDay($params['start_from'], $params['days'], $params['location']);
  1873.                     break;
  1874.                 case 'temperature_night':
  1875.                     $data = $this->insuranceIndustryService->mmTemperatureNight($params['start_from'], $params['days'], $params['location']);
  1876.                     break;
  1877.                 case 'wind_speed':
  1878.                     $data = $this->insuranceIndustryService->mmWindSpeed($params['start_from'], $params['days'], $params['location']);
  1879.                     break;
  1880.                 case 'soil_water_content':
  1881.                     $data = $this->insuranceIndustryService->mmSoilWaterContent($params['start_from'], $params['days'], $params['location']);
  1882.                     break;
  1883.                 default:
  1884.                     // Handle invalid function name
  1885.                     return $this->json(['success' => false, 'message' => 'Invalid name']);
  1886.             }
  1887.             return $this->json(['success' => true, 'data' => $data]);
  1888.         } catch (\Exception $ex) {
  1889.             $this->logger->error($ex->getMessage());
  1890.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1891.         }
  1892.     }
  1893.     /**
  1894.      * @Route("/api/public/weather/heat-index", methods={"POST"})
  1895.      */
  1896.     public function heatIndexData(Request $request): JsonResponse
  1897.     {
  1899.         try {
  1901.             // check user credentials and expiry
  1902.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1903.             if ($response['success'] !== true) {
  1904.                 return $this->json($response);
  1905.             }
  1907.             $params = json_decode($request->getContent(), true);
  1908.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1910.             $requiredParameters = ['hour', 'start_date', 'end_date', 'coordinates', 'unit', 'format', 'model'];
  1911.             foreach ($requiredParameters as $param) {
  1912.                 if (!isset($params[$param])) {
  1913.                     $missingParams[] = $param;
  1914.                 }
  1915.             }
  1916.             if (!empty($missingParams)) {
  1917.                 // Throw an exception with a message that includes the missing parameters
  1918.                 $parameterList = implode(", ", $missingParams);
  1919.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1920.             }
  1922.             $hour = $params['hour'];
  1923.             $startDate = $params['start_date'];
  1924.             $endDate = $params['end_date'];
  1925.             $coordinates = $params['coordinates'];
  1926.             $unit = $params['unit'];
  1927.             $format = $params['format'];
  1928.             $model = $params['model'];
  1932.             $response = $this->meteomaticsWeatherService->getHeatIndex(
  1933.                 $hour,
  1934.                 $startDate,
  1935.                 $endDate,
  1936.                 $coordinates,
  1937.                 $unit,
  1938.                 $format,
  1939.                 $model
  1940.             );
  1942.             // You can return or process the $data as needed
  1943.             // For demonstration purposes, we will just return a JSON response
  1944.             return $this->json($response);
  1945.         } catch (\Exception $ex) {
  1946.             $this->logger->error($ex->getMessage());
  1947.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1948.         }
  1949.     }
  1950.     /**
  1951.      * @Route("/api/public/weather/get-seasonal-average", methods={"POST"})
  1952.      */
  1953.     public function getSeasonalAverager(Request $request): JsonResponse
  1954.     {
  1955.         try {
  1956.             // check user credentials and expiry
  1957.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1958.             if ($response['success'] !== true) {
  1959.                 return $this->json($response);
  1960.             }
  1961.             $params  = json_decode($request->getContent(), true);
  1962.             $requiredParameters = ['date', 'day_time', 'parameter', 'location'];
  1963.             foreach ($requiredParameters as $param) {
  1964.                 if (!isset($params[$param])) {
  1965.                     $missingParams[] = $param;
  1966.                 }
  1967.             }
  1968.             if (!empty($missingParams)) {
  1969.                 $parameterList = implode(", ", $missingParams);
  1970.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1971.             }
  1973.             $data = $this->insuranceIndustryService->seasonalAverage($params['date'], $params['day_time'], $params['parameter'], $params['location']);
  1974.             return $this->json(['success' => true, 'data' => $data]);
  1975.         } catch (\Exception $ex) {
  1976.             $this->logger->error($ex->getMessage());
  1977.             return $this->json(['success' => false, $this->translator->trans(USER_ERROR_MESSAGE)]);
  1978.         }
  1979.     }
  1980.     /**
  1981.      * @Route("/api/public/weather/get-threats-table", methods={"POST"})
  1982.      */
  1983.     public function getThreatTable(Request $request): JsonResponse
  1984.     {
  1985.         try {
  1986.             // check user credentials and expiry
  1987.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1988.             if ($response['success'] !== true) {
  1989.                 return $this->json($response);
  1990.             }
  1991.             $params  = json_decode($request->getContent(), true);
  1992.             $requiredParameters = ['date', 'day_deep', 'location'];
  1993.             foreach ($requiredParameters as $param) {
  1994.                 if (!isset($params[$param])) {
  1995.                     $missingParams[] = $param;
  1996.                 }
  1997.             }
  1998.             if (!empty($missingParams)) {
  1999.                 $parameterList = implode(", ", $missingParams);
  2000.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2001.             }
  2002.             $data = $this->insuranceIndustryService->threatTable($params['date'], $params['day_deep'], $params['location']);
  2003.             return $this->json(['success' => true, 'data' => $data]);
  2004.         } catch (\Exception $ex) {
  2005.             $this->logger->error($ex->getMessage());
  2006.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2007.         }
  2008.     }
  2010.     /**
  2011.      * @Route("/api/public/weather/high-low-tide-times", methods={"POST"})
  2012.      */
  2013.     public function highLowTideTimesData(Request $request): JsonResponse
  2014.     {
  2016.         try {
  2017.             // check user credentials and expiry
  2018.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2019.             if ($response['success'] !== true) {
  2020.                 return $this->json($response);
  2021.             }
  2022.             $params = json_decode($request->getContent(), true);
  2023.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2026.             $requiredParameters = ['hour', 'start_date', 'end_date', 'coordinates', 'model', 'format'];
  2028.             foreach ($requiredParameters as $param) {
  2029.                 if (!isset($params[$param])) {
  2030.                     $missingParams[] = $param;
  2031.                 }
  2032.             }
  2033.             if (!empty($missingParams)) {
  2034.                 // Throw an exception with a message that includes the missing parameters
  2035.                 $parameterList = implode(", ", $missingParams);
  2036.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2037.             }
  2039.             $hour = $params['hour'];
  2040.             $startDate = $params['start_date'];
  2041.             $endDate = $params['end_date'];
  2042.             $coordinates = $params['coordinates'];
  2043.             $model = $params['model'];
  2044.             $format = $params['format'];
  2048.             $response = $this->meteomaticsWeatherService->getHighLowTideTimes(
  2049.                 $hour,
  2050.                 $startDate,
  2051.                 $endDate,
  2052.                 $coordinates,
  2053.                 $model,
  2054.                 $format
  2055.             );
  2057.             // You can return or process the $data as needed
  2058.             // For demonstration purposes, we will just return a JSON response
  2059.             return $this->json($response);
  2060.         } catch (\Exception $ex) {
  2061.             $this->logger->error($ex->getMessage());
  2062.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2063.         }
  2064.     }
  2066.     /**
  2067.      * @Route("/api/public/weather/tidal-amplitude", methods={"POST"})
  2068.      */
  2069.     public function tidalAmplitudeData(Request $request): JsonResponse
  2070.     {
  2072.         try {
  2074.             // check user credentials and expiry
  2075.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2076.             if ($response['success'] !== true) {
  2077.                 return $this->json($response);
  2078.             }
  2079.             $params = json_decode($request->getContent(), true);
  2080.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2082.             $requiredParameters = ['hour', 'start_date', 'end_date', 'coordinates', 'unit', 'model', 'format'];
  2083.             foreach ($requiredParameters as $param) {
  2084.                 if (!isset($params[$param])) {
  2085.                     $missingParams[] = $param;
  2086.                 }
  2087.             }
  2088.             if (!empty($missingParams)) {
  2089.                 // Throw an exception with a message that includes the missing parameters
  2090.                 $parameterList = implode(", ", $missingParams);
  2091.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2092.             }
  2094.             $hour = $params['hour'];
  2095.             $startDate = $params['start_date'];
  2096.             $endDate = $params['end_date'];
  2097.             $coordinates = $params['coordinates'];
  2098.             $unit = $params['unit'];
  2099.             $model = $params['model'];
  2100.             $format = $params['format'];
  2104.             $response = $this->meteomaticsWeatherService->getTidalAmplitudes(
  2105.                 $hour,
  2106.                 $startDate,
  2107.                 $endDate,
  2108.                 $coordinates,
  2109.                 $unit,
  2110.                 $model,
  2111.                 $format
  2112.             );
  2114.             // You can return or process the $data as needed
  2115.             // For demonstration purposes, we will just return a JSON response
  2116.             return $this->json($response);
  2117.         } catch (\Exception $ex) {
  2118.             $this->logger->error($ex->getMessage());
  2119.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2120.         }
  2121.     }
  2122.     /**
  2123.      * @Route("/api/public/weather/significant-wave-height", methods={"POST"})
  2124.      */
  2125.     public function significantWaveHeightData(Request $request): JsonResponse
  2126.     {
  2128.         try {
  2130.             // check user credentials and expiry
  2131.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2132.             if ($response['success'] !== true) {
  2133.                 return $this->json($response);
  2134.             }
  2136.             $params = json_decode($request->getContent(), true);
  2137.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2139.             $requiredParameters = ['hour', 'start_date', 'end_date', 'coordinates', 'format'];
  2141.             foreach ($requiredParameters as $param) {
  2142.                 if (!isset($params[$param])) {
  2143.                     $missingParams[] = $param;
  2144.                 }
  2145.             }
  2146.             if (!empty($missingParams)) {
  2147.                 // Throw an exception with a message that includes the missing parameters
  2148.                 $parameterList = implode(", ", $missingParams);
  2149.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2150.             }
  2152.             $hour = $params['hour'];
  2153.             $startDate = $params['start_date'];
  2154.             $endDate = $params['end_date'];
  2155.             $coordinates = $params['coordinates'];
  2156.             $format = $params['format'];
  2160.             $response = $this->meteomaticsWeatherService->getSignificantWaveHeight(
  2161.                 $hour,
  2162.                 $startDate,
  2163.                 $endDate,
  2164.                 $coordinates,
  2165.                 $format
  2166.             );
  2168.             // You can return or process the $data as needed
  2169.             // For demonstration purposes, we will just return a JSON response
  2170.             return $this->json($response);
  2171.         } catch (\Exception $ex) {
  2172.             $this->logger->error($ex->getMessage());
  2173.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2174.         }
  2175.     }
  2176.     /**
  2177.      * @Route("/api/public/weather/surge-amplitude", methods={"POST"})
  2178.      */
  2179.     public function surgeAmplitudeData(Request $request): JsonResponse
  2180.     {
  2182.         try {
  2184.             // check user credentials and expiry
  2185.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2186.             if ($response['success'] !== true) {
  2187.                 return $this->json($response);
  2188.             }
  2190.             $params = json_decode($request->getContent(), true);
  2191.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2193.             $requiredParameters = ['hour', 'start_date', 'end_date', 'coordinates', 'unit', 'model', 'format'];
  2194.             foreach ($requiredParameters as $param) {
  2195.                 if (!isset($params[$param])) {
  2196.                     $missingParams[] = $param;
  2197.                 }
  2198.             }
  2199.             if (!empty($missingParams)) {
  2200.                 // Throw an exception with a message that includes the missing parameters
  2201.                 $parameterList = implode(", ", $missingParams);
  2202.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2203.             }
  2205.             $hour = $params['hour'];
  2206.             $startDate = $params['start_date'];
  2207.             $endDate = $params['end_date'];
  2208.             $coordinates = $params['coordinates'];
  2209.             $unit = $params['unit'];
  2210.             $model = $params['model'];
  2211.             $format = $params['format'];
  2215.             $response = $this->meteomaticsWeatherService->getSurgeAmplitude(
  2216.                 $hour,
  2217.                 $startDate,
  2218.                 $endDate,
  2219.                 $coordinates,
  2220.                 $unit,
  2221.                 $model,
  2222.                 $format
  2223.             );
  2225.             // You can return or process the $data as needed
  2226.             // For demonstration purposes, we will just return a JSON response
  2227.             return $this->json($response);
  2228.         } catch (\Exception $ex) {
  2229.             $this->logger->error($ex->getMessage());
  2230.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2231.         }
  2232.     }
  2234.     /**
  2235.      * @Route("/api/public/weather/fog", methods={"POST"})
  2236.      */
  2237.     public function fogData(Request $request): JsonResponse
  2238.     {
  2240.         try {
  2242.             // check user credentials and expiry
  2243.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2244.             if ($response['success'] !== true) {
  2245.                 return $this->json($response);
  2246.             }
  2248.             $params = json_decode($request->getContent(), true);
  2249.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2251.             $requiredParameters = ['start_date', 'end_date', 'coordinates', 'format'];
  2252.             foreach ($requiredParameters as $param) {
  2253.                 if (!isset($params[$param])) {
  2254.                     $missingParams[] = $param;
  2255.                 }
  2256.             }
  2257.             if (!empty($missingParams)) {
  2258.                 // Throw an exception with a message that includes the missing parameters
  2259.                 $parameterList = implode(", ", $missingParams);
  2260.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2261.             }
  2264.             $startDate = $params['start_date'];
  2265.             $endDate = $params['end_date'];
  2266.             $interval = $params['interval'];
  2267.             $unit = $params['unit'];
  2268.             $coordinates = $params['coordinates'];
  2269.             $format = $params['format'];
  2273.             $response = $this->meteomaticsWeatherService->getFog(
  2274.                 $coordinates,
  2275.                 $startDate,
  2276.                 $endDate,
  2277.                 $interval,
  2278.                 $unit,
  2279.                 $this->translator,
  2280.                 $format
  2281.             );
  2283.             // You can return or process the $data as needed
  2284.             // For demonstration purposes, we will just return a JSON response
  2285.             return $this->json($response);
  2286.         } catch (\Exception $ex) {
  2287.             $this->logger->error($ex->getMessage());
  2288.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2289.         }
  2290.     }
  2291.     /**
  2292.      * @Route("/api/public/weather/generic-api", methods={"POST"})
  2293.      */
  2294.     public function fetchMeteomaticData(Request $request): JsonResponse
  2295.     {
  2296.         $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2297.         if ($response['success'] !== true) {
  2298.             return $this->json($response);
  2299.         }
  2302.         $params = json_decode($request->getContent(), true);
  2303.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2305.         if (!isset($params['format'])) {
  2306.             throw new \InvalidArgumentException('Missing "format" parameter');
  2307.         }
  2309.         if ($params['format'] == "json") {
  2310.             if (
  2311.                 !isset($params['startdate']) ||
  2312.                 !isset($params['enddate']) ||
  2313.                 !isset($params['resolution']) ||
  2314.                 !isset($params['parameters']) ||
  2315.                 !isset($params['lat']) ||
  2316.                 !isset($params['lon']) ||
  2317.                 !isset($params['format'])
  2318.             ) {
  2319.                 throw new \Exception('Missing required parameters');
  2320.             }
  2321.             // date_default_timezone_set('UTC');
  2323.             //$hour = $params['hour'];
  2324.             $format = $params['format'];
  2325.             $startDate = $params['startdate'];
  2326.             $endDate = $params['enddate'];
  2327.             $resolution = $params['resolution'];
  2328.             $parameters = $params['parameters'];
  2329.             $model = $params['model'];
  2330.             $lat = $params['lat'];
  2331.             $lon = $params['lon'];
  2334.             $response = $this->meteomaticApiService->timeSeriesQuery(
  2335.                 $startDate,
  2336.                 $endDate,
  2337.                 $resolution,
  2338.                 $parameters,
  2339.                 $model,
  2340.                 $lat,
  2341.                 $lon,
  2342.                 $format,
  2343.                 $this->translator
  2344.             );
  2345.         } else {
  2346.             $mandatoryParams = ['version', 'request', 'layers', 'crs', 'bbox', 'format', 'width', 'height', 'tiled'];
  2347.             foreach ($mandatoryParams as $param) {
  2348.                 if (!isset($params[$param]) || empty($params[$param])) {
  2349.                     $missingParams[] = $param;
  2350.                 }
  2351.             }
  2353.             if (!empty($missingParams)) {
  2354.                 // Throw an exception with a message that includes the missing parameters
  2355.                 $parameterList = implode(", ", $missingParams);
  2356.                 throw new \InvalidArgumentException(sprintf($this->translator->trans("missing_or_empty_mandatory_parameter: %s"), $parameterList));
  2357.             }
  2359.             header('Content-Type: image/png');
  2360.             $result = $this->meteomaticsWeatherService->getWeatherMap($params['version'], $params['request'], $params['layers'], $params['crs'], $params['bbox'], $params['format'], $params['width'], $params['height'], $params['tiled']);
  2362.             echo $result;
  2363.             exit;
  2364.         }
  2366.         // You can return or process the $data as needed
  2367.         // For demonstration purposes, we will just return a JSON response
  2368.         return $this->json($response);
  2369.     }
  2371.     /**
  2372.      * @Route("/api/public/weather/top-ten-weather-station", methods={"POST"})
  2373.      */
  2374.     public function topTenWeatherStation(Request $request): JsonResponse
  2375.     {
  2376.         try {
  2377.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2378.             if ($response['success'] !== true) {
  2379.                 return $this->json($response);
  2380.             }
  2381.             $params  = json_decode($request->getContent(), true);
  2382.             // $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2383.             $requiredParameters = ['parameter', 'from_date', 'to_date'];
  2384.             foreach ($requiredParameters as $param) {
  2385.                 if (!isset($params[$param])) {
  2386.                     $missingParams[] = $param;
  2387.                 }
  2388.             }
  2389.             if (!empty($missingParams)) {
  2390.                 // Throw an exception with a message that includes the missing parameters
  2391.                 $parameterList = implode(", ", $missingParams);
  2392.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2393.             }
  2394.             $lang = (isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2395.             $result = $this->weatherStationModel->getTopTenWeatherStations($params['parameter'], $params['from_date'], $params['to_date'], $lang);
  2396.             return $this->json($result);
  2397.         } catch (\Exception $ex) {
  2398.             $this->logger->error($ex->getMessage());
  2399.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2400.         }
  2401.     }
  2402.     /**
  2403.      * @Route("/api/public/weather/get-historical-data-parameters", methods={"POST"})
  2404.      */
  2405.     public function getHistoricalDataParameters(Request $request): JsonResponse
  2406.     {
  2407.         try {
  2408.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2409.             if ($response['success'] !== true) {
  2410.                 return $this->json($response);
  2411.             }
  2412.             $data = [];
  2413.             $historicalDataParameters = new HistoricalDataParameters\Listing();
  2414.             foreach ($historicalDataParameters as $key => $historicalDataParameter) {
  2415.                 if ($historicalDataParameter) {
  2416.                     $data[] = [
  2417.                         "id" => $historicalDataParameter->getId(),
  2418.                         "key" => $historicalDataParameter->getParameterKey(),
  2419.                         "unit" => $historicalDataParameter->getUnit('en'),
  2420.                         "unit_ar" => $historicalDataParameter->getUnit('ar'),
  2421.                         "name" => $historicalDataParameter->getName('en'),
  2422.                         "name_ar" => $historicalDataParameter->getName('ar')
  2423.                     ];
  2424.                 }
  2425.             }
  2427.             return $this->json(['success' => true, 'data' => $data]);
  2428.         } catch (\Exception $ex) {
  2429.             $this->logger->error($ex->getMessage());
  2430.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2431.         }
  2432.     }
  2433.     /**
  2434.      * @Route("api/public/weather-data/{start_date}/{end_date}/{resolution}/{parameter}/{coordinate}/{format}", name="api_dynamic_temperature_weather_data", methods={"GET"})
  2435.      */
  2436.     public function getDynamicTemperatureWeatherData(
  2437.         Request $request,
  2438.         string $start_date,
  2439.         string $end_date,
  2440.         string $resolution,
  2441.         string $parameter,
  2442.         string $coordinate,
  2443.         string $format
  2444.     ): Response {
  2445.         try {
  2446.             // Check user authorization
  2447.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2448.             if ($response['success'] !== true) {
  2449.                 return $this->json($response);
  2450.             }
  2451.             $user = $response['user'];
  2453.             // Optional query parameters
  2454.             $queryParams = $request->query->all();
  2455.             // Build Meteomatics-style path
  2456.             // Example: 2025-12-06T00:00:00Z--2025-12-07T00:00:00Z:PT1H/t_2m:C,t_20m:C/.../json
  2457.             $path = sprintf(
  2458.                 "%s--%s:%s/%s/%s",
  2459.                 $start_date,
  2460.                 $end_date,
  2461.                 $resolution,
  2462.                 $parameter,
  2463.                 $coordinate
  2464.             );
  2466.             // Add format at the end
  2467.             $path .= '/' . $format;
  2469.             // Call Meteomatics API service
  2470.             $weatherData = $this->meteomaticApiService->getDynamicWeatherData($path, $queryParams, $user);
  2472.             return $weatherData;
  2473.         } catch (\Exception $ex) {
  2474.             $this->logger->error($ex->getMessage());
  2475.             return $this->json([
  2476.                 'success' => false,
  2477.                 'message' => $this->translator->trans(USER_ERROR_MESSAGE)
  2478.             ]);
  2479.         }
  2480.     }
  2482.     /**
  2483.      * @Route("/api/public/get-alert-type", methods={"POST"})
  2484.      */
  2485.     public function getAlertTypeAction(Request $request): JsonResponse
  2486.     {
  2487.         try {
  2488.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2489.             if ($response['success'] !== true) {
  2490.                 return $this->json($response);
  2491.             }
  2492.             $result = $this->ewsNotificationModel->getAlertTypes();
  2493.             return $this->json($result);
  2494.         } catch (\Exception $ex) {
  2495.             $this->logger->error($ex->getMessage());
  2496.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2497.         }
  2498.     }
  2500.     /**
  2501.      * @Route("/api/public/get-alert-action", methods={"POST"})
  2502.      */
  2503.     public function getAlertActionAction(Request $request): JsonResponse
  2504.     {
  2505.         try {
  2507.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2508.             if ($response['success'] !== true) {
  2509.                 return $this->json($response);
  2510.             }
  2512.             $params = json_decode($request->getContent(), true);
  2513.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2515.             $result = $this->ewsNotificationModel->getAlertActions();
  2517.             return $this->json($result);
  2518.         } catch (\Exception $ex) {
  2519.             $this->logger->error($ex->getMessage());
  2520.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2521.         }
  2522.     }
  2523.     /**
  2524.      * @Route("/api/public/get-phenomena-list-by-alerts", methods={"POST"})
  2525.      */
  2526.     public function getPhenomenaListByAlertsAction(Request $request): JsonResponse
  2527.     {
  2528.         try {
  2529.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2530.             if ($response['success'] !== true) {
  2531.                 return $this->json($response);
  2532.             }
  2533.             $params = json_decode($request->getContent(), true);
  2534.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2536.             if (!isset($params['alert_id']) && !empty($params['alert_id'])) {
  2537.                 throw new \Exception('Missing required alert id');
  2538.             }
  2539.             $alertType = $params['alert_id'];
  2540.             // $result = $this->ewsNotificationModel->getPhenomenaListByAlertIds($alertType);
  2541.             $result = $this->ewsNotificationModel->getAlertStatuses($params);
  2542.             return $this->json($result);
  2543.         } catch (\Exception $ex) {
  2544.             $this->logger->error($ex->getMessage());
  2545.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2546.         }
  2547.     }
  2548.     /**
  2549.      * @Route("/api/public/get-regions-list", methods={"POST"})
  2550.      */
  2551.     public function getRegionsListAction(Request $request): JsonResponse
  2552.     {
  2553.         try {
  2554.             $params = json_decode($request->getContent(), true);
  2555.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2557.             // check user credentials and expiry
  2558.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2559.             if ($response['success'] !== true) {
  2560.                 return $this->json($response);
  2561.             }
  2562.             $search = (isset($params['search']) && !empty($params['search'])) ? $params['search'] : null;
  2563.             $id = (isset($params['id']) && !empty($params['id'])) ? $params['id'] : null;
  2564.             $result = $this->ncmWeatherApiService->getRegionsByName($search, $id, isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2565.             return $this->json($result);
  2566.         } catch (\Exception $ex) {
  2567.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2568.         }
  2569.     }
  2571.     /**
  2572.      * @Route("/api/public/get-governorates-list", methods={"POST"})
  2573.      */
  2574.     public function getGovernoratesListAction(Request $request): JsonResponse
  2575.     {
  2576.         try {
  2578.             $params = json_decode($request->getContent(), true);
  2579.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2581.             // check user credentials and expiry
  2582.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2583.             if ($response['success'] !== true) {
  2584.                 return $this->json($response);
  2585.             }
  2587.             $result = $this->ewsNotificationModel->getGovernoratesByParams($params);
  2589.             return $this->json($result);
  2590.         } catch (\Exception $ex) {
  2591.             $this->logger->error($ex->getMessage());
  2592.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2593.         }
  2594.     }
  2596.     /**
  2597.      * @Route("/api/public/get-municipality-list", methods={"POST"})
  2598.      */
  2599.     public function getMunicipalityListAction(Request $request): JsonResponse
  2600.     {
  2601.         try {
  2602.             $params = json_decode($request->getContent(), true);
  2603.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2605.             // check user credentials and expiry
  2606.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2607.             if ($response['success'] !== true) {
  2608.                 return $this->json($response);
  2609.             }
  2611.             if (!isset($params['governorate_id'])) {
  2612.                 throw new \Exception('Missing required governorate id');
  2613.             }
  2614.             $governorateId = $params['governorate_id'];
  2615.             $search = (isset($params['search']) && !empty($params['search'])) ? $params['search'] : null;
  2616.             $result = $this->ewsNotificationModel->getMunicipalityByParams($governorateId, $search, $params['lang']);
  2618.             return $this->json($result);
  2619.         } catch (\Exception $ex) {
  2620.             $this->logger->error($ex->getMessage());
  2621.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  2622.         }
  2623.     }
  2625.     /**
  2626.      * @Route("/api/public/list-tbase-crops", methods={"POST"})
  2627.      */
  2629.      public function listTbaseCropsAction(Request $request, PaginatorInterface $paginator)
  2630.      {
  2631.          try {
  2632.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2633.             if ($response['success'] !== true) {
  2634.                 return $this->json($response);
  2635.             }
  2636.             $params = json_decode($request->getContent(), true);
  2637.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2638.              $crops = $this->agricultureModel->getTbaseCrops($params, $this->translator, $paginator);
  2639.              return $this->json(['success' => true, 'data' => $crops]);
  2640.          } catch (\Exception $ex) {
  2641.              $this->logger->error($ex->getMessage());
  2642.              return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2643.          }
  2644.     }
  2646.     /**
  2647.      * @Route("/api/public/get-chill-units", methods={"POST"})
  2648.     */
  2649.     public function getChillUnitsAction(Request $request): JsonResponse
  2650.     {
  2651.         try {
  2653.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2654.             if ($response['success'] !== true) {
  2655.                 return $this->json($response);
  2656.             }
  2658.             $params = json_decode($request->getContent(), true);
  2659.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2661.             $isAccumulated = $params['isAccumulated'] ?? false;
  2662.             $latitude = $params['latitude'] ?? null;
  2663.             $longitude = $params['longitude'] ?? null;
  2664.             $coordinate = "$latitude,$longitude";
  2665.             $parametersArray = ['t_min_2m_1h:C', 't_max_2m_1h:C'];
  2666.             $startDate = new DateTime($params['startDate']);
  2667.             $endDate = new DateTime($params['endDate']);
  2668.             
  2669.             $resolution = 'PT1H';
  2670.             $format = 'json';
  2671.             $model = 'mix';
  2672.             $source = '';
  2673.             $onInvalid = '';
  2674.             
  2675.             $response = $this->meteomaticApiService->publicRouteQuery(
  2676.                 $startDate,
  2677.                 $endDate,
  2678.                 $resolution,
  2679.                 $parametersArray,
  2680.                 $coordinate,
  2681.                 $format,
  2682.                 $model,
  2683.                 $source,
  2684.                 $onInvalid,
  2685.             );
  2687.             $hourlyData = $this->chillUnitService->transformMeteomaticsResponse($response['data']);
  2689.             if ($isAccumulated) {
  2690.                 $result = $this->chillUnitService->calculateAccumulated($hourlyData);
  2691.             } else {
  2692.                 $result = $this->chillUnitService->calculate($hourlyData);
  2693.             }
  2695.             return $this->json($result);
  2696.         } catch (\Exception $ex) {
  2697.             $this->logger->error($ex->getMessage());
  2698.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2699.         }
  2700.     }
  2701.     /**
  2702.      * @Route("/api/public/get-water-requirements", methods={"POST"})
  2703.     */
  2704.     public function getWaterRequirementAction(Request $request): JsonResponse
  2705.     {
  2706.         try {
  2707.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2708.             if ($response['success'] !== true) {
  2709.                 return $this->json($response);
  2710.             }
  2712.             $params = json_decode($request->getContent(), true);
  2713.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2715.             $regionIds = [];
  2716.             
  2717.             $latitude = $params['latitude'] ?? null;
  2718.             $longitude = $params['longitude'] ?? null;
  2719.             $coordinate = "$latitude,$longitude";
  2720.             
  2721.             $governorateArr = \App\Lib\Utility::processLocationCoordinates([[$latitude, $longitude]]);
  2722.             foreach ($governorateArr as $governorateName) {
  2723.                 if ($governorateName['en']) {
  2724.                     $governorate = DataObject\Governorate::getByName($governorateName['en'],'en',true);
  2726.                     if ($governorate instanceof DataObject\Governorate) {
  2727.                         // Assuming getRegion() returns a Region DataObject
  2728.                         $region = $governorate->getRegionId();
  2729.                         $regionIds[] = $region->getId();
  2730.                     }
  2731.                 }
  2732.             }
  2734.             $parametersArray = ['evapotranspiration_24h:mm'];
  2735.             $startDate = new DateTime();
  2736.             $endDate = new DateTime();
  2737.             $resolution = 'PT24H';
  2738.             $format = 'json';
  2739.             $model = 'mix';
  2740.             $source = '';
  2741.             $onInvalid = '';
  2742.             $kcKeys = $params['kcKeys'] ?? ['kcInitial', 'kcMid', 'kcEnd'];
  2743.             $cropNames = $params['cropNames'] ?? [];
  2745.             $response = $this->meteomaticApiService->publicRouteQuery(
  2746.                 $startDate,
  2747.                 $endDate,
  2748.                 $resolution,
  2749.                 $parametersArray,
  2750.                 $coordinate,
  2751.                 $format,
  2752.                 $model,
  2753.                 $source,
  2754.                 $onInvalid,
  2755.             );
  2757.             $meteoData = $response['data']['data'][0]['coordinates'];
  2759.             $cropsData = $this->agricultureModel->getCropsWithRegion($regionIds, $cropNames, $kcKeys, $meteoData);
  2761.             return $this->json($cropsData);
  2763.          } catch (\Exception $ex) {
  2764.             $this->logger->error($ex->getMessage());
  2765.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2766.         }
  2767.     }
  2769.     /**
  2770.      * @Route("/api/public/calculate-gdd-and-gts", methods={"POST"})
  2771.      */
  2772.     public function calculateGDDandGTSAction(Request $request): JsonResponse
  2773.     {
  2774.         try {
  2775.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2776.             if ($response['success'] !== true) {
  2777.                 return $this->json($response);
  2778.             }
  2780.             $params = json_decode($request->getContent(), true);
  2781.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2783.             $params = json_decode($request->getContent(), true);
  2784.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2786.             $requiredParameters = [
  2787.                 'coordinates',
  2788.                 'cropIds',
  2789.                 'startDate',
  2790.                 'endDate'
  2791.             ];
  2793.          
  2794.             foreach ($requiredParameters as $param) {
  2795.                 if (!isset($params[$param])) {
  2796.                     $missingParams[] = $param;
  2797.                 }
  2798.             }
  2799.             if (!empty($missingParams)) {
  2800.                 // Throw an exception with a message that includes the missing parameters
  2801.                 $parameterList = implode(", ", $missingParams);
  2802.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2803.             }
  2804.             $params['meteomaticApiService'] = $this->meteomaticApiService;
  2805.             $gddAndGtsData = $this->agricultureModel->calculateGDDandGTS($params,$this->translator);
  2807.             return $this->json($gddAndGtsData);
  2809.         } catch (\Exception $ex) {
  2810.             $this->logger->error($ex->getMessage());
  2811.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2812.         }
  2813.     }
  2814.     /**
  2815.      * @Route("/api/public/crops", methods={"POST"})
  2816.      */
  2817.     public function cropsAction(Request $request): JsonResponse
  2818.     {
  2819.         try {
  2820.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2821.             if ($response['success'] !== true) {
  2822.                 return $this->json($response);
  2823.             }
  2825.             $params = json_decode($request->getContent(), true);
  2826.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2828.             $result = $this->agricultureModel->getCrops($request, $params, $this->translator);
  2829.             return $this->json($result);
  2830.         } catch (\Exception $ex) {
  2831.             $this->logger->error($ex->getMessage());
  2832.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2833.         }
  2834.     }
  2835.     /**
  2836.      * @Route("/api/public/list-location", methods={"POST"})
  2837.      */
  2838.     public function listLocation(Request $request, PaginatorInterface $paginator): JsonResponse
  2839.     {
  2840.         try {
  2841.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2842.             if ($response['success'] !== true) {
  2843.                 return $this->json($response);
  2844.             }
  2846.             $applicationName = $request->headers->get('X-App-Name');
  2847.             $applicationConsumer = $request->headers->get('X-App-Consumer-Key');
  2849.             if (!$applicationName || !$applicationConsumer) {
  2850.                 return $this->json(['success' => false,'message' => 'Missing required headers']);
  2851.             }
  2853.             $user = DataObject\Customer::getByEmail($applicationName, true);
  2854.             if (!$user) {
  2855.                 return $this->json([
  2856.                     'success' => false,
  2857.                     'message' => 'Invalid User'
  2858.                 ]);
  2859.             }
  2861.             $application = DataObject\WSO2Applications::getByUser($user, true);
  2862.             if (!$application) {
  2863.                 return $this->json([
  2864.                     'success' => false,
  2865.                     'message' => 'User not found'
  2866.                 ]);
  2867.             }
  2869.             // 5. Consumer key validation
  2870.             if ($application->getConsumerKey() !== $applicationConsumer) {
  2871.                 return $this->json([
  2872.                     'success' => false,
  2873.                     'message' => 'Invalid Consumer Key'
  2874.                 ]);
  2875.             }
  2877.             $params = json_decode($request->getContent(), true);
  2878.             $this->translator->setlocale($params['lang'] ?? DEFAULT_LOCALE);
  2880.             $result = $this->locationModel->locationListing(
  2881.                 $request,
  2882.                 $user,
  2883.                 $params,
  2884.                 $paginator,
  2885.                 $this->translator
  2886.             );
  2888.             return $this->json($result);
  2890.         } catch (\Exception $ex) {
  2891.             $this->logger->error($ex->getMessage());
  2893.             return $this->json([
  2894.                 'success' => false,
  2895.                 'message' => $ex->getMessage()
  2896.             ]);
  2897.         }
  2898.     }
  2899.     /**
  2900.      * @Route("/api/public/list-risk-category", methods={"POST"})
  2901.      */
  2902.     public function getRiskCategories(Request $request, PaginatorInterface $paginator)
  2903.     {
  2904.        try {
  2905.            $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2906.            if ($response['success'] !== true) {
  2907.                return $this->json($response);
  2908.            }
  2909.            $applicationName = $request->headers->get('X-App-Name');
  2910.            $applicationConsumer = $request->headers->get('X-App-Consumer-Key');
  2912.            if (!$applicationName || !$applicationConsumer) {
  2913.                return $this->json(['success' => false,'message' => 'Missing required headers']);
  2914.            }
  2916.            $user = DataObject\Customer::getByEmail($applicationName, true);
  2917.            if (!$user) {
  2918.                return $this->json([
  2919.                    'success' => false,
  2920.                    'message' => 'Invalid User'
  2921.                ]);
  2922.            }
  2924.            $application = DataObject\WSO2Applications::getByUser($user, true);
  2925.            if (!$application) {
  2926.                return $this->json([
  2927.                    'success' => false,
  2928.                    'message' => 'User not found'
  2929.                ]);
  2930.            }
  2932.            // 5. Consumer key validation
  2933.            if ($application->getConsumerKey() !== $applicationConsumer) {
  2934.                return $this->json([
  2935.                    'success' => false,
  2936.                    'message' => 'Invalid Consumer Key'
  2937.                ]);
  2938.            }
  2939.            $params = json_decode($request->getContent(), true);
  2940.            $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  2941.     
  2942.            $requiredParameters = [];
  2943.            foreach ($requiredParameters as $param) {
  2944.                if (!isset($params[$param])) {
  2945.                    $missingParams[] = $param;
  2946.                }
  2947.            }
  2949.            if (!empty($missingParams)) {
  2950.                // Throw an exception with a message that includes the missing parameters
  2951.                $parameterList = implode(", ", $missingParams);
  2952.                return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  2953.            }
  2954.            
  2955.            $result = $this->weatherParameterModel->riskCategoryFetch($params, $paginator, $user);
  2957.            return $this->json($result); 
  2959.        } catch (\Exception $ex) {
  2960.            $this->logger->error($ex->getMessage());
  2961.            return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  2962.        }
  2963.     }
  2964.     /**
  2965.      * @Route("/api/public/locations-for-map", methods={"POST"})
  2966.      */
  2967.     public function getLocationsForMaps(Request $request): JsonResponse
  2968.     {
  2969.        try {
  2970.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  2971.             if ($response['success'] !== true) {
  2972.                 return $this->json($response);
  2973.             }
  2974.             $applicationName = $request->headers->get('X-App-Name');
  2975.             $applicationConsumer = $request->headers->get('X-App-Consumer-Key');
  2976.  
  2977.             if (!$applicationName || !$applicationConsumer) {
  2978.                 return $this->json(['success' => false,'message' => 'Missing required headers']);
  2979.             }
  2980.  
  2981.             $user = DataObject\Customer::getByEmail($applicationName, true);
  2982.             if (!$user) {
  2983.                 return $this->json([
  2984.                     'success' => false,
  2985.                     'message' => 'Invalid User'
  2986.                 ]);
  2987.             }
  2988.  
  2989.             $application = DataObject\WSO2Applications::getByUser($user, true);
  2990.             if (!$application) {
  2991.                 return $this->json([
  2992.                     'success' => false,
  2993.                     'message' => 'User not found'
  2994.                 ]);
  2995.             }
  2996.  
  2997.             // 5. Consumer key validation
  2998.             if ($application->getConsumerKey() !== $applicationConsumer) {
  2999.                 return $this->json([
  3000.                     'success' => false,
  3001.                     'message' => 'Invalid Consumer Key'
  3002.                 ]);
  3003.             }
  3005.             $params = json_decode($request->getContent(), true);
  3006.             $parameter = $params['parameter'] ?? null;
  3007.             $duration = $params['duration'] ?? null;
  3008.             $dateTime = $params['datetime'] ?? null;
  3009.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  3011.             if (!$parameter || !$duration || !$dateTime) {
  3012.                 return new JsonResponse(['success' => false, 'message' => $this->translator->trans('missing_parameter_or_duration_or_date')], 400);
  3013.             }
  3015.             $results = $this->weatherParameterModel->getLocationsForMaps($params, $parameter, $duration, $dateTime, $user, $this->translator);
  3017.            return $this->json(['success' => true, 'data' => $results]); 
  3019.        } catch (\Exception $ex) {
  3020.            $this->logger->error($ex->getMessage());
  3021.            return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  3022.        }
  3023.     }
  3024.     /**
  3025.      * @Route("/api/public/locations-by-dates", methods={"POST"})
  3026.      */
  3027.     public function getLocationsByDates(Request $request): JsonResponse
  3028.     {
  3029.        try {
  3030.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  3031.             if ($response['success'] !== true) {
  3032.                 return $this->json($response);
  3033.             }
  3034.             $applicationName = $request->headers->get('X-App-Name');
  3035.             $applicationConsumer = $request->headers->get('X-App-Consumer-Key');
  3036.  
  3037.             if (!$applicationName || !$applicationConsumer) {
  3038.                 return $this->json(['success' => false,'message' => 'Missing required headers']);
  3039.             }
  3040.  
  3041.             $user = DataObject\Customer::getByEmail($applicationName, true);
  3042.             if (!$user) {
  3043.                 return $this->json([
  3044.                     'success' => false,
  3045.                     'message' => 'Invalid User'
  3046.                 ]);
  3047.             }
  3048.  
  3049.             $application = DataObject\WSO2Applications::getByUser($user, true);
  3050.             if (!$application) {
  3051.                 return $this->json([
  3052.                     'success' => false,
  3053.                     'message' => 'User not found'
  3054.                 ]);
  3055.             }
  3056.  
  3057.             // 5. Consumer key validation
  3058.             if ($application->getConsumerKey() !== $applicationConsumer) {
  3059.                 return $this->json([
  3060.                     'success' => false,
  3061.                     'message' => 'Invalid Consumer Key'
  3062.                 ]);
  3063.             }
  3064.             $params = json_decode($request->getContent(), true);
  3065.             $parameter = $params['parameter'] ?? null;
  3066.             $duration = $params['duration'] ?? null;
  3067.             $dateTime = $params['datetime'] ?? null;
  3068.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  3070.             if (!$parameter || !$duration || !$dateTime) {
  3071.                 return new JsonResponse(['success' => false, 'message' => $this->translator->trans('missing_parameter_or_duration_or_date')], 400);
  3072.             }
  3074.            $results = $this->weatherParameterModel->getLocationsbyDates($parameter, $duration, $dateTime, $this->translator);
  3076.            return $this->json(['success' => true, "lastUpdated" => $results['last_updated_at'], 'data' => $results['data']]); 
  3078.        } catch (\Exception $ex) {
  3079.            $this->logger->error($ex->getMessage());
  3080.            return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  3081.        }
  3082.     }
  3083.     /**
  3084.      * @Route("/api/public/locations-by-tags", methods={"POST"})
  3085.      */
  3086.     public function getLocationsByTags(Request $request): JsonResponse
  3087.     {
  3088.        try {
  3089.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  3090.             if ($response['success'] !== true) {
  3091.                 return $this->json($response);
  3092.             }
  3093.             $applicationName = $request->headers->get('X-App-Name');
  3094.             $applicationConsumer = $request->headers->get('X-App-Consumer-Key');
  3096.             if (!$applicationName || !$applicationConsumer) {
  3097.                 return $this->json(['success' => false,'message' => 'Missing required headers']);
  3098.             }
  3100.             $user = DataObject\Customer::getByEmail($applicationName, true);
  3101.             if (!$user) {
  3102.                 return $this->json([
  3103.                     'success' => false,
  3104.                     'message' => 'Invalid User'
  3105.                 ]);
  3106.             }
  3108.             $application = DataObject\WSO2Applications::getByUser($user, true);
  3109.             if (!$application) {
  3110.                 return $this->json([
  3111.                     'success' => false,
  3112.                     'message' => 'User not found'
  3113.                 ]);
  3114.             }
  3116.             // 5. Consumer key validation
  3117.             if ($application->getConsumerKey() !== $applicationConsumer) {
  3118.                 return $this->json([
  3119.                     'success' => false,
  3120.                     'message' => 'Invalid Consumer Key'
  3121.                 ]);
  3122.             }
  3124.             $params = json_decode($request->getContent(), true);
  3125.             $parameter = $params['parameter'] ?? null;
  3126.             $duration = $params['duration'] ?? null;
  3127.             $dateTime = $params['datetime'] ?? null;
  3128.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  3130.             if (!$parameter || !$duration || !$dateTime) {
  3131.                 return $this->json(['success' => false, 'message' => $this->translator->trans('missing_parameter_or_duration_or_date')], 400);
  3132.             }
  3134.             $tags = [];
  3135.             $tagListing = new WeatherParameterLocationTags\Listing();
  3136.             $tagListing->setCondition("`default` = ?", [true]);
  3138.             foreach ($tagListing as $tag) {
  3139.                 $tags[] = [
  3140.                     'id' => $tag->getId(),
  3141.                     'nameEn' => $tag->getNameEn(),
  3142.                     'nameAr' => $tag->getNameAr(),
  3143.                 ];
  3144.             }
  3146.             $desiredOrder = ['High risk', 'Medium risk', 'Low risk'];
  3148.             usort($tags, function ($a, $b) use ($desiredOrder) {
  3149.                 $posA = array_search($a['nameEn'], $desiredOrder);
  3150.                 $posB = array_search($b['nameEn'], $desiredOrder);
  3151.                 return $posA <=> $posB;
  3152.             });
  3154.             $results = $this->weatherParameterModel->getLocationsByTags($parameter, $duration, $dateTime, $tags, $this->translator);
  3156.            return $this->json(['success' => true, 'data' => $results]); 
  3158.        } catch (\Exception $ex) {
  3159.            $this->logger->error($ex->getMessage());
  3160.            return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  3161.        }
  3162.     }
  3163.     /**
  3164.      * @Route("/api/public/locations-by-risk", methods={"POST"})
  3165.      */
  3166.     public function getLocationsByRisk(Request $request): JsonResponse
  3167.     {
  3168.        try {
  3169.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  3170.             if ($response['success'] !== true) {
  3171.                 return $this->json($response);
  3172.             }
  3173.             $applicationName = $request->headers->get('X-App-Name');
  3174.             $applicationConsumer = $request->headers->get('X-App-Consumer-Key');
  3176.             if (!$applicationName || !$applicationConsumer) {
  3177.                 return $this->json(['success' => false,'message' => 'Missing required headers']);
  3178.             }
  3180.             $user = DataObject\Customer::getByEmail($applicationName, true);
  3181.             if (!$user) {
  3182.                 return $this->json([
  3183.                     'success' => false,
  3184.                     'message' => 'Invalid User'
  3185.                 ]);
  3186.             }
  3188.             $application = DataObject\WSO2Applications::getByUser($user, true);
  3189.             if (!$application) {
  3190.                 return $this->json([
  3191.                     'success' => false,
  3192.                     'message' => 'User not found'
  3193.                 ]);
  3194.             }
  3196.             // 5. Consumer key validation
  3197.             if ($application->getConsumerKey() !== $applicationConsumer) {
  3198.                 return $this->json([
  3199.                     'success' => false,
  3200.                     'message' => 'Invalid Consumer Key'
  3201.                 ]);
  3202.             }
  3204.             $params = json_decode($request->getContent(), true);
  3205.             $parameter = $params['parameter'] ?? null;
  3206.             $duration = $params['duration'] ?? null;
  3207.             $dateTime = $params['datetime'] ?? null;
  3208.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  3210.             if (!$parameter || !$duration || !$dateTime) {
  3211.                 return $this->json(['success' => false, 'message' => $this->translator->trans('missing_parameter_or_duration_or_date')], 400);
  3212.             }
  3214.             $results = $this->weatherParameterModel->getLocationsByRiskCat($params, $parameter, $duration, $dateTime, $user, $this->translator);
  3216.            return $this->json(['success' => true, 'data' => $results]); 
  3218.        } catch (\Exception $ex) {
  3219.            $this->logger->error($ex->getMessage());
  3220.            return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  3221.        }
  3222.     }
  3224.     /**
  3225.      * @Route("/api/public/locations-by-amana", methods={"POST"})
  3226.      */
  3227.     public function getLocationsByAmana(Request $request): JsonResponse
  3228.     {
  3229.        try {
  3230.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  3231.             if ($response['success'] !== true) {
  3232.                 return $this->json($response);
  3233.             }
  3234.             $applicationName = $request->headers->get('X-App-Name');
  3235.             $applicationConsumer = $request->headers->get('X-App-Consumer-Key');
  3237.             if (!$applicationName || !$applicationConsumer) {
  3238.                 return $this->json(['success' => false,'message' => 'Missing required headers']);
  3239.             }
  3241.             $user = DataObject\Customer::getByEmail($applicationName, true);
  3242.             if (!$user) {
  3243.                 return $this->json([
  3244.                     'success' => false,
  3245.                     'message' => 'Invalid User'
  3246.                 ]);
  3247.             }
  3249.             $application = DataObject\WSO2Applications::getByUser($user, true);
  3250.             if (!$application) {
  3251.                 return $this->json([
  3252.                     'success' => false,
  3253.                     'message' => 'User not found'
  3254.                 ]);
  3255.             }
  3257.             // 5. Consumer key validation
  3258.             if ($application->getConsumerKey() !== $applicationConsumer) {
  3259.                 return $this->json([
  3260.                     'success' => false,
  3261.                     'message' => 'Invalid Consumer Key'
  3262.                 ]);
  3263.             }
  3265.             $params = json_decode($request->getContent(), true);
  3266.             $parameter = $params['parameter'] ?? null;
  3267.             $duration = $params['duration'] ?? null;
  3268.             $dateTime = $params['datetime'] ?? null;
  3269.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  3271.             if (!$parameter || !$duration || !$dateTime) {
  3272.                 return new JsonResponse(['success' => false, 'message' => $this->translator->trans('missing_parameter_or_duration_or_date')], 400);
  3273.             }
  3275.             $results = $this->weatherParameterModel->getLocationsByAmanaId($params, $parameter, $duration, $dateTime, $this->translator);
  3277.            return $this->json(['success' => true, 'data' => $results]); 
  3279.        } catch (\Exception $ex) {
  3280.            $this->logger->error($ex->getMessage());
  3281.            return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  3282.        }
  3283.     }
  3284. }