src/Controller/PublicApiController.php line 685

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use Carbon\Carbon;
  6. use Knp\Snappy\Pdf;
  7. use Knp\Snappy\Image;
  8. use Pimcore\Model\Asset;
  9. use App\Service\RedisCache;
  10. use App\Model\ReportLogModel;
  11. use App\Service\EmailService;
  12. use App\Service\ReportService;
  13. use DateTime;
  14. use Pimcore\Log\ApplicationLogger;
  15. use App\Model\EwsNotificationModel;
  16. use App\Service\NotificationService;
  17. use Pimcore\Model\DataObject\Report;
  18. use App\Service\MeteomaticApiService;
  19. use App\Model\WeatherForecastCityModel;
  20. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  21. use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
  22. use App\Service\CustomNotificationService;
  23. use App\Service\MeteomaticsWeatherService;
  24. use Pimcore\Controller\FrontendController;
  25. use Knp\Component\Pager\PaginatorInterface;
  26. use App\Service\PublicUserPermissionService;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Symfony\Component\HttpFoundation\Response;
  29. use Symfony\Component\Routing\Annotation\Route;
  30. use Pimcore\Model\DataObject\ReportWeatherSymbols;
  31. use Symfony\Component\HttpFoundation\JsonResponse;
  32. use Symfony\Contracts\Translation\TranslatorInterface;
  33. use Symfony\Component\Security\Core\User\UserInterface;
  34. use Lexik\Bundle\JWTAuthenticationBundle\Services\JWTTokenManagerInterface;
  35. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  37. class PublicApiController extends FrontendController
  38. {
  39.     private $ewsNotificationModel;
  40.     private $reportModel;
  41.     public function __construct(
  42.         private TokenStorageInterface $tokenStorageInterface,
  43.         private JWTTokenManagerInterface $jwtManager,
  44.         private PublicUserPermissionService $publicUserPermissionService,
  45.         protected TranslatorInterface $translator,
  46.         private ApplicationLogger $logger,
  47.         private MeteomaticApiService $meteomaticApiService,
  48.         private \Doctrine\DBAL\Connection $connection,
  49.         private RedisCache $redisCache,
  50.         private MeteomaticsWeatherService $meteomaticsWeatherService,
  51.         private Pdf $snappy,
  52.         private CustomNotificationService $customNotificationService,
  53.         private ReportService $reportService,
  54.         private NotificationService $notificationService,
  55.         private Image $snappyImage,
  56.         private EmailService $emailService
  57.     ) {
  58.        // header('Content-Type: application/json; charset=UTF-8');
  59.        // header("Access-Control-Allow-Origin: *");
  60.         $this->meteomaticApiService = $meteomaticApiService;
  61.         $this->publicUserPermissionService = $publicUserPermissionService;
  62.         $this->ewsNotificationModel = new EwsNotificationModel();
  63.         $this->reportModel = new ReportLogModel();
  64.     }
  66.     /**
  67.      * @Route("/api/public/{startdate}/{enddate}/{resolution}/{parameter}/{coordinate}/{format}", name="api_public_route_query", methods={"GET"})
  68.      */
  69.     public function publicRouteQueryData(Request $request): JsonResponse
  70.     {
  71.         try {
  72.             // check user credentials and expiry
  73.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  74.             if ($response['success'] !== true) {
  75.                 return $this->json($response);
  76.             }
  78.             $startDate = $request->get('startdate');
  79.             $endDate = $request->get('enddate');
  80.             $resolution = $request->get('resolution');
  81.             $parameter = $request->get('parameter');
  82.             $coordinate = $request->get('coordinate');
  83.             $format = $request->get('format');
  85.             // Optional Parameter
  86.             $source = $request->get('source');
  87.             $onInvalid = $request->get('on_invalid');
  88.             $model = $request->get('model');
  90.             if (!$startDate) {
  91.                 throw new \InvalidArgumentException("Missing mandatory parameter: start date");
  92.             }
  93.             if (!$endDate) {
  94.                 throw new \InvalidArgumentException("Missing mandatory parameter: end date");
  95.             }
  96.             if (!$resolution) {
  97.                 throw new \InvalidArgumentException("Missing mandatory parameter: resolution");
  98.             }
  99.             if (!$parameter) {
  100.                 throw new \InvalidArgumentException("Missing mandatory parameter: parameters");
  101.             }
  102.             if (!$coordinate) {
  103.                 throw new \InvalidArgumentException("Missing mandatory parameter: coordinate");
  104.             }
  105.             if (!$format) {
  106.                 throw new \InvalidArgumentException("Missing mandatory parameter: format");
  107.             }
  108.             $startDate = new DateTime($startDate);
  109.             $endDate = new DateTime($endDate);
  110.             $user = $response['user'];
  111.             $parametersArray = explode(',', $parameter);
  112.             // Varify user allowed permissions
  113.             // $reslult = $this->publicUserPermissionService->publicUserPermissionCheck($user, $parametersArray, $this->translator);
  114.             // if ($reslult['success'] !== true) {
  115.             //     return $this->json($reslult);
  116.             // }
  117.             $response = $this->meteomaticApiService->publicRouteQuery(
  118.                 $startDate,
  119.                 $endDate,
  120.                 $resolution,
  121.                 $parametersArray,
  122.                 $coordinate,
  123.                 $format,
  124.                 $model,
  125.                 $source,
  126.                 $onInvalid
  127.             );
  128.             // For demonstration purposes, we will just return a JSON response
  129.             return $this->json($response);
  130.         } catch (\Exception $ex) {
  131.             $this->logger->error($ex->getMessage());
  132.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  133.         }
  134.     }
  136.     /**
  137.      * @Route("/api/public/get-report-detail", name="public_get_report_detail")
  138.      */
  139.     public function getReportDetails(Request $request)
  140.     {
  141.         try {
  142.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  143.             if ($response['success'] !== true) {
  144.                 return $this->json($response);
  145.             }
  146.             $user = $response['user'];
  147.             // $params = json_decode($request->getContent(), true);
  148.             $requestUri = $request->getRequestUri();
  150.             // Extract the last segment from the URL
  151.             $segments = explode('/', trim($requestUri, '/'));
  152.             $action = end($segments);
  153.             $action = str_replace("-", "_", $action);
  154.             $params[] = $action;
  155.             // $reslult = $this->publicUserPermissionService->publicUserPermissionCheck($user, $params, $this->translator);
  156.             // if ($reslult['success'] !== true) {
  157.             //     return $this->json($reslult);
  158.             // }
  159.             $latestReport = Report::getList([
  160.                 "limit" => 1,
  161.                 "orderKey" => "createdOn",
  162.                 "order" => "desc"
  163.             ]);
  164.             if ($latestReport->getCount() <= 0) {
  165.                 throw new \Exception('no_latest_report_found');
  166.             } else {
  167.                 $data = [];
  168.                 foreach ($latestReport as $report) {
  169.                     $data = [
  170.                         'name' => $report->getCreatedBy()?->getName(),
  171.                         'email' => $report->getCreatedBy()?->getEmail(),
  172.                         'jsonData' => json_decode($report->getJsonData(), true),
  173.                         'createdOn' => $report->getCreatedOn()
  174.                     ];
  175.                 }
  177.                 return $this->json(['success' => true, 'data' => $data]);
  178.             }
  179.         } catch (\Exception $ex) {
  180.             $this->logger->error($ex->getMessage());
  181.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  182.         }
  183.     }
  185.     /**
  186.      * @Route("/api/public/ews-analytics", methods={"POST"})
  187.      */
  188.     public function ewsAnalyticsAction(Request $request): JsonResponse
  189.     {
  190.         try {
  191.             $params = json_decode($request->getContent(), true);
  192.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  194.             $lang = ($request->headers->has('lang')) ? $request->headers->get('lang') : "en";
  195.             $result = $this->ewsNotificationModel->ewsAnalytics($params, $this->connection, $lang);
  196.             return $this->json($result);
  197.         } catch (\Exception $ex) {
  198.             $this->logger->error($ex->getMessage());
  199.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  200.         }
  201.     }
  203.     /**
  204.      * @Route("/api/public/generate-report", methods={"POST"})
  205.      */
  206.     public function generateReport(Request $request): JsonResponse
  207.     {
  208.         try {
  209.             $response = [];
  210.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  211.             if ($permissions['success'] !== true) {
  212.                 return $this->json($permissions);
  213.             }
  215.             $params = json_decode($request->getContent(), true);
  216.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  219.             if (
  220.                 !isset($params['from_date']) ||
  221.                 !isset($params['to_date']) ||
  222.                 !isset($params['hours']) ||
  223.                 !isset($params['parameters'])  ||
  224.                 !isset($params['locations'])
  225.             ) {
  226.                 throw new \Exception('Missing required parameters');
  227.             }
  228.             if (empty($params['parameters'] || !is_array($params['parameters']))) {
  229.                 throw new \Exception('Parameters should be non empty array');
  230.             }
  232.             if (empty($params['locations'] || !is_array($params['locations']))) {
  233.                 throw new \Exception('Locations should be non empty array');
  234.             }
  235.             $model = isset($params['model']) ? $params['model'] : 'mix';
  236.             $redisKey = md5('generate_city_report-' . $params['from_date'] . '-' . $params['to_date'] . '-' . $params['hours'] . '-' . implode('_', $params['locations'])) . '-' . implode('_', $params['parameters']) . '-' . $model;
  237.             $data = $this->redisCache->get($redisKey);
  238.             if (!$data) {
  239.                 $cities = new \Pimcore\Model\DataObject\City\Listing();
  240.                 if (!empty($params['locations'])) {
  241.                     $cities->setCondition('o_id IN (?)', [$params['locations']]);
  242.                 }
  243.                 $cities->load();
  244.                 if ($cities->getCount() > 0) {
  245.                     $params['coordinates'] = []; // Initialize an empty array for coordinates
  246.                     $result = [];
  247.                     $citiesArr = [];
  248.                     foreach ($cities as $city) {
  250.                         $params['coordinates'][] = [$city->getLatitude(), $city->getLongitude()];
  251.                         // Append the coordinates for each city
  252.                         $long = number_format($city->getLongitude(), 6, '.', '');
  253.                         $lat = number_format($city->getLatitude(), 6, '.', '');
  254.                         $citiesArr[$lat . '|' . $long]["en"] =  $city->getCityName("en");
  255.                         $citiesArr[$lat . '|' . $long]["ar"] =  $city->getCityName("ar");
  256.                     }
  258.                     $result = $this->meteomaticsWeatherService->getReportForecastData($params['coordinates'], $params['from_date'], $params['to_date'], $params['hours'], $model, $params['parameters'], $this->translator, $citiesArr, $params);
  260.                     $response[] = $result;
  261.                     $jsonResponse = ['success' => true, 'data' => $response];
  262.                     $this->redisCache->set($redisKey, $jsonResponse, REDIS_CACHE_TIME);
  263.                     return $this->json($jsonResponse);
  264.                 } else {
  265.                     return $this->json(['success' => true, 'message' => $this->translator->trans('no_city_found')]);
  266.                 }
  267.             } else {
  268.                 return $this->json($data);
  269.             }
  270.         } catch (\Exception $ex) {
  271.             $this->logger->error($ex->getMessage());
  272.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  273.         }
  274.     }
  276.     /**
  277.      * @Route("/api/public/update-report", methods={"POST"})
  278.      */
  279.     public function updateReport(Request $request)
  280.     {
  281.         try {
  282.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  283.             if ($permissions['success'] !== true) {
  284.                 return $this->json($permissions);
  285.             }
  286.             $user = $permissions['user'];
  287.             $params  = json_decode($request->getContent(), true);
  288.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  290.             // Perform parameter validation here
  291.             // || !isset($params['locations'])
  292.             if (!isset($params['data'])  || !isset($params['start_date']) || !isset($params['end_date']) || !isset($params['lang'])) {
  293.                 return $this->json(['success' => false, 'message' =>  $this->translator->trans('missing_required_parameters')]);
  294.             }
  295.             if (isset($params['organizations'])) {
  296.                 if (!is_array($params['organizations'])) {
  297.                     throw new \Exception($this->translator->trans('Organizations should be non empty array'), 400);
  298.                 }
  299.             }
  300.             if (isset($params['channels'])) {
  301.                 if (!is_array($params['channels']) || empty($params['channels'])) {
  302.                     throw new \Exception($this->translator->trans('Channels should be non empty array'), 400);
  303.                 }
  304.                 if (in_array('email', $params['channels'])) {
  305.                     if (!isset($params['emails']) || !is_array($params['emails']) || empty($params['emails'])) {
  306.                         throw new \Exception($this->translator->trans('Emails should be non empty array'), 400);
  307.                     }
  308.                 }
  309.             }
  310.             $result = $this->reportModel->editReport($user, $params, $this->translator, $this->logger);
  311.             return $this->json($result);
  312.         } catch (\Exception $ex) {
  313.             $this->logger->error($ex->getMessage());
  314.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  315.         }
  316.     }
  318.     /**
  319.      * @Route("/api/public/get-city-list", name="public-city-listing")
  320.      */
  321.     public function getCityListAction(Request $request)
  322.     {
  323.         try {
  324.             $result = [];
  325.             $lang = ($request->headers->has('lang')) ? $request->headers->get('lang') : "en";
  327.             $params  = json_decode($request->getContent(), true);
  328.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  330.             $reportTypeId = $params['report_type_id'] ?? null;
  331.             $cities = new \Pimcore\Model\DataObject\City\Listing();
  332.             if ($reportTypeId) {
  333.                 $cities->setCondition("reportType REGEXP CONCAT('(^|,)', REPLACE('" . $reportTypeId . "', ',', '|'), '(,|$)')");
  334.             } else {
  335.                 $db = \Pimcore\Db::get();
  336.                 $selectedLocalities = $db->fetchAllAssociative("SELECT oo_id  FROM `object_query_ReportType` WHERE (`isAutomaticReport` = 0)");
  337.                 $ooIds = array_column($selectedLocalities, 'oo_id');
  338.                 $cities->setCondition("reportType REGEXP CONCAT('(^|,)', REPLACE('" . implode(',', $ooIds) . "', ',', '|'), '(,|$)')");
  339.             }
  340.             $cities->load();
  341.             if ($cities->getCount() > 0) {
  342.                 foreach ($cities as $city) {
  343.                     $result[] = [
  344.                         "id" => $city->getId(),
  345.                         "name" => $city->getCityName($lang),
  346.                         "nameEn" => $city->getCityName('en'),
  347.                         "nameAr" => $city->getCityName('ar'),
  348.                         "lat" => $city->getLatitude(),
  349.                         "long" => $city->getLongitude(),
  350.                         "googlePlaceName" => $city->getGooglePlaceName(),
  351.                     ];
  352.                 }
  353.                 return $this->json(["success" => true, "data" => $result]);
  354.             }
  355.             return $this->json(["success" => false, "message" => $this->translator->trans("no_city_is_available")]);
  356.         } catch (\Exception $ex) {
  357.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  358.         }
  359.     }
  361.     /**
  362.      * @Route("/api/public/list-report", name="public-report-listing")
  363.      */
  364.     public function getReportListAction(Request $request, PaginatorInterface $paginator)
  365.     {
  366.         try {
  367.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  368.             if ($permissions['success'] !== true) {
  369.                 return $this->json($permissions);
  370.             }
  371.             $user = $permissions['user'];
  372.             $params  = json_decode($request->getContent(), true);
  373.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  375.             if (!isset($params['page']) || !isset($params['limit'])) {
  376.                 throw new \Exception('Missing required params: page or limit');
  377.             }
  378.             $report_type = isset($params['report_type']) ? $params['report_type'] : null;
  379.             $lang = isset($params['lang']) ? $params['lang'] : DEFAULT_LOCALE;
  380.             $isPublicReports = isset($params['publicReports']) ? $params['publicReports'] : false; // sending this flag from public portal to get all reports accordong to our needs
  381.             $page = $params['page'];
  382.             $limit = $params['limit'];
  383.             $result = $this->reportModel->reportList($params, $page, $limit, $this->translator, $paginator, $report_type, $user, $lang, $isPublicReports);
  385.             return $this->json($result);
  386.         } catch (\Exception $ex) {
  387.             $this->logger->error($ex->getMessage());
  388.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  389.         }
  390.     }
  392.     /**
  393.      * @Route("/api/public/generate-report-pdf", name="public-report-pdf")
  394.      */
  395.     public function generateReportPdf(Request $request)
  396.     {
  397.         try {
  398.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  399.             if ($permissions['success'] !== true) {
  400.                 return $this->json($permissions);
  401.             }
  402.             $user = $permissions['user'];
  404.             $params  = json_decode($request->getContent(), true);
  405.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  407.             return $this->getPdfReport($request, $user, 'pdf/report_pdf_template.html.twig', $this->translator, '_manned_forecast_report.pdf');
  408.         } catch (\Exception $ex) {
  409.             $this->logger->error($ex->getMessage());
  410.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  411.         }
  412.     }
  414.     /**
  415.      * @Route("/api/public/get-report-types", name="public-report-types-listing")
  416.      */
  417.     public function getReportTypes(Request $request)
  418.     {
  419.         try {
  421.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  422.             if ($permissions['success'] !== true) {
  423.                 return $this->json($permissions);
  424.             }
  426.             $params  = json_decode($request->getContent(), true);
  427.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  429.             if (!isset($params['automatic'])) {
  430.                 throw new \Exception('missing_required_parameters');
  431.             }
  432.             $result = [];
  433.             $automatic = $params['automatic'] ? true : false;
  434.             $reportTypes = new \Pimcore\Model\DataObject\ReportType\Listing();
  435.             $reportTypes->setCondition('isAutomaticReport = ?', [$automatic]);
  436.             $reportTypes->load();
  438.             if ($reportTypes->getCount() > 0) {
  439.                 foreach ($reportTypes as $reportType) {
  440.                     $result[] = [
  441.                         "id" => $reportType->getId(),
  442.                         "key" => $reportType->getReportKey(),
  443.                         "nameEn" => $reportType->getName('en'),
  444.                         "nameAr" => $reportType->getName('ar'),
  445.                         "descriptionEn" => $reportType->getDescription('en'),
  446.                         "descriptionAr" => $reportType->getDescription('ar'),
  447.                         "titleEn" => $reportType->getTitle('en'),
  448.                         "titleAr" => $reportType->getTitle('ar'),
  449.                         "automatic" => $reportType->getIsAutomaticReport()
  450.                     ];
  451.                 }
  452.                 return $this->json(["success" => true, "data" => $result]);
  453.             }
  454.             return $this->json(["success" => false, "message" => $this->translator->trans("no_reportType_is_available")]);
  455.         } catch (\Exception $ex) {
  456.             $this->logger->error($ex->getMessage());
  457.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  458.         }
  459.     }
  461.     /**
  462.      * @Route("/api/public/get-weather-params-list", name="public-weather-params-listing")
  463.      */
  464.     public function getWeatherParamsListAction(Request $request)
  465.     {
  466.         try {
  467.             $result = [];
  468.             $lang = ($request->headers->has('lang')) ? $request->headers->get('lang') : "en";
  470.             $params  = json_decode($request->getContent(), true);
  471.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  473.             if (!isset($params['report_type_id'])) {
  474.                 return $this->json(['success' => false, 'message' =>  $this->translator->trans('missing_required_parameters')]);
  475.             }
  476.             $reportTypeId = $params['report_type_id'];
  477.             $parameters = new \Pimcore\Model\DataObject\ReportWeatherParameters\Listing();
  478.             $parameters->setCondition("reportType REGEXP CONCAT('(^|,)', REPLACE('" . $reportTypeId . "', ',', '|'), '(,|$)')");
  479.             $parameters->load();
  480.             if ($parameters->getCount() > 0) {
  481.                 foreach ($parameters as $paramter) {
  482.                     $result[] = [
  483.                         "id" => $paramter->getId(),
  484.                         "nameEn" => $paramter->getName('en'),
  485.                         "nameAr" => $paramter->getName('ar'),
  486.                         "meteoMaticsKey" => $paramter->getMeteoMaticsKey(),
  487.                         "units" => $paramter->getUnits(),
  488.                         "unitTitle" => $paramter->getUnitTitle()
  489.                     ];
  490.                 }
  491.                 return $this->json(["success" => true, "data" => $result]);
  492.             }
  493.             return $this->json(["success" => false, "message" => $this->translator->trans("no_weather_parameter_is_available")]);
  494.         } catch (\Exception $ex) {
  495.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  496.         }
  497.     }
  499.     /**
  500.      * @Route("/api/public/generate-excel", name="public-generate-excel")
  501.      */
  502.     public function generateExcelReport(Request $request)
  503.     {
  504.         $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  505.         if ($permissions['success'] !== true) {
  506.             return $this->json($permissions);
  507.         }
  508.         $user = $permissions['user'];
  510.         $params  = json_decode($request->getContent(), true);
  511.         $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  513.         if (!isset($params['id'])) {
  514.             throw new \Exception('missing_required_parameters');
  515.         }
  516.         $report = Report::getById($params['id'], true);
  517.         if (!$report instanceof Report) {
  518.             throw new \Exception('no_report_found');
  519.         }
  520.         // Replace this with the actual data you want to use
  521.         $jsonData = json_decode($report->getJsonData(), true);
  523.         // Create a new PhpSpreadsheet instance
  524.         $spreadsheet = new Spreadsheet();
  526.         // Create a worksheet
  527.         $sheet = $spreadsheet->getActiveSheet();
  529.         // Determine headers dynamically based on the first item in the data
  530.         $firstItem = reset($jsonData);
  531.         $parameters = $firstItem['parameters'] ?? [];
  532.         $headers = ['City', 'Lat', 'Lon', 'Date']; // Initialize headers with common columns
  534.         // Extract parameter names and add them to headers
  535.         foreach ($parameters as $parameter) {
  536.             $headers[] = $parameter['parameter'];
  537.         }
  539.         // Add headers to the worksheet
  540.         foreach ($headers as $index => $header) {
  541.             $sheet->setCellValueByColumnAndRow($index + 1, 1, $header);
  542.         }
  544.         // Initialize row counter
  545.         $row = 2;
  547.         foreach ($jsonData as $item) {
  548.             // Extract city-related data
  549.             $cityData = [$item['city'] ?? '', $item['lat'] ?? '', $item['lon'] ?? ''];
  551.             // Loop through each date for all parameters
  552.             foreach ($item['parameters'][0]['dates'] as $dateIndex => $date) {
  553.                 // Initialize row data with city-related data and date
  554.                 $rowData = array_merge($cityData, [date('Y-m-d', strtotime($date['date']))]);
  556.                 // Loop through each parameter
  557.                 foreach ($item['parameters'] as $parameter) {
  558.                     // Check if the value is set for the current date, otherwise set it to 0
  559.                     $value = isset($parameter['dates'][$dateIndex]['value']) ? $parameter['dates'][$dateIndex]['value'] : 0;
  561.                     // Add parameter value for the current date to the row data
  562.                     $rowData[] = $value;
  563.                 }
  565.                 // Set cell values explicitly
  566.                 foreach ($rowData as $colIndex => $cellValue) {
  567.                     $sheet->setCellValueByColumnAndRow($colIndex + 1, $row, $cellValue);
  568.                 }
  570.                 // Increment the row counter
  571.                 $row++;
  572.             }
  573.         }
  578.         // Save the Excel file to a temporary file
  579.         $tempFile = tempnam(sys_get_temp_dir(), 'weather_report');
  580.         $writer = new Xlsx($spreadsheet);
  581.         $writer->save($tempFile);
  583.         // Store the file in Pimcore Assets
  584.         $assetFolder = '/report/ExcelReports'; // Change this to your actual asset folder path
  585.         $filename = $user->getId() . '_' . time() . '_' . 'weather_report.xlsx';
  586.         $assetPath =  API_BASE_URL . '/' . $assetFolder . '/' . $filename;
  588.         // Create a new asset
  589.         $asset = new \Pimcore\Model\Asset();
  590.         $asset->setFilename($filename);
  591.         $asset->setData(file_get_contents($tempFile));
  592.         $asset->setParent(\Pimcore\Model\Asset\Service::createFolderByPath($assetFolder));
  593.         $asset->save();
  595.         // Remove the temporary file
  596.         unlink($tempFile);
  597.         $report->setAsset($asset);
  598.         $report->setIsHistorical(true);
  599.         $report->save();
  600.         // Return the path to the stored Excel file in Pimcore
  601.         return $this->json(['success' => true, 'data' => $assetPath]);
  602.     }
  604.     /**
  605.      * @Route("/api/public/generate-historical-report", methods={"POST"})
  606.      */
  607.     public function generateHistoricalReport(Request $request): JsonResponse
  608.     {
  609.         try {
  610.             $response = [];
  611.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  612.             if ($permissions['success'] !== true) {
  613.                 return $this->json($permissions);
  614.             }
  615.             $params = json_decode($request->getContent(), true);
  616.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  618.             if (
  619.                 !isset($params['from_date']) ||
  620.                 !isset($params['to_date']) ||
  621.                 !isset($params['hours']) ||
  622.                 !isset($params['parameters'])  ||
  623.                 !isset($params['locations'])
  624.             ) {
  625.                 throw new \Exception('Missing required parameters');
  626.             }
  627.             if (empty($params['parameters'] || !is_array($params['parameters']))) {
  628.                 throw new \Exception('Parameters should be non empty array');
  629.             }
  631.             if (empty($params['locations'] || !is_array($params['locations']))) {
  632.                 throw new \Exception('Locations should be non empty array');
  633.             }
  634.             if ($params['to_date'] > date('Y-m-d', strtotime(Carbon::now()))) {
  636.                 $daysadd = date('Y-m-d', strtotime(Carbon::now()->addDays('17')));
  637.                 if ($params['to_date'] >= $daysadd) {
  638.                     throw new \Exception('End date limit exceeded');
  639.                 }
  640.             }
  641.             $model = isset($params['model']) ? $params['model'] : 'mix';
  642.             $redisKey = md5('generate_city_report-' . $params['from_date'] . '-' . $params['to_date'] . '-' . $params['hours'] . '-' . implode('_', $params['locations'])) . '-' . implode('_', $params['parameters']) . '-' . $model;
  643.             $data = $this->redisCache->get($redisKey);
  644.             if (!$data) {
  645.                 $cities = new \Pimcore\Model\DataObject\Location\Listing();
  646.                 if (!empty($params['locations'])) {
  647.                     $cities->setCondition('o_id IN (?)', [$params['locations']]);
  648.                 }
  649.                 $cities->load();
  650.                 if ($cities->getCount() > 0) {
  651.                     $params['coordinates'] = []; // Initialize an empty array for coordinates
  652.                     $result = [];
  653.                     $citiesArr = [];
  654.                     foreach ($cities as $city) {
  655.                         $cityLocations = json_decode($city->getCoordinates(), true);
  656.                         foreach ($cityLocations as $coordinates) {
  657.                             $long = number_format($coordinates[1], 6, '.', '');
  658.                             $lat = number_format($coordinates[0], 6, '.', '');
  659.                             $params['coordinates'][] = $coordinates;
  660.                             $citiesArr[$lat . '|' . $long] =  $city->getName();
  661.                         }
  662.                     }
  664.                     $result = $this->meteomaticsWeatherService->getReportForecastData($params['coordinates'], $params['from_date'], $params['to_date'], $params['hours'], $model, $params['parameters'], $this->translator, $citiesArr, $params);
  666.                     $response[] = $result;
  667.                     $jsonResponse = ['success' => true, 'data' => $response];
  668.                     $this->redisCache->set($redisKey, $jsonResponse, REDIS_CACHE_TIME);
  669.                     return $this->json($jsonResponse);
  670.                 } else {
  671.                     return $this->json(['success' => true, 'message' => $this->translator->trans('no_city_found')]);
  672.                 }
  673.             } else {
  674.                 return $this->json($data);
  675.             }
  676.         } catch (\Exception $ex) {
  677.             $this->logger->error($ex->getMessage());
  678.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  679.         }
  680.     }
  682.     /**
  683.      * @Route("/api/public/get-latest-report", name="public-get-latest-report")
  684.      */
  685.     public function getLatestReport(Request $request)
  686.     {
  687.         try {
  689.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  690.             if ($permissions['success'] !== true) {
  691.                 return $this->json($permissions);
  692.             }
  694.             $params  = json_decode($request->getContent(), true);
  695.             $reportType = (isset($params['report_type']) && !empty($params['report_type'])) ? $params['report_type'] : 'ten-day-forecast-report';
  696.             $result = $this->reportModel->getLatestReport($reportType, $this->translator, false);
  698.             return $this->json($result);
  699.         } catch (\Exception $ex) {
  700.             $this->logger->error($ex->getMessage());
  701.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  702.         }
  703.     }
  706.      /**
  707.      * @Route("/api/public/get-latest-weather-report", name="public-get-latest-weather-report")
  708.      */
  709.     public function getLatestPublicWeatherReport(Request $request)
  710.     {
  711.         try {
  713.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  714.             if ($permissions['success'] !== true) {
  715.                 return $this->json($permissions);
  716.             }
  718.             $params  = json_decode($request->getContent(), true);
  719.             $result = $this->reportModel->getLatestPublicWeatherReport($params, $this->translator);
  721.             return $this->json($result);
  722.         } catch (\Exception $ex) {
  723.             $this->logger->error($ex->getMessage());
  724.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  725.         }
  726.     }
  728.     /**
  729.      * @Route("/api/public/get-automatic-reports", name="public_get_automatic_reports")
  730.      */
  731.     public function getAutomaticReports(Request $request, PaginatorInterface $paginator)
  732.     {
  733.         try {
  734.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  735.             if ($permissions['success'] !== true) {
  736.                 return $this->json($permissions);
  737.             }
  738.             $user = $permissions['user'];
  740.             $params  = json_decode($request->getContent(), true);
  741.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  743.             if (!isset($params['page']) || !isset($params['limit']) || !isset($params['lang'])) {
  744.                 throw new \Exception('Missing required parameters');
  745.             }
  746.             $search = isset($params['search']) ? $params['search'] : null;
  747.             $orderKey = isset($params['orderKey']) ? $params['orderKey'] : 'createdOn';
  748.             $order = isset($params['order']) ? $params['order'] : 'desc';
  749.             $result = $this->reportModel->listAutomaticPublicReports($params, $user, $search, $orderKey, $order, $this->translator, $paginator);
  750.             return $this->json($result);
  751.         } catch (\Exception $ex) {
  752.             $this->logger->error($ex->getMessage());
  753.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  754.         }
  755.     }
  757.     /**
  758.      * @Route("/api/public/generate-automatic-report-pdf", name="public-automatic-report-pdf")
  759.      */
  760.     public function generateAutomaticReportPdf(Request $request)
  761.     {
  762.         try {
  763.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  764.             if ($permissions['success'] !== true) {
  765.                 return $this->json($permissions);
  766.             }
  767.             $user = $permissions['user'];
  768.             $result = $this->reportModel->generatePdfReport($request, $user, $this->snappy, $this->translator);
  769.             return  $this->json($result);
  770.         } catch (\Exception $ex) {
  771.             $this->logger->error($ex->getMessage());
  772.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  773.         }
  774.     }
  776.     public function getPdfReport($request, $user, $template, $translator, $report_type)
  777.     {
  778.         $params  = json_decode($request->getContent(), true);
  779.         if (!isset($params['id'])) {
  780.             return $this->json(["success" => false, "message" => $translator->trans("missing_required_parameters")]);
  781.         }
  782.         $report = Report::getById($params['id'], true);
  783.         $lang = isset($params['lang']) ? $params['lang'] : "en";
  784.         if (!$report instanceof Report) {
  785.             return $this->json(["success" => false, "message" => $translator->trans("no_report_found")]);
  786.         }
  787.         $asset = $lang == 'ar' ? $report->getAssetAr() : $report->getAsset();
  788.         if ($asset) {
  789.             $pdfasset = API_BASE_URL . $asset->getPath() . $asset->getFilename();
  790.             return $this->json(['success' => true, 'data' => $pdfasset]);
  791.         }
  792.         //$template=$report->getReportType()?->getKey() == 'MannForecastReport'?'pdf/report_pdf_template.html.twig':'pdf/automatic_report_pdf_template.html.twig';
  794.         $fileName = '_custom_weather_report.pdf';
  795.         $reportPath = '/report/ReportPdf';
  797.         if ($report->getReportType()?->getKey() == 'MannForecastReport') {
  798.             $template =  'pdf/report_pdf_template.html.twig';
  799.         } elseif ($report->getReportType()?->getKey() == 'advance-custom-weather-report') {
  801.             $template = 'pdf/advance_custom_report_pdf_template.html.twig';
  802.             $fileName = '_advance_custom_weather_report.pdf';
  803.             $reportPath = '/report/advanceCustomReportPdf';
  804.         } else {
  805.             $template = 'pdf/automatic_report_pdf_template.html.twig';
  806.         }
  809.         $parameter = [
  810.             'data' => $report,
  811.             'reportTitleEn' => $report->getReportTitle('en'),
  812.             'reportTitleAr' => $report->getReportTitle('ar'),
  813.             'reportDescriptionEn' => $report->getDescription('en'),
  814.             'reportDescriptionAr' => $report->getDescription('ar'),
  815.             'reportDisclaimerEn' => $report->getReportDisclaimer('en'), // new 
  816.             'reportDisclaimerAr' => $report->getReportDisclaimer('ar'), // new 
  817.             'additionalNoteEn' => $report->getAdditionalNote('en'), // new 
  818.             'additionalNoteAr' => $report->getAdditionalNote('ar'), // new 
  819.             'template' => $template,
  820.             'lang' => $lang
  821.         ];
  823.         // return $this->render('pdf/automatic_report_pdf_template_copy.html.twig',$parameter);
  824.         $pdf = \App\Lib\Utility::generatePdf($parameter, $this->snappy);
  825.         // $tempFilePath = tempnam(sys_get_temp_dir(), 'image_');
  826.         // file_put_contents($tempFilePath, $pdf);
  828.         // Create a BinaryFileResponse and set headers
  829.         //    $response = new BinaryFileResponse($tempFilePath);
  830.         //    $response->headers->set('Content-Type', 'application/pdf');
  831.         //    $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_INLINE, 'image.pdf');
  833.         // Return the response
  834.         //    return $response;
  835.         $asset = \App\Lib\Utility::createAsset($pdf, $user->getId() . '_' . time() . $report_type,  $reportPath);
  836.         $pdfasset = '';
  837.         if ($asset instanceof Asset) {
  838.             $pdfasset = API_BASE_URL . $asset->getPath() . $asset->getFilename();
  839.         }
  840.         if ($lang == 'ar') {
  841.             $report->setAssetAr($asset);
  842.         } else {
  843.             $report->setAsset($asset);
  844.         }
  845.         $report->save();
  846.         return $this->json(['success' => true, 'data' => $pdfasset]);
  847.     }
  849.     /**
  850.      * @Route("/api/public/get-today-weather-report", name="public_get_today_weather_report")
  851.      */
  852.     public function getTodayWeatherReports(Request $request, PaginatorInterface $paginator)
  853.     {
  854.         try {
  855.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  856.             if ($permissions['success'] !== true) {
  857.                 return $this->json($permissions);
  858.             }
  859.             $user = $permissions['user'];
  861.             $params  = json_decode($request->getContent(), true);
  862.             if (!isset($params['page']) || !isset($params['limit']) || !isset($params['lang'])) {
  863.                 throw new \Exception('Missing required parameters');
  864.             }
  865.             $result = $this->reportModel->getTodayWeatherReports($params, $this->translator, $paginator);
  866.             return $this->json($result);
  867.         } catch (\Exception $ex) {
  868.             $this->logger->error($ex->getMessage());
  869.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  870.         }
  871.     }
  873.     /**
  874.      * @Route("/api/public/get-report-weather-symbols", name="public_get_report_weather_symbols")
  875.      */
  876.     public function getReportWeatherSymbols(Request $request): JsonResponse
  877.     {
  878.         try {
  879.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  880.             if ($permissions['success'] !== true) {
  881.                 return $this->json($permissions);
  882.             }
  883.             $user = $permissions['user'];
  885.             $data = [];
  886.             $weatherSymbols = new ReportWeatherSymbols\Listing();
  887.             foreach ($weatherSymbols as $weatherSymbol) {
  888.                 if ($weatherSymbol) {
  889.                     $weatherSymbolNames = $weatherSymbol->getWeatherSymbols();
  890.                     $weatherSymbolIcons = $weatherSymbol->getWeatherIcons();
  891.                     if ($weatherSymbolNames) {
  892.                         foreach ($weatherSymbolNames as $weatherSymbolName) {
  893.                             $response['symbols'][] = [
  894.                                 'nameEn' => $weatherSymbolName->getSymbolName('en'),
  895.                                 'nameAr' => $weatherSymbolName->getSymbolName('ar'),
  896.                             ];
  897.                         }
  898.                     }
  899.                     if ($weatherSymbolIcons) {
  900.                         foreach ($weatherSymbolIcons as $weatherSymbolIcon) {
  901.                             $response['icons'][] = [
  902.                                 'iconValue' => $weatherSymbolIcon->getIconValue(),
  903.                             ];
  904.                         }
  905.                     }
  906.                 }
  907.                 $data[] = $response;
  908.             }
  910.             return $this->json(['success' => true, 'data' => $data]);
  911.         } catch (\Exception $ex) {
  912.             $this->logger->error($ex->getMessage());
  913.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  914.         }
  915.     }
  917.     /**
  918.      * @Route("/api/public/get-forecast-cities", methods={"POST"})
  919.      */
  920.     public function getForecastCities(Request $request): Response
  921.     {
  922.         try {
  924.             $params = json_decode($request->getContent(), true);
  925.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  927.             // check user credentials and expiry
  928.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  929.             if ($response['success'] !== true) {
  930.                 return $this->json($response);
  931.             }
  934.             $forecastCityModel = new WeatherForecastCityModel();
  935.             $cities = $forecastCityModel->getWeatherForecastCities();
  937.             return $this->json(['success' => true, 'data' => $cities]);
  938.         } catch (\Exception $ex) {
  939.             $this->logger->error($ex->getMessage());
  940.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  941.         }
  942.     }
  944.     /**
  945.      * @Route("/api/public/get-regions-bbox", name="get-regions-bbox")
  946.      */
  947.     public function getRegionsBbox(Request $request)
  948.     {
  949.         try {
  951.             $params = json_decode($request->getContent(), true);
  952.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  954.             // check user credentials and expiry
  955.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  956.             if ($response['success'] !== true) {
  957.                 return $this->json($response);
  958.             }
  961.             $data = REGIONS_BBOX;
  963.             return $this->json(['success' => true, 'data' => $data]);
  964.         } catch (\Exception $ex) {
  965.             $this->logger->error($ex->getMessage());
  966.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  967.         }
  968.     }
  970.     /**
  971.      * @Route("/api/public/get-station-data", methods={"GET"})
  972.      */
  973.     public function getWeatherStationDataAction(Request $request)
  974.     {
  975.         try {
  976.             $params = json_decode($request->getContent(), true);
  977.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  979.             // check user credentials and expiry
  980.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  981.             if ($response['success'] !== true) {
  982.                 return $this->json($response);
  983.             }
  986.             $typeName = $request->get('type_name');
  987.             $parameters = $request->get('parameters');
  988.             $dateTime = $request->get('date_time');
  989.             $bBox = $request->get('b_box');
  992.             if (!$typeName) {
  993.                 throw new \InvalidArgumentException("Missing mandatory parameter: type_name");
  994.             }
  995.             if (!$parameters) {
  996.                 throw new \InvalidArgumentException("Missing mandatory parameter: parameters");
  997.             }
  998.             if (!$dateTime) {
  999.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  1000.             }
  1001.             if (!$bBox) {
  1002.                 throw new \InvalidArgumentException("Missing mandatory parameter: b_box");
  1003.             }
  1005.             $result = $this->meteomaticsWeatherService->getWeatherStationData($typeName, $parameters, $dateTime, $bBox);
  1006.             return $result;
  1007.         } catch (\Exception $ex) {
  1008.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  1009.         }
  1010.     }
  1012.     /**
  1013.      * @Route("/api/public/daily-forecast", methods={"POST"})
  1014.      */
  1015.     public function dailyForecast(Request $request): JsonResponse
  1016.     {
  1017.         try {
  1018.             $params = json_decode($request->getContent(), true);
  1019.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1021.             // check user credentials and expiry
  1022.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1023.             if ($response['success'] !== true) {
  1024.                 return $this->json($response);
  1025.             }
  1027.             $requiredParameters = ['coordinates', 'from_date', 'to_date', 'model'];
  1028.             foreach ($requiredParameters as $param) {
  1029.                 if (!isset($params[$param])) {
  1030.                     $missingParams[] = $param;
  1031.                 }
  1032.             }
  1033.             if (!empty($missingParams)) {
  1034.                 // Throw an exception with a message that includes the missing parameters
  1035.                 $parameterList = implode(", ", $missingParams);
  1036.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1037.             }
  1038.             $result = $this->meteomaticsWeatherService->getForecastData($params['coordinates'], $params['from_date'], $params['to_date'], $params['hours'], $params['model'], $this->translator);
  1039.             return $this->json($result);
  1040.         } catch (\Exception $ex) {
  1041.             $this->logger->error($ex->getMessage());
  1042.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1043.         }
  1044.     }
  1046.     /**
  1047.      * @Route("/api/public/weather/{path}", name="api_meteomatics", requirements={"path"=".+"}, methods={"GET"})
  1048.      */
  1049.     public function getDynamicWeatherData(Request $request, string $path): Response
  1050.     {
  1051.         try {
  1052.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1053.             if ($response['success'] !== true) {
  1054.                 return $this->json($response);
  1055.             }
  1056.             $user = $response['user'];
  1057.             $queryParams = $request->query->all();
  1058.             $weatherData = $this->meteomaticApiService->getDynamicWeatherData($path, $queryParams, $user);
  1059.             return $weatherData;
  1060.         } catch (\Exception $ex) {
  1061.             $this->logger->error($ex->getMessage());
  1062.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1063.         }
  1064.     }
  1066.     /**
  1067.      * @Route("/api/public/create-manned-alert-subscription", methods={"POST"})
  1068.      */
  1069.     public function mannedAlertSubscription(Request $request): JsonResponse
  1070.     {
  1071.         try {
  1072.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1073.             if ($response['success'] !== true) {
  1074.                 return $this->json($response);
  1075.             }
  1076.             $user = $response['user'];
  1077.             $params = json_decode($request->getContent(), true);
  1078.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1080.             // $requiredParameters = ['region_id', 'governorate_id', 'alert_type_id'];
  1082.             // foreach ($requiredParameters as $param) {
  1083.             //     if (!isset($params[$param]) || empty($params[$param])) {
  1084.             //         $missingParams[] = $param;
  1085.             //     }
  1086.             // }
  1088.             // if (!empty($missingParams)) {
  1089.             //     // Throw an exception with a message that includes the missing parameters
  1090.             //     $parameterList = implode(", ", $missingParams);
  1091.             //     return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1092.             // }
  1094.             $result = $this->customNotificationService->mannedAlertSubscription($user, $params, $this->translator);
  1095.             return $this->json($result);
  1096.         } catch (\Exception $ex) {
  1097.             $this->logger->error($ex->getMessage());
  1098.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1099.         }
  1100.     }
  1101. }