src/Controller/PublicApiController.php line 37

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.     }
  705.     /**
  706.      * @Route("/api/public/get-automatic-reports", name="public_get_automatic_reports")
  707.      */
  708.     public function getAutomaticReports(Request $request, PaginatorInterface $paginator)
  709.     {
  710.         try {
  711.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  712.             if ($permissions['success'] !== true) {
  713.                 return $this->json($permissions);
  714.             }
  715.             $user = $permissions['user'];
  717.             $params  = json_decode($request->getContent(), true);
  718.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  720.             if (!isset($params['page']) || !isset($params['limit']) || !isset($params['lang'])) {
  721.                 throw new \Exception('Missing required parameters');
  722.             }
  723.             $search = isset($params['search']) ? $params['search'] : null;
  724.             $orderKey = isset($params['orderKey']) ? $params['orderKey'] : 'createdOn';
  725.             $order = isset($params['order']) ? $params['order'] : 'desc';
  726.             $result = $this->reportModel->listAutomaticPublicReports($params, $user, $search, $orderKey, $order, $this->translator, $paginator);
  727.             return $this->json($result);
  728.         } catch (\Exception $ex) {
  729.             $this->logger->error($ex->getMessage());
  730.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  731.         }
  732.     }
  734.     /**
  735.      * @Route("/api/public/generate-automatic-report-pdf", name="public-automatic-report-pdf")
  736.      */
  737.     public function generateAutomaticReportPdf(Request $request)
  738.     {
  739.         try {
  740.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  741.             if ($permissions['success'] !== true) {
  742.                 return $this->json($permissions);
  743.             }
  744.             $user = $permissions['user'];
  745.             $result = $this->reportModel->generatePdfReport($request, $user, $this->snappy, $this->translator);
  746.             return  $this->json($result);
  747.         } catch (\Exception $ex) {
  748.             $this->logger->error($ex->getMessage());
  749.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  750.         }
  751.     }
  753.     public function getPdfReport($request, $user, $template, $translator, $report_type)
  754.     {
  755.         $params  = json_decode($request->getContent(), true);
  756.         if (!isset($params['id'])) {
  757.             return $this->json(["success" => false, "message" => $translator->trans("missing_required_parameters")]);
  758.         }
  759.         $report = Report::getById($params['id'], true);
  760.         $lang = isset($params['lang']) ? $params['lang'] : "en";
  761.         if (!$report instanceof Report) {
  762.             return $this->json(["success" => false, "message" => $translator->trans("no_report_found")]);
  763.         }
  764.         $asset = $lang == 'ar' ? $report->getAssetAr() : $report->getAsset();
  765.         if ($asset) {
  766.             $pdfasset = API_BASE_URL . $asset->getPath() . $asset->getFilename();
  767.             return $this->json(['success' => true, 'data' => $pdfasset]);
  768.         }
  769.         //$template=$report->getReportType()?->getKey() == 'MannForecastReport'?'pdf/report_pdf_template.html.twig':'pdf/automatic_report_pdf_template.html.twig';
  771.         $fileName = '_custom_weather_report.pdf';
  772.         $reportPath = '/report/ReportPdf';
  774.         if ($report->getReportType()?->getKey() == 'MannForecastReport') {
  775.             $template =  'pdf/report_pdf_template.html.twig';
  776.         } elseif ($report->getReportType()?->getKey() == 'advance-custom-weather-report') {
  778.             $template = 'pdf/advance_custom_report_pdf_template.html.twig';
  779.             $fileName = '_advance_custom_weather_report.pdf';
  780.             $reportPath = '/report/advanceCustomReportPdf';
  781.         } else {
  782.             $template = 'pdf/automatic_report_pdf_template.html.twig';
  783.         }
  786.         $parameter = [
  787.             'data' => $report,
  788.             'reportTitleEn' => $report->getReportTitle('en'),
  789.             'reportTitleAr' => $report->getReportTitle('ar'),
  790.             'reportDescriptionEn' => $report->getDescription('en'),
  791.             'reportDescriptionAr' => $report->getDescription('ar'),
  792.             'reportDisclaimerEn' => $report->getReportDisclaimer('en'), // new 
  793.             'reportDisclaimerAr' => $report->getReportDisclaimer('ar'), // new 
  794.             'additionalNoteEn' => $report->getAdditionalNote('en'), // new 
  795.             'additionalNoteAr' => $report->getAdditionalNote('ar'), // new 
  796.             'template' => $template,
  797.             'lang' => $lang
  798.         ];
  800.         // return $this->render('pdf/automatic_report_pdf_template_copy.html.twig',$parameter);
  801.         $pdf = \App\Lib\Utility::generatePdf($parameter, $this->snappy);
  802.         // $tempFilePath = tempnam(sys_get_temp_dir(), 'image_');
  803.         // file_put_contents($tempFilePath, $pdf);
  805.         // Create a BinaryFileResponse and set headers
  806.         //    $response = new BinaryFileResponse($tempFilePath);
  807.         //    $response->headers->set('Content-Type', 'application/pdf');
  808.         //    $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_INLINE, 'image.pdf');
  810.         // Return the response
  811.         //    return $response;
  812.         $asset = \App\Lib\Utility::createAsset($pdf, $user->getId() . '_' . time() . $report_type,  $reportPath);
  813.         $pdfasset = '';
  814.         if ($asset instanceof Asset) {
  815.             $pdfasset = API_BASE_URL . $asset->getPath() . $asset->getFilename();
  816.         }
  817.         if ($lang == 'ar') {
  818.             $report->setAssetAr($asset);
  819.         } else {
  820.             $report->setAsset($asset);
  821.         }
  822.         $report->save();
  823.         return $this->json(['success' => true, 'data' => $pdfasset]);
  824.     }
  826.     /**
  827.      * @Route("/api/public/get-today-weather-report", name="public_get_today_weather_report")
  828.      */
  829.     public function getTodayWeatherReports(Request $request, PaginatorInterface $paginator)
  830.     {
  831.         try {
  832.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  833.             if ($permissions['success'] !== true) {
  834.                 return $this->json($permissions);
  835.             }
  836.             $user = $permissions['user'];
  838.             $params  = json_decode($request->getContent(), true);
  839.             if (!isset($params['page']) || !isset($params['limit']) || !isset($params['lang'])) {
  840.                 throw new \Exception('Missing required parameters');
  841.             }
  842.             $result = $this->reportModel->getTodayWeatherReports($params, $this->translator, $paginator);
  843.             return $this->json($result);
  844.         } catch (\Exception $ex) {
  845.             $this->logger->error($ex->getMessage());
  846.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  847.         }
  848.     }
  850.     /**
  851.      * @Route("/api/public/get-report-weather-symbols", name="public_get_report_weather_symbols")
  852.      */
  853.     public function getReportWeatherSymbols(Request $request): JsonResponse
  854.     {
  855.         try {
  856.             $permissions = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  857.             if ($permissions['success'] !== true) {
  858.                 return $this->json($permissions);
  859.             }
  860.             $user = $permissions['user'];
  862.             $data = [];
  863.             $weatherSymbols = new ReportWeatherSymbols\Listing();
  864.             foreach ($weatherSymbols as $weatherSymbol) {
  865.                 if ($weatherSymbol) {
  866.                     $weatherSymbolNames = $weatherSymbol->getWeatherSymbols();
  867.                     $weatherSymbolIcons = $weatherSymbol->getWeatherIcons();
  868.                     if ($weatherSymbolNames) {
  869.                         foreach ($weatherSymbolNames as $weatherSymbolName) {
  870.                             $response['symbols'][] = [
  871.                                 'nameEn' => $weatherSymbolName->getSymbolName('en'),
  872.                                 'nameAr' => $weatherSymbolName->getSymbolName('ar'),
  873.                             ];
  874.                         }
  875.                     }
  876.                     if ($weatherSymbolIcons) {
  877.                         foreach ($weatherSymbolIcons as $weatherSymbolIcon) {
  878.                             $response['icons'][] = [
  879.                                 'iconValue' => $weatherSymbolIcon->getIconValue(),
  880.                             ];
  881.                         }
  882.                     }
  883.                 }
  884.                 $data[] = $response;
  885.             }
  887.             return $this->json(['success' => true, 'data' => $data]);
  888.         } catch (\Exception $ex) {
  889.             $this->logger->error($ex->getMessage());
  890.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  891.         }
  892.     }
  894.     /**
  895.      * @Route("/api/public/get-forecast-cities", methods={"POST"})
  896.      */
  897.     public function getForecastCities(Request $request): Response
  898.     {
  899.         try {
  901.             $params = json_decode($request->getContent(), true);
  902.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  904.             // check user credentials and expiry
  905.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  906.             if ($response['success'] !== true) {
  907.                 return $this->json($response);
  908.             }
  911.             $forecastCityModel = new WeatherForecastCityModel();
  912.             $cities = $forecastCityModel->getWeatherForecastCities();
  914.             return $this->json(['success' => true, 'data' => $cities]);
  915.         } catch (\Exception $ex) {
  916.             $this->logger->error($ex->getMessage());
  917.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  918.         }
  919.     }
  921.     /**
  922.      * @Route("/api/public/get-regions-bbox", name="get-regions-bbox")
  923.      */
  924.     public function getRegionsBbox(Request $request)
  925.     {
  926.         try {
  928.             $params = json_decode($request->getContent(), true);
  929.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  931.             // check user credentials and expiry
  932.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  933.             if ($response['success'] !== true) {
  934.                 return $this->json($response);
  935.             }
  938.             $data = REGIONS_BBOX;
  940.             return $this->json(['success' => true, 'data' => $data]);
  941.         } catch (\Exception $ex) {
  942.             $this->logger->error($ex->getMessage());
  943.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  944.         }
  945.     }
  947.     /**
  948.      * @Route("/api/public/get-station-data", methods={"GET"})
  949.      */
  950.     public function getWeatherStationDataAction(Request $request)
  951.     {
  952.         try {
  953.             $params = json_decode($request->getContent(), true);
  954.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  956.             // check user credentials and expiry
  957.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  958.             if ($response['success'] !== true) {
  959.                 return $this->json($response);
  960.             }
  963.             $typeName = $request->get('type_name');
  964.             $parameters = $request->get('parameters');
  965.             $dateTime = $request->get('date_time');
  966.             $bBox = $request->get('b_box');
  969.             if (!$typeName) {
  970.                 throw new \InvalidArgumentException("Missing mandatory parameter: type_name");
  971.             }
  972.             if (!$parameters) {
  973.                 throw new \InvalidArgumentException("Missing mandatory parameter: parameters");
  974.             }
  975.             if (!$dateTime) {
  976.                 throw new \InvalidArgumentException("Missing mandatory parameter: date_time");
  977.             }
  978.             if (!$bBox) {
  979.                 throw new \InvalidArgumentException("Missing mandatory parameter: b_box");
  980.             }
  982.             $result = $this->meteomaticsWeatherService->getWeatherStationData($typeName, $parameters, $dateTime, $bBox);
  983.             return $result;
  984.         } catch (\Exception $ex) {
  985.             return $this->json(['success' => false, 'message' => $ex->getMessage()]);
  986.         }
  987.     }
  989.     /**
  990.      * @Route("/api/public/daily-forecast", methods={"POST"})
  991.      */
  992.     public function dailyForecast(Request $request): JsonResponse
  993.     {
  994.         try {
  995.             $params = json_decode($request->getContent(), true);
  996.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  998.             // check user credentials and expiry
  999.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1000.             if ($response['success'] !== true) {
  1001.                 return $this->json($response);
  1002.             }
  1004.             $requiredParameters = ['coordinates', 'from_date', 'to_date', 'model'];
  1005.             foreach ($requiredParameters as $param) {
  1006.                 if (!isset($params[$param])) {
  1007.                     $missingParams[] = $param;
  1008.                 }
  1009.             }
  1010.             if (!empty($missingParams)) {
  1011.                 // Throw an exception with a message that includes the missing parameters
  1012.                 $parameterList = implode(", ", $missingParams);
  1013.                 return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1014.             }
  1015.             $result = $this->meteomaticsWeatherService->getForecastData($params['coordinates'], $params['from_date'], $params['to_date'], $params['hours'], $params['model'], $this->translator);
  1016.             return $this->json($result);
  1017.         } catch (\Exception $ex) {
  1018.             $this->logger->error($ex->getMessage());
  1019.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1020.         }
  1021.     }
  1023.     /**
  1024.      * @Route("/api/public/weather/{path}", name="api_meteomatics", requirements={"path"=".+"}, methods={"GET"})
  1025.      */
  1026.     public function getDynamicWeatherData(Request $request, string $path): Response
  1027.     {
  1028.         try {
  1029.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1030.             if ($response['success'] !== true) {
  1031.                 return $this->json($response);
  1032.             }
  1033.             $user = $response['user'];
  1034.             $queryParams = $request->query->all();
  1035.             $weatherData = $this->meteomaticApiService->getDynamicWeatherData($path, $queryParams, $user);
  1036.             return $weatherData;
  1037.         } catch (\Exception $ex) {
  1038.             $this->logger->error($ex->getMessage());
  1039.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1040.         }
  1041.     }
  1043.     /**
  1044.      * @Route("/api/public/create-manned-alert-subscription", methods={"POST"})
  1045.      */
  1046.     public function mannedAlertSubscription(Request $request): JsonResponse
  1047.     {
  1048.         try {
  1049.             $response = $this->publicUserPermissionService->isAuthorized($request, $this->translator);
  1050.             if ($response['success'] !== true) {
  1051.                 return $this->json($response);
  1052.             }
  1053.             $user = $response['user'];
  1054.             $params = json_decode($request->getContent(), true);
  1055.             $this->translator->setlocale(isset($params["lang"]) ? $params["lang"] : DEFAULT_LOCALE);
  1057.             // $requiredParameters = ['region_id', 'governorate_id', 'alert_type_id'];
  1059.             // foreach ($requiredParameters as $param) {
  1060.             //     if (!isset($params[$param]) || empty($params[$param])) {
  1061.             //         $missingParams[] = $param;
  1062.             //     }
  1063.             // }
  1065.             // if (!empty($missingParams)) {
  1066.             //     // Throw an exception with a message that includes the missing parameters
  1067.             //     $parameterList = implode(", ", $missingParams);
  1068.             //     return $this->json(['success' => false, 'message' => sprintf($this->translator->trans("missing_required_parameters: %s"), $parameterList)]);
  1069.             // }
  1071.             $result = $this->customNotificationService->mannedAlertSubscription($user, $params, $this->translator);
  1072.             return $this->json($result);
  1073.         } catch (\Exception $ex) {
  1074.             $this->logger->error($ex->getMessage());
  1075.             return $this->json(['success' => false, 'message' => $this->translator->trans(USER_ERROR_MESSAGE)]);
  1076.         }
  1077.     }
  1078. }