src/Model/CalendarModel.php line 224

Open in your IDE?
  1. <?php
  3. namespace App\Model;
  5. use Symfony\Component\Security\Core\User\UserInterface;
  6. use Pimcore\Model\DataObject\CustomNotification;
  7. use Pimcore\Model\DataObject\EwsNotification;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use App\Service\MeteomaticsWeatherService;
  10. use Pimcore\Model\DataObject\Dashboard;
  11. use Pimcore\Model\DataObject\Customer;
  12. use Pimcore\Model\DataObject\Location;
  13. use Pimcore\Model\DataObject;
  14. use App\Model\LocationModel;
  15. use GuzzleHttp\Client;
  16. use DateTimeZone;
  17. use Pimcore\Db;
  18. use DateTime;
  20. class CalendarModel
  21. {
  24.     private $apiBaseUrl = MATEOMATICS_API_URL;
  25.     private $username = MATEOMATICS_API_USERNAME;
  26.     private  $password = MATEOMATICS_API_PASSWORD;
  28.     // public function getCalendarNotification(MeteomaticsWeatherService $mateoMaticsService, $user, $customNotificationIds, $startDate, $endDate, $hour, $page, $size, $title, $paginator, $translator): array
  29.     // {
  31.     //     $pageSize = isset($size) ? $size : LIMIT_PER_PAGE;
  32.     //     $page = isset($page) ? $page : 1;
  34.     //     $qualifiedLocations = [];
  35.     //     $locationModel = new LocationModel();
  36.     //     $ewsNotificationModel = new EwsNotificationModel();
  37.     //     $options = [];
  38.     //     $calculateOption = [];
  39.     //     $customNotificationListing = new DataObject\CustomNotification\Listing();
  40.     //     foreach ($customNotificationListing->getClass()->getFieldDefinitions() as $fieldDefionition) {
  41.     //         if ($fieldDefionition->getName() == "calculate") {
  42.     //             $options = $fieldDefionition->getOptions();
  43.     //         }
  44.     //     }
  45.     //     if ($options) {
  46.     //         foreach ($options as $optionKey => $option) {
  47.     //             $calculateOption[$option['value']] = $option['key'];
  48.     //         }
  49.     //     }
  50.     //     $customNotification = new DataObject\CustomNotification\Listing();
  51.     //     $customNotification->addConditionParam('o_id IN (' . $customNotificationIds . ')');
  52.     //     $customNotification->filterByUser($user);
  53.     //     //$customNotification->setLimit(10);
  54.     //     $customNotification->setOrderKey("o_id");
  55.     //     $customNotification->setOrder("desc");
  56.     //     if (!empty($title)) {
  57.     //         $customNotification->addConditionParam("title like '%$title%' ");
  58.     //     }
  60.     //     $paginator = $paginator->paginate(
  61.     //         $customNotification,
  62.     //         $page,
  63.     //         $pageSize
  64.     //     );
  65.     //     $customNotifications = $paginator->count();
  66.     //     if (!$customNotifications) {
  67.     //         // throw new \Exception("You do not have any notification configured for this location");
  68.     //         return ['success' => false, 'message' => $translator->trans("you_do_not_have_any_notification_configured_for_this_location")];
  69.     //     }
  72.     //     $resultArr = [];
  73.     //     $resultArr1 = [];
  74.     //     foreach ($paginator as $customNotification) {
  76.     //         $user = $customNotification->getUser();
  77.     //         $location = $customNotification->getLocation();
  78.     //         if ($location instanceof DataObject\Location) {
  79.     //             $coOrdinates = json_decode($location->getCoOrdinates(), true);
  80.     //             if ($coOrdinates && count($coOrdinates)) {
  81.     //                 if (!$customNotification->getAlert()) {
  82.     //                     continue;
  83.     //                 }
  84.     //                 $parameter = $customNotification->getAlert()->getMeteoMaticsKey();
  85.     //                 $alertName = $customNotification->getAlert()->getName("en");
  86.     //                 $alertNameAr = $customNotification->getAlert()->getName("ar");
  87.     //                 if (!empty($customNotification->getWeatherModel())) {
  88.     //                     $model = $customNotification->getWeatherModel();
  89.     //                 } else {
  90.     //                     $model = "mix";
  91.     //                 }
  93.     //                 $startDate = date('Y-m-d\T00:00:00.v\Z', strtotime($startDate));
  94.     //                 $endDate = date('Y-m-d\T23:59:59.v\Z', strtotime($endDate));
  96.     //                 p_r($startDate);
  97.     //                 p_r($endDate);
  98.     //                 $response = $mateoMaticsService->getTempratureByParamsHourly($coOrdinates, $startDate, $endDate, $parameter, $hour, $model);
  100.     //                 $qualifiedLocations = $response['data'][0]['coordinates'][0]['dates'];
  102.     //                 if (is_array($response) && isset($response['data'][0]['parameter']) && $response['data'][0]['parameter'] = $parameter) {
  104.     //                     foreach ($qualifiedLocations as $key => $qualifiedLocation) {
  106.     //                         if ($customNotification->getCalculate() == "range") {
  107.     //                             $value2 = [];
  108.     //                             $value2[0] = $customNotification->getMinValue();
  109.     //                             $value2[1] = $customNotification->getMaxValue();
  110.     //                         } else {
  111.     //                             $value2 = $customNotification->getMaxValue();
  112.     //                         }
  114.     //                         $value = $qualifiedLocation['value'];
  116.     //                         $resultArr[$qualifiedLocation["date"]][$alertName] = $qualifiedLocation;
  118.     //                         if (\App\Lib\Utility::compareValues($customNotification->getCalculate(), $value, $value2)) {
  119.     //                             $resultArr1[] = [
  120.     //                                 'custom_notification_id' => $customNotification->getId(),
  121.     //                                 'custom_notification_id' => $customNotification->getId(),
  122.     //                                 "custom_notification_color" => $customNotification->getColor(),
  123.     //                                 "date" => $qualifiedLocation['date'],
  124.     //                                 "location_name" => $location->getName(),
  125.     //                                 "location_title" => $location->getTitle(),
  126.     //                                 "custom_notification_title" => $customNotification->getTitle(),
  127.     //                                 "location_id" => $location->getId(),
  128.     //                                 "parameter" => $parameter,
  129.     //                                 "name" => $alertName,
  130.     //                                 "nameAr" => $alertNameAr,
  131.     //                                 "calculation_type" => $customNotification->getCalculate(),
  132.     //                                 "calculation_type_label" => isset($calculateOption[$customNotification->getCalculate()]) ? $calculateOption[$customNotification->getCalculate()] : "",
  133.     //                                 "user_value" => $value2,
  134.     //                                 'received_value' => $value,
  135.     //                                 "matched" => true
  136.     //                             ];
  137.     //                         } else {
  138.     //                             $resultArr1[] = [
  139.     //                                 'custom_notification_id' => $customNotification->getId(),
  140.     //                                 "custom_notification_color" => $customNotification->getColor(),
  141.     //                                 "date" => $qualifiedLocation['date'],
  142.     //                                 "location_name" => $location->getName(),
  143.     //                                 "location_title" => $location->getTitle(),
  144.     //                                 "custom_notification_title" => $customNotification->getTitle(),
  145.     //                                 "location_id" => $location->getId(),
  146.     //                                 "parameter" => $parameter,
  147.     //                                 "name" => $alertName,
  148.     //                                 "nameAr" => $alertNameAr,
  149.     //                                 "calculation_type" => $customNotification->getCalculate(),
  150.     //                                 "calculation_type_label" => isset($calculateOption[$customNotification->getCalculate()]) ? $calculateOption[$customNotification->getCalculate()] : "",
  151.     //                                 "user_value" => $value2,
  152.     //                                 'received_value' => $value,
  153.     //                                 "matched" => false
  154.     //                             ];
  155.     //                         }
  156.     //                     }
  157.     //                 }
  158.     //             }
  159.     //         }
  160.     //     }
  162.     //     $rawArr = array_values($resultArr1);
  163.     //     $organizedData = [];
  164.     //     $matchedAlert = [];
  165.     //     $timezone = new \DateTimeZone("Asia/Riyadh");
  167.     //     foreach ($rawArr as $entry) {
  168.     //         $notification = $entry;
  170.     //         // Parse the date with DateTime and adjust timezone
  171.     //         $notificationDate = new \DateTime($notification['date'], new \DateTimeZone("UTC"));
  172.     //         $notificationDate->modify('-6 hours');
  173.     //         $notificationDate->setTimezone($timezone);
  175.     //         // Format date components for use in organizedData
  176.     //         $notification['date'] = $notificationDate->format("Y-m-d\TH:00:00\Z");
  177.     //         $notificationId = $notification['custom_notification_id'];
  178.     //         $date = $notificationDate->format("Y-m-d");
  179.     //         $time = $notificationDate->format("H:i");
  180.     //         $day = $notificationDate->format("D");
  182.     //         if (!isset($matchedAlert[$date . $notificationId]) || $notification['matched'] == true) {
  183.     //             $matchedAlert[$date . $notificationId] = $notification['matched'];
  184.     //         }
  186.     //         // Initialize the main array element for this notification ID if not already done
  187.     //         if (!isset($organizedData[$notificationId])) {
  188.     //             $organizedData[$notificationId] = [
  189.     //                 "custom_notification_title" => $notification['custom_notification_title'],
  190.     //                 "location_title" => $notification['location_title'],
  191.     //                 "alerts" => [],
  192.     //                 "user_value" => $notification['user_value'], // Static value, change as needed
  193.     //                 "calculation_type" => $notification['calculation_type'],
  194.     //                 "calculation_type_label" => $notification['calculation_type_label'],
  195.     //                 "parameterName" => $notification['parameter'],
  196.     //                 "parameterTitleEn" => $notification['name'],
  197.     //                 "parameterTitleAr" => $notification['nameAr'],
  198.     //             ];
  199.     //         }
  201.     //         // Initialize the date array element if not already done
  202.     //         if (!isset($organizedData[$notificationId]['alerts'][$date])) {
  203.     //             $organizedData[$notificationId]['alerts'][$date] = [
  204.     //                 'date' => $date,
  205.     //                 'day' => $day,
  206.     //                 'rawDate' => $notification['date'],
  207.     //                 'data' => []
  208.     //             ];
  209.     //         }
  210.     //         $organizedData[$notificationId]['alerts'][$date]["isAlertPresent"] = $matchedAlert[$date . $notificationId];
  212.     //         // Append time data to the corresponding date
  213.     //         $organizedData[$notificationId]['alerts'][$date]['data'][] = [
  214.     //             'fromInterval' => $notification['date'],
  215.     //             'toInterval' => $notification['date'],
  216.     //             'data' => $notification
  217.     //         ];
  218.     //     }
  221.     //     return ["success" => true, "data" => array_values($organizedData), "paginationVariables" => $paginator->getPaginationData()];
  222.     // }
  224.     public function getCalendarNotification(MeteomaticsWeatherService $mateoMaticsService, $user, $customNotificationIds, $startDate, $endDate, $hour, $page, $size, $title, $paginator, $translator, $tagIds = '', $location = '', $locationTagName): array
  225.     {
  226.         // Set timezone to Asia/Riyadh
  227.         $timezone = new \DateTimeZone("Asia/Riyadh");
  229.         // Convert start and end dates to Asia/Riyadh timezone
  230.         $startDateObj = new \DateTime($startDate, $timezone);
  231.         $endDateObj = new \DateTime($endDate, $timezone);
  233.         $pageSize = isset($size) ? $size : LIMIT_PER_PAGE;
  234.         $page = isset($page) ? $page : 1;
  236.         $qualifiedLocations = [];
  237.         $locationModel = new LocationModel();
  238.         $ewsNotificationModel = new EwsNotificationModel();
  239.         $options = [];
  240.         $calculateOption = [];
  241.         $customNotificationListing = new DataObject\CustomNotification\Listing();
  243.         foreach ($customNotificationListing->getClass()->getFieldDefinitions() as $fieldDefionition) {
  244.             if ($fieldDefionition->getName() == "calculate") {
  245.                 $options = $fieldDefionition->getOptions();
  246.             }
  247.         }
  248.         if ($options) {
  249.             foreach ($options as $optionKey => $option) {
  250.                 $calculateOption[$option['value']] = $option['key'];
  251.             }
  252.         }
  254.         // Check if $customNotificationIds is empty and return a message if so
  255.         if (empty($customNotificationIds)) {
  256.             return ['success' => false, 'message' => $translator->trans("you_do_not_have_any_notification_configured")];
  257.         }
  259.         $customNotification = new DataObject\CustomNotification\Listing();
  260.         $customNotification->addConditionParam('o_id IN (' . $customNotificationIds . ')');
  261.         $customNotification->filterByUser($user);
  262.         $customNotification->setOrderKey("o_id");
  263.         $customNotification->setOrder("desc");
  265.         if (!empty($title)) {
  266.             $customNotification->addConditionParam("title like '%$title%' ");
  267.         }
  268.         if (!empty($tagIds)) {
  269.             $customNotification->addConditionParam('tag__id IN (' . $tagIds . ')');
  270.         }
  272.         // filter for location title
  273.         if (!empty($location)) {
  274.             $db = \Pimcore\Db::get();
  275.             $locationIds = $db->fetchFirstColumn(
  276.                 "SELECT l.oo_id FROM object_query_location AS l WHERE l.title LIKE :location;",
  277.                 [
  278.                     'location' => '%' . $location . '%',
  279.                 ]
  280.             );
  281.             if (!empty($locationIds)) {
  282.                 // Combine conditions with OR
  283.                 $conditions = [];
  284.                 if (!empty($locationIds)) {
  285.                     $conditions[] = 'location__id IN (' . implode(",", $locationIds) . ')';
  286.                 }
  287.                 if (!empty($tagIds)) {
  288.                     $conditions[] = 'tag__id IN (' . implode(",", $tagIds) . ')';
  289.                 }
  290.                 $customNotification->addConditionParam(implode(" OR ", $conditions));
  291.             } else {
  292.                 return ['success' => false, 'message' => $translator->trans("you_do_not_have_any_notification_configured_for_this_location")];
  293.             }
  294.         }
  296.         // filter for location name
  297.         if (!empty($locationTagName)) {
  298.             $db = \Pimcore\Db::get();
  299.            
  300.             $tagIds = $db->fetchFirstColumn(
  301.                 "SELECT ooo_id 
  302.                 FROM object_localized_data_Tags
  303.                 WHERE language = :language AND TagName LIKE :tagName",
  304.                 [
  305.                     'language' => $translator->getLocale(),
  306.                     'tagName' => '%' . $location . '%'
  307.                 ]
  308.             );
  309.             if (!empty($tagIds)) {
  310.                 // Combine conditions with OR
  311.                 $conditions = [];
  312.                 if (!empty($locationIds)) {
  313.                     $conditions[] = 'location__id IN (' . implode(",", $locationIds) . ')';
  314.                 }
  315.                 if (!empty($tagIds)) {
  316.                     $conditions[] = 'tag__id IN (' . implode(",", $tagIds) . ')';
  317.                 }
  318.                 $customNotification->addConditionParam(implode(" OR ", $conditions));
  319.             } else {
  320.                 return ['success' => false, 'message' => $translator->trans("you_do_not_have_any_notification_configured_for_this_location")];
  321.             }
  322.         }
  325.         $paginator = $paginator->paginate(
  326.             $customNotification,
  327.             $page,
  328.             $pageSize
  329.         );
  330.         $customNotifications = $paginator->count();
  331.         if (!$customNotifications) {
  332.             return ['success' => false, 'message' => $translator->trans("you_do_not_have_any_notification_configured_for_this_location")];
  333.         }
  335.         $resultArr = [];
  336.         $resultArr1 = [];
  338.         $comparableStartDate = $startDateObj;
  339.         $comparableEndDate = $endDateObj;
  340.         $startDateFormatted = $startDateObj->format('Y-m-d\T00:00:00.v\Z');
  341.         $endDateObj->modify("+3 hours");
  342.         $endDateFormatted = $endDateObj->format('Y-m-d\T00:00:00.v\Z');
  344.         foreach ($paginator as $customNotification) {
  345.             $user = $customNotification->getUser();
  346.             $location = $customNotification->getLocation();
  348.             if ($location instanceof DataObject\Location) {
  349.                 $coOrdinates = json_decode($location->getCoOrdinates(), true);
  351.                 if ($coOrdinates && count($coOrdinates)) {
  352.                     if (!$customNotification->getAlert()) {
  353.                         continue;
  354.                     }
  356.                     $parameter = $customNotification->getAlert()->getMeteoMaticsKey();
  357.                     $alertName = $customNotification->getAlert()->getName("en");
  358.                     $alertNameAr = $customNotification->getAlert()->getName("ar");
  359.                     $model = !empty($customNotification->getWeatherModel()) ? $customNotification->getWeatherModel() : "mix";
  361.                     // Format dates for Meteomatics request with Asia/Riyadh timezone
  362.                     /*$startDateFormatted = $startDateObj->format('Y-m-d\T00:00:00.v\Z');
  363.             $endDateObj->modify("+3 hours");
  364.             $endDateFormatted = $endDateObj->format('Y-m-d\T00:00:00.v\Z');*/
  366.                     $response = $mateoMaticsService->getTempratureByParamsHourly($coOrdinates, $startDateFormatted, $endDateFormatted, $parameter, $hour, $model, $timezone);
  367.                     $qualifiedLocations = $response['data'][0]['coordinates'][0]['dates'];
  369.                     if (is_array($response) && isset($response['data'][0]['parameter']) && $response['data'][0]['parameter'] == $parameter) {
  371.                         foreach ($qualifiedLocations as $key => $qualifiedLocation) {
  372.                             $qualifiedDate = new \DateTime($qualifiedLocation["date"], $timezone);
  374.                             // Check if the qualified date falls within the start and end dates
  375.                             //                var_dump("Qualified-Data : ". $qualifiedDate->format("Y-m-d")." --- ".$comparableEndDate->format("Y-m-d"));
  376.                             if ($qualifiedDate < $comparableStartDate || $qualifiedDate > $comparableEndDate) {
  377.                                 continue; // Skip if date is out of the specified range
  378.                             }
  380.                             if ($customNotification->getCalculate() == "range") {
  381.                                 $value2 = [];
  382.                                 $value2[0] = $customNotification->getMinValue();
  383.                                 $value2[1] = $customNotification->getMaxValue();
  384.                             } else {
  385.                                 $value2 = $customNotification->getMaxValue();
  386.                             }
  388.                             $value = $qualifiedLocation['value'];
  390.                             $resultArr[$qualifiedLocation["date"]][$alertName] = $qualifiedLocation;
  392.                             if (\App\Lib\Utility::compareValues($customNotification->getCalculate(), $value, $value2)) {
  393.                                 $resultArr1[] = [
  394.                                     'custom_notification_id' => $customNotification->getId(),
  395.                                     "custom_notification_color" => $customNotification->getColor(),
  396.                                     'model' => $customNotification->getWeatherModel(),
  397.                                     'unit' => $customNotification->getUnits(),
  398.                                     'unit_en' => $customNotification->getAlert()?->getUnitTitle(),
  399.                                     'unit_ar' => (\App\Lib\Utility::getArabicTranslationUnits($customNotification->getAlert()?->getUnitTitle())),
  400.                                     "date" => $qualifiedLocation['date'],
  401.                                     "location_name" => $location->getName(),
  402.                                     "location_title" => $location->getTitle(),
  403.                                     "custom_notification_title" => $customNotification->getTitle(),
  404.                                     "location_id" => $location->getId(),
  405.                                     "parameter" => $parameter,
  406.                                     "name" => $alertName,
  407.                                     "nameAr" => $alertNameAr,
  408.                                     "calculation_type" => $customNotification->getCalculate(),
  409.                                     'calculculation_type_ar' => (\App\Lib\Utility::getArabicTranslation($customNotification->getCalculate(), CUSTOM_NOTIFICATION_CONDITION) ? \App\Lib\Utility::getArabicTranslation($customNotification->getCalculate(), CUSTOM_NOTIFICATION_CONDITION) : ''),
  410.                                     "calculation_type_label" => isset($calculateOption[$customNotification->getCalculate()]) ? $calculateOption[$customNotification->getCalculate()] : "",
  411.                                     "calculation_type_label" => $calculateOption[$customNotification->getCalculate()] ?? "",
  412.                                     "user_value" => $value2,
  413.                                     'received_value' => $value,
  414.                                     "matched" => true
  415.                                 ];
  416.                             } else {
  417.                                 $resultArr1[] = [
  418.                                     'custom_notification_id' => $customNotification->getId(),
  419.                                     "custom_notification_color" => $customNotification->getColor(),
  420.                                     'model' => $customNotification->getWeatherModel(),
  421.                                     'unit' => $customNotification->getUnits(),
  422.                                     'unit_en' => $customNotification->getAlert()?->getUnitTitle(),
  423.                                     'unit_ar' => (\App\Lib\Utility::getArabicTranslationUnits($customNotification->getAlert()?->getUnitTitle())),
  424.                                     "date" => $qualifiedLocation['date'],
  425.                                     "location_name" => $location->getName(),
  426.                                     "location_title" => $location->getTitle(),
  427.                                     "custom_notification_title" => $customNotification->getTitle(),
  428.                                     "location_id" => $location->getId(),
  429.                                     "parameter" => $parameter,
  430.                                     "name" => $alertName,
  431.                                     "nameAr" => $alertNameAr,
  432.                                     "calculation_type" => $customNotification->getCalculate(),
  433.                                     'calculculation_type_ar' => (\App\Lib\Utility::getArabicTranslation($customNotification->getCalculate(), CUSTOM_NOTIFICATION_CONDITION) ? \App\Lib\Utility::getArabicTranslation($customNotification->getCalculate(), CUSTOM_NOTIFICATION_CONDITION) : ''),
  434.                                     "calculation_type_label" => isset($calculateOption[$customNotification->getCalculate()]) ? $calculateOption[$customNotification->getCalculate()] : "",
  435.                                     "calculation_type_label" => $calculateOption[$customNotification->getCalculate()] ?? "",
  436.                                     "user_value" => $value2,
  437.                                     'received_value' => $value,
  438.                                     "matched" => false
  439.                                 ];
  440.                             }
  441.                         }
  442.                     }
  443.                 }
  444.             }
  445.         }
  447.         $rawArr = array_values($resultArr1);
  448.         $organizedData = [];
  449.         $matchedAlert = [];
  450.         $timezone = new \DateTimeZone("Asia/Riyadh");
  451.         foreach ($rawArr as $entry) {
  452.             $notification = $entry;
  453.             // Parse the date with DateTime and adjust timezone
  454.             $notificationDate = new \DateTime($notification['date'], $timezone);
  456.             $notification['date'] = $notificationDate->format("Y-m-d\TH:00:00\Z");
  457.             $notificationId = $notification['custom_notification_id'];
  458.             $date = $notificationDate->format("Y-m-d");
  459.             $time = $notificationDate->format("H:i");
  460.             $day = $notificationDate->format("D");
  461.             if (!isset($matchedAlert[$date . $notificationId]) || $notification['matched'] == true) {
  462.                 $matchedAlert[$date . $notificationId] = $notification['matched'];
  463.             }
  465.             // Initialize the main array element for this notification ID if not already done
  466.             if (!isset($organizedData[$notificationId])) {
  467.                 $organizedData[$notificationId] = [
  468.                     "custom_notification_title" => $notification['custom_notification_title'],
  469.                     "location_title" => $notification['location_title'],
  470.                     "tag_name" => $customNotification->getTag() ? $customNotification->getTag()->getTagName() : "",
  471.                     "alerts" => [],
  472.                     "user_value" => $notification['user_value'], // Static value, change as needed
  473.                     "calculation_type" => $notification['calculation_type'],
  474.                     'calculculation_type_ar' => (\App\Lib\Utility::getArabicTranslation($customNotification->getCalculate(), CUSTOM_NOTIFICATION_CONDITION) ? \App\Lib\Utility::getArabicTranslation($customNotification->getCalculate(), CUSTOM_NOTIFICATION_CONDITION) : ''),
  475.                     "calculation_type_label" => $notification['calculation_type_label'],
  476.                     "parameterName" => $notification['parameter'],
  477.                     "parameterTitleEn" => $notification['name'],
  478.                     "parameterTitleAr" => $notification['nameAr'],
  479.                     'unit' => $notification['unit'],
  480.                     'unit_en' => $notification['unit_en'],
  481.                     'unit_ar' => $notification['unit_ar'],
  483.                 ];
  484.             }
  486.             // Initialize the date array element if not already done
  487.             if (!isset($organizedData[$notificationId]['alerts'][$date])) {
  488.                 $organizedData[$notificationId]['alerts'][$date] = [
  489.                     'date' => $date,
  490.                     'day' => $day,
  491.                     'rawDate' => $notification['date'],
  492.                     'data' => []
  493.                 ];
  494.             }
  495.             $organizedData[$notificationId]['alerts'][$date]["isAlertPresent"] = $matchedAlert[$date . $notificationId];
  497.             // Append time data to the corresponding date
  498.             $organizedData[$notificationId]['alerts'][$date]['data'][] = [
  499.                 'fromInterval' => $notification['date'],
  500.                 'toInterval' => $notification['date'],
  501.                 'data' => $notification
  502.             ];
  503.         }
  504.         return ["success" => true, "data" => array_values($organizedData), "paginationVariables" => $paginator->getPaginationData()];
  505.     }
  508.     // public function getAdvanceCalendarNotification(MeteomaticsWeatherService $mateoMaticsService, $user, $advanceCustomNotificationIds, $startDate, $endDate, $hour, $page, $size, $title, $paginator, $translator): array
  509.     // {
  512.     //     $qualifiedLocations = [];
  513.     //     $advanceCustomNotifications = new DataObject\AdvanceCustomNotification\Listing();
  514.     //     $advanceCustomNotifications->addConditionParam('o_id IN (' . $advanceCustomNotificationIds . ')');
  515.     //     $advanceCustomNotifications->addConditionParam('owner__id = ? OR user LIKE ? ', [$user->getId(), '%,' . $user->getId() . ',%']);
  516.     //     $advanceCustomNotifications->setOrderKey("o_id");
  517.     //     $advanceCustomNotifications->setOrder("desc");
  518.     //     if (!empty($title)) {
  519.     //         $advanceCustomNotifications->addConditionParam("notificationName like '%$title%' ");
  520.     //     }
  523.     //     $totalAdvanceCustomNotifications = $advanceCustomNotifications->count();
  524.     //     if (!$totalAdvanceCustomNotifications) {
  525.     //         // throw new \Exception("You do not have any notification configured for this location");
  526.     //         return ['success' => false, 'message' => $translator->trans("you_do_not_have_any_advance_custom_notification_configured")];
  527.     //     }
  529.     //     $resultArr = [];
  530.     //     $resultArr1 = [];
  531.     //     foreach ($advanceCustomNotifications as $advanceCustomNotification) {
  534.     //         $finalResult = false;
  535.     //         $data = [];
  536.     //         $groupData = [];
  537.     //         $rules = $advanceCustomNotification->getNotificationConfig();
  538.     //         $groupConditions = [];
  539.     //         $ruleCondition = [];
  540.     //         $ruleValues = [];
  541.     //         $groupRuleCondition = [];
  542.     //         $groupRuleValues = [];
  543.     //         $groupValues = [];
  544.     //         $sequence = [];
  546.     //         if ($rules) {
  547.     //             foreach ($rules as $ruleConfig) {
  549.     //                 if ($ruleConfig->getRuleType() == 'rule') {
  550.     //                     if ($ruleConfig->getRulecondition() != null) {
  551.     //                         $ruleCondition[] = $ruleConfig->getRulecondition();
  552.     //                     }
  553.     //                     try {
  554.     //                         $result = $this->getMeteomaticData($ruleConfig, $startDate, $endDate);
  557.     //                         if (!empty($result)) {
  558.     //                             $data[] = $result;
  559.     //                             $ruleValues[] = true;
  560.     //                             $sequence[] = [
  561.     //                                 'name' => $ruleConfig->getName(),
  562.     //                                 'condition' => $ruleConfig->getRuleCondition(),
  563.     //                                 'type' => 'rule',
  564.     //                                 'value' => true
  565.     //                             ];
  566.     //                         } else {
  567.     //                             $ruleValues[] = false;
  568.     //                             $sequence[] = [
  569.     //                                 'name' => $ruleConfig->getName(),
  570.     //                                 'condition' => $ruleConfig->getRuleCondition(),
  571.     //                                 'type' => 'rule',
  572.     //                                 'value' => false
  573.     //                             ];
  574.     //                         }
  575.     //                         $alertName = $result['alertName'];
  577.     //                         $qualifiedLocations = $result['data']['data'][0]['coordinates'][0]['dates'];
  579.     //                         if (is_array($result) && isset($result['data']['data'][0]['parameter']) && $result['data']['data'][0]['parameter'] = $result['parameterKey']) {
  581.     //                             foreach ($qualifiedLocations as $key => $qualifiedLocation) {
  583.     //                                 if ($ruleConfig->getCondition() == "range") {
  584.     //                                     $value2 = [];
  585.     //                                     $value2[0] = $ruleConfig->getConditionValueMin();
  586.     //                                     $value2[1] = $ruleConfig->getConditionValueMax();
  587.     //                                 } else {
  588.     //                                     $value2 = $ruleConfig->getConditionValueMin();
  589.     //                                 }
  592.     //                                 $value = $qualifiedLocation['value'];
  594.     //                                 $resultArr[$qualifiedLocation["date"]][$alertName] = $qualifiedLocation;
  596.     //                                 if ($result['comparedValue']) {
  598.     //                                     $resultArr1[] = [
  599.     //                                         "type" => "rule",
  600.     //                                         'name' => $ruleConfig->getName(),
  601.     //                                         'rule_condition' => $ruleConfig->getRuleCondition(),
  602.     //                                         'advance_custom_notification_id' => $advanceCustomNotification->getId(),
  603.     //                                         "date" => $qualifiedLocation['date'],
  604.     //                                         "location_id" => $ruleConfig->getLocation()?->getId(),
  605.     //                                         "location_name" => $ruleConfig->getLocation()?->getName(),
  606.     //                                         "location_title" => $ruleConfig->getLocation()?->getTitle(),
  607.     //                                         "advance_custom_notification_title" => $advanceCustomNotification->getNotificationName("en"),
  608.     //                                         "parameter" => $ruleConfig->getParameter()->getParamName("en"),
  610.     //                                         "calculation_type" => $ruleConfig->getCondition(),
  611.     //                                         "calculation_type_label" => isset($calculateOption[$ruleConfig->getCondition()]) ? $calculateOption[$ruleConfig->getCondition()] : "",
  612.     //                                         "user_value" => $value2,
  613.     //                                         'received_value' => $value,
  614.     //                                         "matched" => true
  615.     //                                     ];
  616.     //                                 } else {
  618.     //                                     $resultArr1[] = [
  619.     //                                         "type" => "rule",
  620.     //                                         'name' => $ruleConfig->getName(),
  621.     //                                         'rule_condition' => $ruleConfig->getRuleCondition(),
  622.     //                                         'advance_custom_notification_id' => $advanceCustomNotification->getId(),
  623.     //                                         "date" => $qualifiedLocation['date'],
  624.     //                                         "location_id" => $ruleConfig->getLocation()->getId(),
  625.     //                                         "location_name" => $ruleConfig->getLocation()?->getName(),
  626.     //                                         "location_title" => $ruleConfig->getLocation()?->getTitle(),
  627.     //                                         "advance_custom_notification_title" => $advanceCustomNotification->getNotificationName("en"),
  628.     //                                         "parameter" => $ruleConfig->getParameter()->getParamName("en"),
  630.     //                                         "calculation_type" => $ruleConfig->getCondition(),
  631.     //                                         "calculation_type_label" => isset($calculateOption[$ruleConfig->getCondition()]) ? $calculateOption[$ruleConfig->getCondition()] : "",
  632.     //                                         "user_value" => $value2,
  633.     //                                         'received_value' => $value,
  634.     //                                         "matched" => false
  635.     //                                     ];
  636.     //                                 }
  637.     //                             }
  638.     //                         }
  639.     //                         if (!empty($result)) {
  640.     //                             $data[] = $result;
  641.     //                             $ruleValues[] = true;
  642.     //                             $sequence[] = [
  643.     //                                 'name' => $ruleConfig->getName(),
  644.     //                                 'condition' => $ruleConfig->getRuleCondition(),
  645.     //                                 'type' => 'rule',
  646.     //                                 'value' => true
  647.     //                             ];
  648.     //                         } else {
  649.     //                             $ruleValues[] = false;
  650.     //                             $sequence[] = [
  651.     //                                 'name' => $ruleConfig->getName(),
  652.     //                                 'condition' => $ruleConfig->getRuleCondition(),
  653.     //                                 'type' => 'rule',
  654.     //                                 'value' => false
  655.     //                             ];
  656.     //                         }
  657.     //                     } catch (\Exception $e) {
  658.     //                         $msg = $e->getMessage();
  659.     //                         // $output->write("<fg=red>$msg</>");
  660.     //                         continue;
  661.     //                         // return Command::FAILURE;
  662.     //                     }
  663.     //                 } else {
  664.     //                     if ($ruleConfig->getRulecondition() != null) {
  665.     //                         $groupRuleCondition[$ruleConfig->getName()][] = $ruleConfig->getRulecondition();
  666.     //                     }
  667.     //                     $groupConditions[$ruleConfig->getName()] = $ruleConfig->getGroupcondition();
  668.     //                     try {
  670.     //                         $result = $this->getMeteomaticData($ruleConfig, $startDate, $endDate);
  672.     //                         if (!empty($result)) {
  673.     //                             $groupData[$ruleConfig->getName()][] = $result;
  674.     //                             $groupRuleValues[$ruleConfig->getName()][] = true;
  675.     //                         } else {
  676.     //                             $groupRuleValues[$ruleConfig->getName()][] = false;
  677.     //                         }
  678.     //                         $alertName = $result['alertName'];
  680.     //                         $qualifiedLocations = $result['data']['data'][0]['coordinates'][0]['dates'];
  682.     //                         if (is_array($result) && isset($result['data']['data'][0]['parameter']) && $result['data']['data'][0]['parameter'] = $result['parameterKey']) {
  684.     //                             foreach ($qualifiedLocations as $key => $qualifiedLocation) {
  686.     //                                 if ($ruleConfig->getCondition() == "range") {
  687.     //                                     $value2 = [];
  688.     //                                     $value2[0] = $ruleConfig->getConditionValueMin();
  689.     //                                     $value2[1] = $ruleConfig->getConditionValueMax();
  690.     //                                 } else {
  691.     //                                     $value2 = $ruleConfig->getConditionValueMin();
  692.     //                                 }
  695.     //                                 $value = $qualifiedLocation['value'];
  697.     //                                 $resultArr[$qualifiedLocation["date"]][$alertName] = $qualifiedLocation;
  699.     //                                 if ($result['comparedValue']) {
  701.     //                                     $resultArr1[] = [
  702.     //                                         "type" => "Group",
  703.     //                                         'name' => $ruleConfig->getName(),
  704.     //                                         'rule_condition' => $ruleConfig->getRuleCondition(),
  705.     //                                         'group_condition' => $ruleConfig->getGroupCondition(),
  706.     //                                         'advance_custom_notification_id' => $advanceCustomNotification->getId(),
  707.     //                                         "date" => $qualifiedLocation['date'],
  708.     //                                         "location_id" => $ruleConfig->getLocation()?->getId(),
  709.     //                                         "location_name" => $ruleConfig->getLocation()?->getName(),
  710.     //                                         "location_title" => $ruleConfig->getLocation()?->getTitle(),
  711.     //                                         "advance_custom_notification_title" => $advanceCustomNotification->getNotificationName("en"),
  712.     //                                         "parameter" => $ruleConfig->getParameter()->getParamName("en"),
  714.     //                                         "calculation_type" => $ruleConfig->getCondition(),
  715.     //                                         "calculation_type_label" => isset($calculateOption[$ruleConfig->getCondition()]) ? $calculateOption[$ruleConfig->getCondition()] : "",
  716.     //                                         "user_value" => $value2,
  717.     //                                         'received_value' => $value,
  718.     //                                         "matched" => true
  719.     //                                     ];
  720.     //                                 } else {
  722.     //                                     $resultArr1[] = [
  723.     //                                         "type" => "Group",
  724.     //                                         'name' => $ruleConfig->getName(),
  725.     //                                         'rule_condition' => $ruleConfig->getRuleCondition(),
  726.     //                                         'group_condition' => $ruleConfig->getGroupCondition(),
  727.     //                                         'advance_custom_notification_id' => $advanceCustomNotification->getId(),
  728.     //                                         "date" => $qualifiedLocation['date'],
  729.     //                                         "location_id" => $ruleConfig->getLocation()->getId(),
  730.     //                                         "location_name" => $ruleConfig->getLocation()?->getName(),
  731.     //                                         "location_title" => $ruleConfig->getLocation()?->getTitle(),
  732.     //                                         "advance_custom_notification_title" => $advanceCustomNotification->getNotificationName("en"),
  733.     //                                         "parameter" => $ruleConfig->getParameter()->getParamName("en"),
  735.     //                                         "calculation_type" => $ruleConfig->getCondition(),
  736.     //                                         "calculation_type_label" => isset($calculateOption[$ruleConfig->getCondition()]) ? $calculateOption[$ruleConfig->getCondition()] : "",
  737.     //                                         "user_value" => $value2,
  738.     //                                         'received_value' => $value,
  739.     //                                         "matched" => false
  740.     //                                     ];
  741.     //                                 }
  742.     //                             }
  743.     //                         }
  744.     //                         if (!empty($result)) {
  745.     //                             $data[] = $result;
  746.     //                             $ruleValues[] = true;
  747.     //                             $sequence[] = [
  748.     //                                 'name' => $ruleConfig->getName(),
  749.     //                                 'condition' => $ruleConfig->getRuleCondition(),
  750.     //                                 'type' => 'rule',
  751.     //                                 'value' => true
  752.     //                             ];
  753.     //                         } else {
  754.     //                             $ruleValues[] = false;
  755.     //                             $sequence[] = [
  756.     //                                 'name' => $ruleConfig->getName(),
  757.     //                                 'condition' => $ruleConfig->getRuleCondition(),
  758.     //                                 'type' => 'rule',
  759.     //                                 'value' => false
  760.     //                             ];
  761.     //                         }
  762.     //                     } catch (\Exception $e) {
  763.     //                         $msg = $e->getMessage();
  764.     //                         // $output->write("<fg=red>$msg</>");
  765.     //                         continue;
  766.     //                         // return Command::FAILURE;
  767.     //                     }
  768.     //                 }
  769.     //             }
  770.     //         }
  772.     //         if ($groupRuleValues) {
  773.     //             foreach ($groupRuleValues as $group => $values) {
  774.     //                 if (isset($groupRuleCondition[$group])) {
  775.     //                     $result = \App\Lib\Utility::evaluateConditions($values, $groupRuleCondition[$group]);
  776.     //                     $groupValues[$group] = $result;
  777.     //                     $sequence[] = [
  778.     //                         'name' => $group,
  779.     //                         'condition' => $groupConditions[$group],
  780.     //                         'type' => 'group',
  781.     //                         'value' => $groupValues[$group]
  782.     //                     ];
  783.     //                     if ($result) {
  784.     //                         $data = array_merge($data, array_values($groupData[$group]));
  785.     //                     }
  786.     //                 } else {
  788.     //                     $groupValues[$group] = $values[0];
  789.     //                     $sequence[] = [
  790.     //                         'name' => $group,
  791.     //                         'condition' => $groupConditions[$group],
  792.     //                         'type' => 'group',
  793.     //                         'value' => $values[0]
  794.     //                     ];
  795.     //                     if ($values[0]) {
  796.     //                         foreach (array_values($groupData[$group]) as $dataArray) {
  797.     //                             foreach ($dataArray as $dateKey => $value) {
  798.     //                                 array_push($data, [$dateKey => $value]);
  799.     //                             }
  800.     //                         }
  801.     //                     }
  802.     //                 }
  803.     //             }
  804.     //         }
  806.     //         $result = !empty($sequence) ? $sequence[0]['value'] : null;
  807.     //         if (count($sequence) > 1) {
  808.     //             // Start from the second element since the first one has no preceding condition
  809.     //             for ($i = 1; $i < count($sequence); $i++) {
  810.     //                 $currentElement = $sequence[$i];
  811.     //                 switch ($currentElement['condition']) {
  812.     //                     case "AND":
  813.     //                         $result = $result && $currentElement['value'];
  814.     //                         break;
  815.     //                     case "OR":
  816.     //                         $result = $result || $currentElement['value'];
  817.     //                         break;
  818.     //                 }
  819.     //             }
  820.     //         }
  821.     //         if ($result) {
  822.     //             $finalResult = true;
  823.     //         } else {
  824.     //             $finalResult = false;
  825.     //         }
  826.     //     }
  828.     //     $rawArr = array_values($resultArr1);
  829.     //     $organizedData = [];
  830.     //     $matchedAlert = [];
  831.     //     foreach ($rawArr as $entry) {
  832.     //         $notification = $entry;
  833.     //         $notificationId = $notification['advance_custom_notification_id'];
  834.     //         $date = date("Y-m-d", strtotime($notification['date']));
  835.     //         $time = date("H:i", strtotime($notification['date']));
  836.     //         $day = date("D", strtotime($notification['date']));
  837.     //         if (!isset($matchedAlert[$date . $notificationId]) || $notification['matched'] == true) {
  838.     //             $matchedAlert[$date . $notificationId] = $notification['matched'];
  839.     //         }
  840.     //         // Initialize the main array element for this notification ID if not already done
  841.     //         if (!isset($organizedData[$notificationId])) {
  842.     //             $organizedData[$notificationId] = [
  843.     //                 "advance_custom_notification_id" => $notification['advance_custom_notification_id'],
  844.     //                 "advance_custom_notification_title" => $notification['advance_custom_notification_title'],
  845.     //                 // "location_title" => $notification['location_title'],
  846.     //                 "alerts" => [],
  847.     //                 "user_value" => $notification['user_value'], // Static value, change as needed
  848.     //                 "calculation_type" => $notification['calculation_type'],
  849.     //                 "calculation_type_label" => $notification['calculation_type_label'],
  850.     //                 "parameterName" => $notification['parameter'],
  851.     //                 'finalResult' =>  $finalResult
  852.     //             ];
  853.     //         }
  855.     //         // Initialize the date array element if not already done
  856.     //         if (!isset($organizedData[$notificationId]['alerts'][$date])) {
  857.     //             $organizedData[$notificationId]['alerts'][$date] = [
  858.     //                 'date' => $date,
  859.     //                 'day' => $day,
  860.     //                 'rawDate' => $notification['date'],
  861.     //                 'data' => []
  862.     //             ];
  863.     //         }
  864.     //         $organizedData[$notificationId]['alerts'][$date]["isAlertPresent"] = $matchedAlert[$date . $notificationId];
  865.     //         // Append time data to the corresponding date
  866.     //         $organizedData[$notificationId]['alerts'][$date]['data'][] = [
  867.     //             'fromInterval' => $notification['date'],
  868.     //             'toInterval' => $notification['date'],
  869.     //             'data' => $notification,
  872.     //         ];
  873.     //     }
  875.     //     return ["success" => true, "data" => array_values($organizedData)];
  876.     // }
  879.     //     public function getAdvanceCalendarNotification(MeteomaticsWeatherService $mateoMaticsService, $user, $advanceCustomNotificationIds, $startDate, $endDate, $hour, $page, $size, $title, $paginator, $translator): array
  880.     // {
  881.     //     $qualifiedLocations = [];
  882.     //     $advanceCustomNotifications = new DataObject\AdvanceCustomNotification\Listing();
  883.     //     $advanceCustomNotifications->addConditionParam('o_id IN (' . $advanceCustomNotificationIds . ')');
  884.     //     $advanceCustomNotifications->filterByUser($user);
  885.     //     $advanceCustomNotifications->setOrderKey("o_id");
  886.     //     $advanceCustomNotifications->setOrder("desc");
  887.     //     if (!empty($title)) {
  888.     //         $advanceCustomNotifications->addConditionParam("notificationName like '%$title%' ");
  889.     //     }
  891.     //     $totalAdvanceCustomNotifications = $advanceCustomNotifications->count();
  892.     //     if (!$totalAdvanceCustomNotifications) {
  893.     //         return ['success' => false, 'message' => $translator->trans("you_do_not_have_any_advance_custom_notification_configured")];
  894.     //     }
  896.     //     $resultArr1 = [];
  897.     //     foreach ($advanceCustomNotifications as $advanceCustomNotification) {
  898.     //         $rules = $advanceCustomNotification->getNotificationConfig();
  899.     //         $ruleDates = [];
  900.     //         if ($rules) {
  901.     //             $data = [];
  902.     //             $ruleDates = [];
  904.     //             foreach ($rules as $ruleConfig) {
  905.     //                 $ruleId = $ruleConfig->getName() . '-' . $ruleConfig->getLocation()?->getName('en') . '-' . $ruleConfig->getParameter()?->getParamName("en") . '-' . $ruleConfig->getCondition();
  907.     //                 $ruleDetails = [
  908.     //                                     'ruleId' => $ruleId,
  909.     //                                     'ruleName' => $ruleConfig->getName(),
  910.     //                                     'ruleType' => $ruleConfig->getRuleType(),
  911.     //                                     'location' => $ruleConfig->getLocation()?->getName('en'),
  912.     //                                     'model' => $ruleConfig->getModelParam(),
  913.     //                                     'parameter' => $ruleConfig->getParameter()?->getParamName("en"),
  914.     //                                     'parameterKey' => $ruleConfig->getParameter()?->getParamKey(),
  915.     //                                     'timeInterval' => $ruleConfig->getTimeInterval(),
  916.     //                                     'condition' => $ruleConfig->getCondition(),
  917.     //                                     'conditionValueMax' => $ruleConfig->getConditionValueMax(),
  918.     //                                     'conditionValueMin' => $ruleConfig->getConditionValueMin(),
  919.     //                                 ];
  921.     //                                 $data[] = $ruleDetails;
  924.     //             }
  928.     //             return ["success" => true, "data" => $data];
  929.     //         }
  938.     //     }
  940.     //     return ["success" => true, "data" => $resultArr1];
  941.     // }
  944.     /**
  945.      * The main function that fetches, paginates, and processes notifications.
  946.      */
  947.     public function getAdvanceCalendarNotification(
  948.         MeteomaticsWeatherService $mateoMaticsService,
  949.         $user,
  950.         $advanceCustomNotificationIds,
  951.         $startDate,
  952.         $endDate,
  953.         $hour,
  954.         $page,
  955.         $size,
  956.         $title,
  957.         $paginator,
  958.         $translator,
  959.         $location = '',
  960.         $locationTagName
  961.     ): array {
  962.         // -----------------------------------------------------------
  963.         // 1) Basic validations
  964.         // -----------------------------------------------------------
  965.         if (empty($advanceCustomNotificationIds)) {
  966.             return [
  967.                 'success' => false,
  968.                 'message' => $translator->trans("you_do_not_have_any_advance_custom_notification_configured")
  969.             ];
  970.         }
  972.         // We use Asia/Riyadh as per your requirement
  973.         $timezone = new DateTimeZone("Asia/Riyadh");
  974.         $startDateObj = new DateTime($startDate, $timezone);
  975.         $endDateObj   = new DateTime($endDate, $timezone);
  977.         // -----------------------------------------------------------
  978.         // 2) Build the DataObject query
  979.         // -----------------------------------------------------------
  980.         $advanceCustomNotifications = new DataObject\AdvanceCustomNotification\Listing();
  981.         $advanceCustomNotifications->addConditionParam('o_id IN (' . $advanceCustomNotificationIds . ')');
  982.         // Only those owned by the user or shared with them
  983.         $advanceCustomNotifications->addConditionParam(
  984.             'owner__id = ? OR user LIKE ?',
  985.             [$user->getId(), '%,' . $user->getId() . ',%']
  986.         );
  988.         // Optional: Filter by title
  989.         if (!empty($title)) {
  990.             $advanceCustomNotifications->addConditionParam("notificationName like '%$title%' ");
  991.         }
  993.         // Optional: Filter by location Tag Name
  994.         if (!empty($locationTagName)) {
  995.             $db = \Pimcore\Db::get();
  996.             $tagIds = $db->fetchFirstColumn(
  997.                 "SELECT ooo_id
  998.                  FROM object_localized_data_Tags
  999.                  WHERE language = :language AND TagName LIKE :tagName",
  1000.                 [
  1001.                     'language' => $translator->getLocale(),
  1002.                     'tagName'  => '%' . $locationTagName . '%'
  1003.                 ]
  1004.             );
  1006.             if (!empty($tagIds)) {
  1007.                 $condition = 'locationTag__id IN (' . implode(",", $tagIds) . ')';
  1008.                 $advanceCustomNotifications->addConditionParam($condition);
  1009.             } 
  1010.         }
  1012.          // Optional: Filter by location
  1013.          if (!empty($location)) {
  1014.             $advanceCustomNotifications->addConditionParam("locationNames like '%$location%' ");
  1015.         }
  1017.         // Sorting
  1018.         $advanceCustomNotifications->setOrderKey("o_id");
  1019.         $advanceCustomNotifications->setOrder("desc");
  1021.         $totalAdvanceCustomNotifications = $advanceCustomNotifications->count();
  1022.         if (!$totalAdvanceCustomNotifications) {
  1023.             return [
  1024.                 'success' => false,
  1025.                 'message' => $translator->trans("you_do_not_have_any_advance_custom_notification_configured")
  1026.             ];
  1027.         }
  1029.         // -----------------------------------------------------------
  1030.         // 3) Pagination
  1031.         // -----------------------------------------------------------
  1032.         $pageSize  = $size ?? LIMIT_PER_PAGE;  // Adjust to your default
  1033.         $page      = $page ?? 1;
  1034.         $paginator = $paginator->paginate($advanceCustomNotifications, $page, $pageSize);
  1036.         // -----------------------------------------------------------
  1037.         // 4) Main loop over notifications
  1038.         // -----------------------------------------------------------
  1039.         $alertsData = [];
  1041.         foreach ($paginator as $advanceCustomNotification) {
  1042.             $rules = $advanceCustomNotification->getNotificationConfig();
  1043.             if (!$rules) {
  1044.                 // No rules, skip
  1045.                 continue;
  1046.             }
  1048.             // We'll accumulate day-based data:
  1049.             $ruleDates = [];
  1051.             // We'll also keep a sequence of T/F for each rule/group for top-level combination (AND/OR).
  1052.             $sequence  = [];
  1054.             // Handling groups
  1055.             $groupRuleValues    = [];  // groupName => [bool, bool, ...]
  1056.             $groupRuleCondition = [];  // groupName => e.g. ['AND','OR',...]
  1057.             $groupConditions    = [];  // groupName => 'AND' or 'OR'
  1058.             $groupArr           = [];
  1060.             $ruleIndex  = 1;
  1061.             $groupIndex = 0;
  1063.             // ---------------------------------------------
  1064.             // 4a) Process each rule in the notification
  1065.             // ---------------------------------------------
  1066.             foreach ($rules as $key => $ruleConfig) {
  1067.                 $name = 'Rule' . $ruleIndex;
  1069.                 // Call YOUR getMeteomaticData
  1070.                 // We pass in the same $timezone used above
  1071.                 try {
  1072.                     $result = $this->getMeteomaticData($ruleConfig, $startDateObj, $endDateObj, $timezone);
  1073.                 } catch (Exception $e) {
  1074.                     // Handle/log error
  1075.                     continue;
  1076.                 }
  1078.                 // If 'comparedValue' is not empty => that means the condition was matched at some level
  1079.                 // (per your custom compareValueofCustomNotification logic).
  1080.                 $isMatched = !empty($result['comparedValue']);
  1082.                 // Distinguish single rule vs. group
  1083.                 if ($ruleConfig->getRuleType() === 'group') {
  1084.                     $groupIndex++;
  1086.                     if ($ruleConfig->getRulecondition() != null) {
  1087.                         $groupRuleCondition[$ruleConfig->getName()][] = $ruleConfig->getRulecondition();
  1088.                     }
  1089.                     $groupArr[] = $ruleConfig->getName();
  1090.                     $groupConditions[$ruleConfig->getName()] = $ruleConfig->getGroupCondition();
  1092.                     // Store the sub-rule’s boolean
  1093.                     $groupRuleValues[$ruleConfig->getName()][] = $isMatched;
  1094.                 } else {
  1095.                     $ruleIndex++;
  1096.                     // Add a top-level entry for single rule
  1097.                     $sequence[] = [
  1098.                         'name'      => $ruleConfig->getName(),
  1099.                         'condition' => $ruleConfig->getRuleCondition(),
  1100.                         'type'      => 'rule',
  1101.                         'value'     => $isMatched
  1102.                     ];
  1103.                 }
  1105.                 // --------------------------------------------------
  1106.                 // Build day-by-day intervals from the returned data
  1107.                 // --------------------------------------------------
  1108.                 $datesData = $result['data']['data'][0]['coordinates'][0]['dates'] ?? [];
  1109.                 $ruleId    = $this->generateRuleId($ruleConfig, $key);
  1111.                 $intervalsPerDay = $this->buildDayIntervals($datesData, $ruleConfig);
  1113.                 // Insert these intervals into $ruleDates
  1114.                 foreach ($intervalsPerDay as $day => $intervals) {
  1115.                     if (!isset($ruleDates[$day])) {
  1116.                         $ruleDates[$day] = [];
  1117.                     }
  1119.                     // Build a standard data structure about this rule
  1120.                     $ruleDetails = [
  1121.                         'ruleIndex'  => ($ruleConfig->getRuleType() === 'group') ? $groupIndex : $ruleIndex,
  1122.                         'name'       => ($ruleConfig->getRuleType() === 'group')
  1123.                             ? "Rule{$groupIndex}"
  1124.                             : $name,
  1125.                         'ruleName'   => $ruleConfig->getName(),
  1126.                         'advanceCustomNotificationTitle' => $advanceCustomNotification->getNotificationName('en'),
  1127.                         'ruleId'     => $ruleId,
  1128.                         'ruleType'   => $ruleConfig->getRuleType(),
  1129.                         'location'   => $ruleConfig->getLocation()?->getTitle('en'),
  1130.                         'severity_code' => (
  1131.                             \App\Lib\Utility::getSeverityCode($advanceCustomNotification->getSeverity(), CUSTOM_NOTIFICATION_CONFIG_COLORS)
  1132.                             ?: ''
  1133.                         ),
  1134.                         'severity'       => $advanceCustomNotification->getSeverity(),
  1135.                         'severityAr'     => (
  1136.                             \App\Lib\Utility::getArabicTranslation($advanceCustomNotification->getSeverity(), CUSTOM_NOTIFICATION_CONFIG_COLORS)
  1137.                             ?: ''
  1138.                         ),
  1139.                         'model'          => $ruleConfig->getModelParam(),
  1140.                         'modelEn'        => (
  1141.                             \App\Lib\Utility::getArabicTranslationByKey('value', $ruleConfig->getModelParam(), CUSTOM_NOTIFICATION_MODEL_TYPE, 'en')
  1142.                             ?: ''
  1143.                         ),
  1144.                         'modelAr'        => (
  1145.                             \App\Lib\Utility::getArabicTranslationByKey('value', $ruleConfig->getModelParam(), CUSTOM_NOTIFICATION_MODEL_TYPE, 'ar')
  1146.                             ?: ''
  1147.                         ),
  1148.                         'unit'            => $ruleConfig->getParameterUnitKey(),
  1149.                         'unitAr'          => \App\Lib\Utility::getArabicTranslationUnits($ruleConfig->getParameterUnitKey()),
  1150.                         'parameterKey'    => $ruleConfig->getParameter()?->getParamKey(),
  1151.                         'parameter'       => $ruleConfig->getParameter()?->getParamName('en'),
  1152.                         'parameterAr'     => $ruleConfig->getParameter()?->getParamName('ar'),
  1153.                         'condition'       => $ruleConfig->getCondition(),
  1154.                         'conditionAr'     => (
  1155.                             \App\Lib\Utility::getArabicTranslation($ruleConfig->getCondition(), CUSTOM_NOTIFICATION_CONDITION)
  1156.                             ?: ''
  1157.                         ),
  1158.                         'timeInterval'    => $ruleConfig->getTimeInterval(),
  1159.                         'conditionValueMax' => $ruleConfig->getConditionValueMax(),
  1160.                         'conditionValueMin' => $ruleConfig->getConditionValueMin(),
  1161.                         'timeInDays'      => $ruleConfig->getTimeInDays(),
  1162.                         'ruleCondition'   => $ruleConfig->getRuleCondition(),
  1163.                         'groupCondition'  => $ruleConfig->getGroupCondition(),
  1164.                         'modelValue'      => $ruleConfig->getModelValue(),
  1165.                         'heightOrDepth'   => $ruleConfig->getHeightOrDepth(),
  1166.                         'rawDate'         => isset($intervals[0]) ? $intervals[0]['time'] : null,
  1167.                         'intervals'       => $intervals
  1168.                     ];
  1170.                     // If it's a group rule, nest it inside a group array
  1171.                     if ($ruleConfig->getRuleType() === 'group') {
  1172.                         $groupExists = false;
  1173.                         foreach ($ruleDates[$day] as &$existingGroup) {
  1174.                             if (isset($existingGroup['groupName']) && $existingGroup['groupName'] === $ruleConfig->getName()) {
  1175.                                 $existingGroup['rules'][] = $ruleDetails;
  1176.                                 $groupExists = true;
  1177.                                 break;
  1178.                             }
  1179.                         }
  1180.                         if (!$groupExists) {
  1181.                             $ruleDates[$day][] = [
  1182.                                 'groupName' => $ruleConfig->getName(),
  1183.                                 'rules'     => [$ruleDetails],
  1184.                             ];
  1185.                         }
  1186.                     } else {
  1187.                         // It's a normal rule
  1188.                         $ruleExists = false;
  1189.                         foreach ($ruleDates[$day] as &$existingRuleData) {
  1190.                             if (isset($existingRuleData['ruleId']) && $existingRuleData['ruleId'] === $ruleId) {
  1191.                                 $existingRuleData['intervals'] = array_merge($existingRuleData['intervals'], $intervals);
  1192.                                 $ruleExists = true;
  1193.                                 break;
  1194.                             }
  1195.                         }
  1196.                         if (!$ruleExists) {
  1197.                             $ruleDates[$day][] = $ruleDetails;
  1198.                         }
  1199.                     }
  1200.                 }
  1201.             } // end foreach $rules
  1203.             // ---------------------------------------------
  1204.             // 4b) Evaluate group booleans & push to $sequence
  1205.             // ---------------------------------------------
  1206.             if (!empty($groupRuleValues)) {
  1207.                 foreach ($groupRuleValues as $groupName => $values) {
  1208.                     if (isset($groupRuleCondition[$groupName])) {
  1209.                         // Evaluate using your custom group logic
  1210.                         $wholeGroupResult = \App\Lib\Utility::evaluateConditions(
  1211.                             $values,
  1212.                             $groupRuleCondition[$groupName]
  1213.                         );
  1214.                         $sequence[] = [
  1215.                             'name'      => $groupName,
  1216.                             'condition' => $groupConditions[$groupName] ?? null,
  1217.                             'type'      => 'group',
  1218.                             'value'     => $wholeGroupResult
  1219.                         ];
  1220.                     } else {
  1221.                         // No explicit condition set => just take the first
  1222.                         $sequence[] = [
  1223.                             'name'      => $groupName,
  1224.                             'condition' => $groupConditions[$groupName] ?? null,
  1225.                             'type'      => 'group',
  1226.                             'value'     => $values[0]
  1227.                         ];
  1228.                     }
  1229.                 }
  1230.             }
  1232.             // ---------------------------------------------
  1233.             // 4c) Combine top-level booleans with AND/OR
  1234.             // ---------------------------------------------
  1235.             $finalRuleOrGroupResult = $this->evaluateSequence($sequence);
  1237.             // ---------------------------------------------
  1238.             // 4d) Build final day-based array
  1239.             // ---------------------------------------------
  1240.             $daysData = [];
  1241.             foreach ($ruleDates as $day => $rulesOnDay) {
  1242.                 // Check if ANY interval is matched => finalResult = true
  1243.                 $dayHasMatched = $this->hasAnyMatched($rulesOnDay);
  1245.                 // If you need to combine with $finalRuleOrGroupResult, do so here, e.g.:
  1246.                 // $final = $dayHasMatched && $finalRuleOrGroupResult;
  1247.                 // For now, we'll just rely on "any match" => true
  1248.                 $daysData[] = [
  1249.                     'finalResult' => $dayHasMatched,
  1250.                     'date'        => $day,
  1251.                     'data'        => $rulesOnDay
  1252.                 ];
  1253.             }
  1255.             // Add this notification's days to $alertsData
  1256.             $alertsData[] = $daysData;
  1257.         }
  1259.         // -----------------------------------------------------------
  1260.         // 5) Return data + pagination variables
  1261.         // -----------------------------------------------------------
  1262.         return [
  1263.             'success'             => true,
  1264.             'data'                => $alertsData,
  1265.             'paginationVariables' => $paginator->getPaginationData()
  1266.         ];
  1267.     }
  1269.     /**
  1270.      * YOUR real getMeteomaticData() method (replaces the placeholder).
  1271.      */
  1272.     public function getMeteomaticData($rule, $startDate, $endDate, $timezone = null)
  1273.     {
  1274.         if (empty($startDate) || empty($endDate)) {
  1275.             throw new \InvalidArgumentException('Invalid dates');
  1276.         }
  1278.         // Just reuse your code as-is; below is copied from your snippet:
  1279.         $startDateObj = $startDate;
  1280.         $endDateObj   = $endDate;
  1282.         if ($timezone) {
  1283.             $startDateUtc = $startDateObj->setTimezone($timezone)->format('Y-m-d\TH:i:s.v\Z');
  1284.             $endDateUtc   = $endDateObj->setTimezone($timezone)->format('Y-m-d\TH:i:s.v\Z');
  1285.         } else {
  1286.             $startDateUtc = $startDateObj->setTimezone(new DateTimeZone('UTC'))->format('Y-m-d\TH:i:s.v\Z');
  1287.             $endDateUtc   = $endDateObj->setTimezone(new DateTimeZone('UTC'))->format('Y-m-d\TH:i:s.v\Z');
  1288.         }
  1290.         // Rule parameters
  1291.         $duration = $rule->getTimeInterval();
  1292.         $param    = $rule->getParameter()->getParamKey();
  1293.         $paramName = $rule->getParameter()->getParamName("en");
  1294.         $unit     = $rule->getParameterUnitKey();
  1295.         $coordinates = json_decode($rule->getLocation()->getCoordinates(), true);
  1296.         $heightDepth = $rule->getHeightOrDepth();
  1298.         $durationInterval = 1;
  1299.         if (stripos($rule->getTimeInDays(), 'h') !== false) {
  1300.             $hours = (int) filter_var($rule->getTimeInDays(), FILTER_SANITIZE_NUMBER_INT);
  1301.             $durationInterval = $hours;                
  1302.         } else {
  1303.             $days = (int) filter_var($rule->getTimeInDays(), FILTER_SANITIZE_NUMBER_INT);
  1304.             $durationInterval = $days * 24; 
  1305.         }
  1306.         if ($durationInterval==0) {
  1307.             $durationInterval=24;
  1308.         }
  1310.         // $resolution  = 'PT'.$durationInterval.'H';
  1311.         $resolution  = 'PT1H'; // Hourly resolution
  1312.         $model       = $rule->getModelParam() !== "model"
  1313.             ? "mix&calibrated=true"
  1314.             : ($rule->getModelValue() ?: 'mix');
  1316.         // Build parameter string
  1317.         $parametersStr = $param;
  1318.         if ($heightDepth) {
  1319.             $parametersStr .= '_' . $heightDepth;
  1320.         }
  1321.         if ($duration) {
  1322.             $parametersStr .= '_' . $duration . 'h';
  1323.         }
  1324.         if ($unit) {
  1325.             $parametersStr .= ':' . $unit;
  1326.         }
  1328.         // Format coordinates
  1329.         $formattedCoordinates = (count($coordinates) > 1)
  1330.             ? implode('+', array_map(fn($coord) => implode(',', $coord), $coordinates))
  1331.             : implode(',', $coordinates[0]);
  1333.         // Construct API URL
  1334.         $url = "{$this->apiBaseUrl}/{$startDateUtc}--{$endDateUtc}:{$resolution}/{$parametersStr}/{$formattedCoordinates}/json?source={$model}&use_decluttered=true";
  1336.         // Make API request via Guzzle
  1337.         $client   = new Client(['verify' => false]);
  1338.         $response = $client->request('GET', $url, [
  1339.             'auth' => [$this->username, $this->password],
  1340.         ]);
  1342.         $data = json_decode($response->getBody(), true);
  1344.         // Compare values using your existing utility method
  1345.         $ruleValue = \App\Lib\Utility::compareValueofCustomNotification(
  1346.             $data,
  1347.             $rule->getCondition(),
  1348.             $rule->getConditionValueMin(),
  1349.             $rule->getConditionValueMax(),
  1350.             $paramName,
  1351.             $rule->getLocation()->getName(),
  1352.             $unit
  1353.         );
  1355.         return [
  1356.             "data"          => $data,
  1357.             'comparedValue' => $ruleValue,
  1358.             "parameterKey"  => $parametersStr,
  1359.             'alertName'     => $paramName
  1360.         ];
  1361.     }
  1363.     /**
  1364.      * Break down the 'dates' array from Meteomatics into day-based intervals.
  1365.      */
  1366.     private function buildDayIntervals(array $datesData, $ruleConfig): array
  1367.     {
  1368.         $intervalsPerDay = [];
  1370.         foreach ($datesData as $date) {
  1371.             if (!isset($date['date']) || !isset($date['value'])) {
  1372.                 continue;
  1373.             }
  1375.             $time  = $date['date'];
  1376.             $value = $date['value'];
  1377.             $day   = (new DateTime($time))->format('Y-m-d');
  1379.             if (!isset($intervalsPerDay[$day])) {
  1380.                 $intervalsPerDay[$day] = [];
  1381.             }
  1383.             // Evaluate 'matched' for each hourly interval
  1384.             $matched = \App\Lib\Utility::isWeatherConditionMatched(
  1385.                 $ruleConfig->getConditionValueMin(),
  1386.                 $ruleConfig->getConditionValueMax(),
  1387.                 $value,
  1388.                 $ruleConfig->getCondition()
  1389.             );
  1391.             $intervalsPerDay[$day][] = [
  1392.                 'time'              => $time,
  1393.                 'value'             => $value,
  1394.                 'condition'         => $ruleConfig->getCondition(),
  1395.                 'conditionValueMax' => $ruleConfig->getConditionValueMax(),
  1396.                 'conditionValueMin' => $ruleConfig->getConditionValueMin(),
  1397.                 'matched'           => $matched,
  1398.             ];
  1399.         }
  1401.         return $intervalsPerDay;
  1402.     }
  1404.     /**
  1405.      * Combine an array of booleans with AND/OR logic in sequence order.
  1406.      */
  1407.     private function evaluateSequence(array $sequence): bool
  1408.     {
  1409.         if (empty($sequence)) {
  1410.             return false;
  1411.         }
  1413.         $final = $sequence[0]['value'];
  1415.         for ($i = 1; $i < count($sequence); $i++) {
  1416.             $current = $sequence[$i];
  1417.             switch ($current['condition']) {
  1418.                 case 'AND':
  1419.                     $final = $final && $current['value'];
  1420.                     break;
  1421.                 case 'OR':
  1422.                     $final = $final || $current['value'];
  1423.                     break;
  1424.                 default:
  1425.                     // fallback or handle unknown
  1426.                     $final = $final && $current['value'];
  1427.             }
  1428.         }
  1429.         return $final;
  1430.     }
  1432.     /**
  1433.      * Determine if ANY interval in the day's data was matched.
  1434.      * Supports both single-rule arrays and grouped rules.
  1435.      */
  1436.     private function hasAnyMatched(array $rulesOnDay): bool
  1437.     {
  1438.         foreach ($rulesOnDay as $ruleData) {
  1439.             // If it's a group => check $ruleData['rules']
  1440.             if (isset($ruleData['groupName']) && isset($ruleData['rules'])) {
  1441.                 foreach ($ruleData['rules'] as $subRule) {
  1442.                     foreach ($subRule['intervals'] as $interval) {
  1443.                         if (!empty($interval['matched'])) {
  1444.                             return true;
  1445.                         }
  1446.                     }
  1447.                 }
  1448.             } else {
  1449.                 // Single rule => intervals are directly in $ruleData['intervals']
  1450.                 if (isset($ruleData['intervals'])) {
  1451.                     foreach ($ruleData['intervals'] as $interval) {
  1452.                         if (!empty($interval['matched'])) {
  1453.                             return true;
  1454.                         }
  1455.                     }
  1456.                 }
  1457.             }
  1458.         }
  1459.         return false;
  1460.     }
  1462.     /**
  1463.      * Generate a unique rule ID (mimicking your original approach).
  1464.      */
  1465.     private function generateRuleId($ruleConfig, $key): string
  1466.     {
  1467.         $locName   = $ruleConfig->getLocation()?->getName('en') ?? '';
  1468.         $paramName = $ruleConfig->getParameter()?->getParamName('en') ?? '';
  1469.         return sprintf(
  1470.             "%s-%s-%s-%s-%d",
  1471.             $ruleConfig->getName(),
  1472.             $locName,
  1473.             $paramName,
  1474.             $ruleConfig->getCondition(),
  1475.             $key
  1476.         );
  1477.     }
  1479.     public function getAdvanceNotifications(
  1480.         MeteomaticsWeatherService $mateoMaticsService,
  1481.         $user,
  1482.         $notificationIds,
  1483.         $startDate,
  1484.         $endDate,
  1485.         $hour,
  1486.         $page,
  1487.         $size,
  1488.         $title,
  1489.         $paginator,
  1490.         $translator
  1491.     ): array {
  1492.         $timezone = new \DateTimeZone("Asia/Riyadh");
  1493.         $startDateObj = new \DateTime($startDate, $timezone);
  1494.         $endDateObj = new \DateTime($endDate, $timezone);
  1496.         $pageSize = isset($size) ? $size : LIMIT_PER_PAGE;
  1497.         $page = isset($page) ? $page : 1;
  1500.         if (empty($notificationIds)) {
  1501.             return ['success' => false, 'message' => $translator->trans("no_notifications_configured")];
  1502.         }
  1504.         $notificationListing = new DataObject\AdvanceCustomNotification\Listing();
  1505.         $notificationListing->addConditionParam('o_id IN (' . $notificationIds . ')');
  1506.         $notificationListing->addConditionParam('owner__id = ? OR user LIKE ? ', [$user->getId(), '%,' . $user->getId() . ',%']);
  1507.         $notificationListing->setOrderKey("o_id");
  1508.         $notificationListing->setOrder("desc");
  1510.         if (!empty($title)) {
  1511.             $notificationListing->addConditionParam("notificationName like '%$title%' ");
  1512.         }
  1513.         if (!empty($location)) {
  1514.             $db = \Pimcore\Db::get();
  1515.             $tagIds = $db->fetchFirstColumn(
  1516.                 "SELECT ooo_id 
  1517.                 FROM object_localized_data_Tags
  1518.                 WHERE language = :language AND TagName LIKE :tagName",
  1519.                 [
  1520.                     'language' => $translator->getLocale(),
  1521.                     'tagName' => '%' . $location . '%'
  1522.                 ]
  1523.             );
  1524.             if (!empty($tagIds)) {
  1525.                 $condition = 'locationTag__id IN (' . implode(",", $tagIds) . ') OR locationNames LIKE ?';
  1526.                 $params = [
  1527.                     '%' . $location . '%',
  1528.                 ];
  1529.                 $notificationListing->addConditionParam($condition, $params);
  1530.             } else {
  1531.                 $notificationListing->addConditionParam("locationNames like '%$location%' ");
  1532.             }
  1533.         }
  1535.         $paginator = $paginator->paginate(
  1536.             $notificationListing,
  1537.             $page,
  1538.             $pageSize
  1539.         );
  1541.         $notificationsCount = $paginator->count();
  1542.         if (!$notificationsCount) {
  1543.             return ['success' => false, 'message' => $translator->trans("no_notifications_found")];
  1544.         }
  1546.         $resultArr = [];
  1547.         $matchedNotifications = [];
  1549.         foreach ($paginator as $notification) {
  1550.             // print($notification->getid());
  1551.             $rules = $notification->getNotificationConfig();
  1552.             $notificationResult = $this->processRules($rules, $notification, $startDateObj, $endDateObj, $hour, $timezone);
  1553.         }
  1555.         return $notificationResult;
  1556.     }
  1558.     private function processRules(
  1559.         $rules,
  1560.         $notification,
  1561.         $startDateObj,
  1562.         $endDateObj,
  1563.         $hour,
  1564.         $timezone
  1565.     ): array {
  1566.         $data = [];
  1567.         $finalResult = false; // Overall final result for the notification
  1568.         $groupResults = [];
  1569.         $ruleIndex = 1; // Incremental index for rules
  1571.         foreach ($rules as $rule) {
  1572.             $ruleName = $rule->getName();
  1573.             $ruleType = $rule->getRuleType();
  1574.             $ruleCondition = $rule->getRuleCondition();
  1575.             $groupCondition = $rule->getGroupCondition();
  1577.             // Fetch Meteomatics data
  1578.             $result = $this->getMeteomaticData($rule, $startDateObj, $endDateObj, $timezone);
  1580.             $datesData = $result['data']['data'][0]['coordinates'][0]['dates'];
  1581.             $intervalsPerDay = [];
  1582.             $isMatched = false; // Whether any interval matches the condition
  1584.             foreach ($datesData as $date) {
  1585.                 if (isset($date['date'], $date['value'])) {
  1586.                     $interval = [
  1587.                         'time' => $date['date'],
  1588.                         'value' => $date['value'],
  1589.                         'condition' => $rule->getCondition(),
  1590.                         'conditionValueMax' => $rule->getConditionValueMax(),
  1591.                         'conditionValueMin' => $rule->getConditionValueMin(),
  1592.                         'matched' => \App\Lib\Utility::compareValues(
  1593.                             $rule->getCondition(),
  1594.                             $date['value'],
  1595.                             [
  1596.                                 $rule->getConditionValueMin(),
  1597.                                 $rule->getConditionValueMax(),
  1598.                             ]
  1599.                         ),
  1600.                     ];
  1602.                     $day = (new DateTime($date['date']))->format('Y-m-d');
  1604.                     if (!isset($intervalsPerDay[$day])) {
  1605.                         $intervalsPerDay[$day] = [];
  1606.                     }
  1608.                     $intervalsPerDay[$day][] = $interval;
  1610.                     // Check if any interval matches
  1611.                     if ($interval['matched']) {
  1612.                         $isMatched = true;
  1613.                     }
  1614.                 }
  1615.             }
  1617.             foreach ($intervalsPerDay as $day => $intervals) {
  1618.                 $ruleDetails = [
  1619.                     'alertId' => $notification->getID(),
  1620.                     'ruleIndex' => $ruleIndex,
  1621.                     'name' => $ruleType === 'group' ? "Group" : "Rule" . $ruleIndex,
  1622.                     'ruleName' => $ruleName,
  1623.                     'advanceCustomNotificationTitle' => $notification->getNotificationName('en'),
  1624.                     'ruleId' => $ruleName . '-' . $rule->getLocation()?->getName('en'),
  1625.                     'ruleType' => $ruleType,
  1626.                     'location' => $rule->getLocation()?->getName('en'),
  1627.                     'severity_code' => (\App\Lib\Utility::getSeverityCode($notification->getSeverity(), CUSTOM_NOTIFICATION_CONFIG_COLORS) ? \App\Lib\Utility::getSeverityCode($notification->getSeverity(), CUSTOM_NOTIFICATION_CONFIG_COLORS) : ''),
  1628.                     'severity' => $notification->getSeverity(),
  1629.                     'severityAr' => (\App\Lib\Utility::getArabicTranslation($notification->getSeverity(), CUSTOM_NOTIFICATION_CONFIG_COLORS) ? \App\Lib\Utility::getArabicTranslation($notification->getSeverity(), CUSTOM_NOTIFICATION_CONFIG_COLORS) : ''),
  1630.                     'model' => $rule->getModelParam(),
  1631.                     'modelEn' => (\App\Lib\Utility::getArabicTranslationByKey('value', $rule->getModelParam(), CUSTOM_NOTIFICATION_MODEL_TYPE, 'en') ? \App\Lib\Utility::getArabicTranslationByKey('value', $rule->getModelParam(), CUSTOM_NOTIFICATION_MODEL_TYPE, 'en') : ''),
  1632.                     'modelAr' => (\App\Lib\Utility::getArabicTranslationByKey('value', $rule->getModelParam(), CUSTOM_NOTIFICATION_MODEL_TYPE, 'ar') ? \App\Lib\Utility::getArabicTranslationByKey('value', $rule->getModelParam(), CUSTOM_NOTIFICATION_MODEL_TYPE, 'ar') : ''),
  1633.                     'unit' => $rule->getParameterUnitKey(),
  1634.                     'unitAr' => (\App\Lib\Utility::getArabicTranslationUnits($rule->getParameterUnitKey())),
  1635.                     'parameterKey' => $rule->getParameter()?->getParamKey(),
  1636.                     'parameter' => $rule->getParameter()?->getParamName('en'),
  1637.                     'parameterAr' => $rule->getParameter()?->getParamName('ar'),
  1638.                     'condition' => $rule->getCondition(),
  1639.                     'conditionAr' => (\App\Lib\Utility::getArabicTranslation($rule->getCondition(), CUSTOM_NOTIFICATION_CONDITION) ? \App\Lib\Utility::getArabicTranslation($rule->getCondition(), CUSTOM_NOTIFICATION_CONDITION) : ''),
  1640.                     'timeInterval' => $rule->getTimeInterval(),
  1641.                     'conditionValueMax' => $rule->getConditionValueMax(),
  1642.                     'conditionValueMin' => $rule->getConditionValueMin(),
  1643.                     'timeInDays' => $rule->getTimeInDays(),
  1644.                     'ruleCondition' => $rule->getRuleCondition(),
  1645.                     'groupCondition' => $rule->getGroupCondition(),
  1646.                     'modelValue' => $rule->getModelValue(),
  1647.                     'heightOrDepth' => $rule->getHeightOrDepth(),
  1648.                     'rawDate' => $intervals[0]['time'],
  1649.                     'intervals' => $intervals,
  1650.                 ];
  1652.                 if ($ruleType === 'group') {
  1653.                     // Aggregate group results
  1654.                     if (!isset($groupResults[$ruleName])) {
  1655.                         $groupResults[$ruleName] = [
  1656.                             'rules' => [],
  1657.                             'condition' => $groupCondition,
  1658.                             'values' => [],
  1659.                         ];
  1660.                     }
  1662.                     $groupResults[$ruleName]['rules'][] = $ruleDetails;
  1663.                     $groupResults[$ruleName]['values'][] = $isMatched;
  1664.                 } else {
  1665.                     // Add standalone rule result
  1666.                     $data[$day][] = $ruleDetails;
  1667.                     $finalResult = $this->evaluateCondition($finalResult, $isMatched, $ruleCondition);
  1668.                 }
  1669.             }
  1671.             $ruleIndex++;
  1672.         }
  1674.         // Process group results
  1675.         foreach ($groupResults as $groupName => $group) {
  1676.             $groupCondition = ($group['condition']) ? $group['condition'] : "AND";
  1678.             // Ensure $groupCondition is expanded to match the number of values
  1679.             $operators = array_fill(0, count($group['values']) - 1, $groupCondition);
  1681.             // Evaluate conditions only if there are multiple values
  1682.             if (count($group['values']) > 1) {
  1683.                 $groupMatchResult = \App\Lib\Utility::evaluateConditionsAdvanceCustomNotification($group['values'], $operators);
  1684.             } else {
  1685.                 // If there's only one value, use it directly
  1686.                 $groupMatchResult = $group['values'][0];
  1687.             }
  1689.             $finalResult = $this->evaluateCondition($finalResult, $groupMatchResult, $groupCondition);
  1691.             $data[] = [
  1692.                 'groupName' => $groupName,
  1693.                 'result' => $groupMatchResult,
  1694.                 'rules' => $group['rules'],
  1695.             ];
  1697.             if ($groupMatchResult) {
  1698.                 $matchedRules[] = $groupName;
  1699.             }
  1700.         }
  1702.         return [
  1703.             'finalResult' => $finalResult,
  1704.             'data' => $data,
  1705.         ];
  1706.     }
  1709.     private function evaluateSingleRule($rule, $startDateObj, $endDateObj, $timezone): array
  1710.     {
  1711.         $duration = $rule->getTimeInterval();
  1712.         $param = $rule->getParameter()->getParamKey();
  1713.         $paramName = $rule->getParameter()->getParamName("en");
  1714.         $unit = $rule->getParameterUnitKey();
  1715.         $coordinates = json_decode($rule->getLocation()->getCoordinates(), true);
  1716.         $heightDepth = $rule->getHeightOrDepth();
  1717.         $resolution = 'PT1H';
  1718.         $formattedCoordinates = "";
  1719.         $model = $rule->getModelParam() !== "model"
  1720.             ? "mix&calibrated=true"
  1721.             : ($rule->getModelValue() ?: 'mix');
  1723.         // Construct parameter string
  1724.         $parametersStr = $param;
  1725.         if ($heightDepth) {
  1726.             $parametersStr .= '_' . $heightDepth;
  1727.         }
  1728.         if ($duration) {
  1729.             $parametersStr .= '_' . $duration . 'h';
  1730.         }
  1731.         if ($unit) {
  1732.             $parametersStr .= ':' . $unit;
  1733.         }
  1735.         // Format coordinates
  1736.         $formattedCoordinates = count($coordinates) > 1
  1737.             ? implode('+', array_map(fn($coordinate) => implode(',', $coordinate), $coordinates))
  1738.             : implode(',', $coordinates[0]);
  1740.         // Construct the URL for Meteomatics API
  1741.         $startDate = $startDateObj->format('Y-m-d\T00:00:00.v\Z');
  1742.         $endDate = $endDateObj->format('Y-m-d\T23:59:59.v\Z');
  1743.         $url = "{$this->apiBaseUrl}/{$startDate}--{$endDate}:{$resolution}/{$parametersStr}/{$formattedCoordinates}/json?source={$model}&use_decluttered=true";
  1745.         // Fetch data from Meteomatics
  1746.         $client = new Client(['verify' => false]);
  1747.         $response = $client->request('GET', $url, [
  1748.             'auth' => [$this->username, $this->password],
  1749.         ]);
  1750.         $data = json_decode($response->getBody(), true);
  1752.         $qualifiedLocations = $data['data'][0]['coordinates'][0]['dates'];
  1753.         $matched = false;
  1754.         $ruleData = [];
  1757.         foreach ($qualifiedLocations as $location) {
  1758.             $value = $location['value'];
  1759.             $date = new \DateTime($location['date'], new \DateTimeZone("UTC"));
  1760.             $date->setTimezone($timezone);
  1762.             $condition = $rule->getCondition();
  1763.             $minValue = $rule->getConditionValueMin();
  1764.             $maxValue = $rule->getConditionValueMax();
  1766.             if ($condition == "range") {
  1767.                 $matched = \App\Lib\Utility::compareValues($condition, $value, [$minValue, $maxValue]);
  1768.             } else {
  1769.                 $matched = \App\Lib\Utility::compareValues($condition, $value, $minValue);
  1770.             }
  1772.             if ($matched) {
  1773.                 $ruleData[] = [
  1774.                     'date' => $date->format('Y-m-d H:i'),
  1775.                     'value' => $value,
  1776.                     'location' => $rule->getLocation()->getName(),
  1777.                 ];
  1778.             }
  1779.         }
  1781.         return [
  1782.             'rule_name' => $rule->getName(),
  1783.             'matched' => $matched,
  1784.             'data' => $ruleData,
  1785.         ];
  1786.     }
  1788.     private function evaluateCondition($currentResult, $newResult, $condition)
  1789.     {
  1790.         if ($condition === 'AND') {
  1791.             return $currentResult && $newResult;
  1792.         } elseif ($condition === 'OR') {
  1793.             return $currentResult || $newResult;
  1794.         }
  1796.         return $currentResult;
  1797.     }
  1798. }