1 files changed, 81 insertions, 8 deletions

diff --git a/src/components/policy/policy_external/src/cache_manager.cc b/src/components/policy/policy_external/src/cache_manager.cc
index 5aa39cb2f4..00bb1e4a1c 100644
--- a/src/components/policy/policy_external/src/cache_manager.cc
+++ b/src/components/policy/policy_external/src/cache_manager.cc
@@ -41,6 +41,7 @@
 #include <vector>
 
 #include "utils/file_system.h"
+#include "utils/helpers.h"
 #include "json/reader.h"
 #include "json/features.h"
 #include "json/writer.h"
@@ -638,13 +639,11 @@ void CacheManager::RemoveAppConsentForGroup(const std::string& app_id,
   }
 }
 
-using rpc::policy_table_interface_base::RequestTypes;
-using rpc::policy_table_interface_base::RequestType;
-
 void CacheManager::ProcessUpdate(
     const policy_table::ApplicationPolicies::const_iterator
         initial_policy_iter) {
   using namespace policy;
+  using rpc::policy_table_interface_base::RequestTypes;
   const RequestTypes& new_request_types =
       *(initial_policy_iter->second.RequestType);
 
@@ -2392,6 +2391,32 @@ bool CacheManager::ResetPT(const std::string& file_name) {
   return result;
 }
 
+policy::RequestType::State CacheManager::GetAppRequestTypesState(
+    const std::string& policy_app_id) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+  policy_table::ApplicationPolicies::const_iterator app_policies_iter =
+      pt_->policy_table.app_policies_section.apps.find(policy_app_id);
+  if (pt_->policy_table.app_policies_section.apps.end() == app_policies_iter) {
+    LOG4CXX_DEBUG(logger_,
+                  "Can't find request types for app_id " << policy_app_id);
+    return policy::RequestType::State::UNAVAILABLE;
+  }
+  const policy_table::RequestTypes& request_types =
+      *app_policies_iter->second.RequestType;
+  if (!request_types.is_initialized()) {
+    LOG4CXX_TRACE(logger_,
+                  "Request types for " << policy_app_id << " are OMITTED");
+    return RequestType::State::OMITTED;
+  }
+  if (request_types.empty()) {
+    LOG4CXX_TRACE(logger_,
+                  "Request types for " << policy_app_id << " are EMPTY");
+    return policy::RequestType::State::EMPTY;
+  }
+  return policy::RequestType::State::AVAILABLE;
+}
+
 void CacheManager::GetAppRequestTypes(
     const std::string& policy_app_id,
     std::vector<std::string>& request_types) const {
@@ -2411,16 +2436,64 @@ void CacheManager::GetAppRequestTypes(
     return;
   }
   if (policy_iter->second.RequestType.is_initialized()) {
-    policy_table::RequestTypes::iterator it_request_type =
-        policy_iter->second.RequestType->begin();
-    for (; it_request_type != policy_iter->second.RequestType->end();
-         ++it_request_type) {
-      request_types.push_back(EnumToJsonString(*it_request_type));
+    for (const auto& request_type : *policy_iter->second.RequestType) {
+      request_types.push_back(EnumToJsonString(request_type));
     }
   }
   return;
 }
 
+RequestSubType::State CacheManager::GetAppRequestSubTypesState(
+    const std::string& policy_app_id) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+  policy_table::ApplicationPolicies::const_iterator app_policies_iter =
+      pt_->policy_table.app_policies_section.apps.find(policy_app_id);
+  if (pt_->policy_table.app_policies_section.apps.end() == app_policies_iter) {
+    LOG4CXX_DEBUG(logger_,
+                  "Can't find request subtypes for app_id " << policy_app_id);
+    return RequestSubType::State::UNAVAILABLE;
+  }
+  const policy_table::RequestSubTypes& request_subtypes =
+      *app_policies_iter->second.RequestSubType;
+  if (!request_subtypes.is_initialized()) {
+    LOG4CXX_TRACE(logger_,
+                  "Request subtypes for " << policy_app_id << " are OMITTED");
+    return RequestSubType::State::OMITTED;
+  }
+  if (request_subtypes.empty()) {
+    LOG4CXX_TRACE(logger_,
+                  "Request subtypes for " << policy_app_id << " are EMPTY");
+    return RequestSubType::State::EMPTY;
+  }
+  return RequestSubType::State::AVAILABLE;
+}
+
+void CacheManager::GetAppRequestSubTypes(
+    const std::string& policy_app_id,
+    std::vector<std::string>& request_subtypes) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  CACHE_MANAGER_CHECK_VOID();
+  if (kDeviceId == policy_app_id) {
+    LOG4CXX_DEBUG(logger_,
+                  "Request subtypes not applicable for app_id " << kDeviceId);
+    return;
+  }
+  sync_primitives::AutoLock auto_lock(cache_lock_);
+  policy_table::ApplicationPolicies::iterator policy_iter =
+      pt_->policy_table.app_policies_section.apps.find(policy_app_id);
+  if (pt_->policy_table.app_policies_section.apps.end() == policy_iter) {
+    LOG4CXX_DEBUG(logger_,
+                  "Can't find request subtypes for app_id " << policy_app_id);
+    return;
+  }
+
+  for (const auto& request_subtype : *policy_iter->second.RequestSubType) {
+    request_subtypes.push_back(request_subtype);
+  }
+  return;
+}
+
 const MetaInfo CacheManager::GetMetaInfo() const {
   LOG4CXX_AUTO_TRACE(logger_);
   sync_primitives::AutoLock auto_lock(cache_lock_);