Merge remote-tracking branch 'origin/develop' into feature/add_display_namefeature/add_display_name

# Conflicts:
#	src/components/application_manager/src/commands/mobile/register_app_interface_request.cc

9 files changed, 356 insertions, 31 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_);
diff --git a/src/components/policy/policy_external/src/policy_helper.cc b/src/components/policy/policy_external/src/policy_helper.cc
index 8be0372c03..39b9399c24 100644
--- a/src/components/policy/policy_external/src/policy_helper.cc
+++ b/src/components/policy/policy_external/src/policy_helper.cc
@@ -322,9 +322,21 @@ bool CheckAppPolicy::operator()(const AppPoliciesValueType& app_policy) {
 
   PermissionsCheckResult result = CheckPermissionsChanges(app_policy);
 
-  if (!IsPredefinedApp(app_policy) && IsRequestTypeChanged(app_policy)) {
-    SetPendingPermissions(app_policy, RESULT_REQUEST_TYPE_CHANGED);
-    AddResult(app_id, RESULT_REQUEST_TYPE_CHANGED);
+  if (!IsPredefinedApp(app_policy)) {
+    const bool is_request_type_changed = IsRequestTypeChanged(app_policy);
+    const bool is_request_subtype_changed = IsRequestSubTypeChanged(app_policy);
+    if (is_request_type_changed) {
+      LOG4CXX_TRACE(logger_,
+                    "Request types were changed for application: " << app_id);
+      SetPendingPermissions(app_policy, RESULT_REQUEST_TYPE_CHANGED);
+      AddResult(app_id, RESULT_REQUEST_TYPE_CHANGED);
+    }
+    if (is_request_subtype_changed) {
+      LOG4CXX_TRACE(
+          logger_, "Request subtypes were changed for application: " << app_id);
+      SetPendingPermissions(app_policy, RESULT_REQUEST_SUBTYPE_CHANGED);
+      AddResult(app_id, RESULT_REQUEST_SUBTYPE_CHANGED);
+    }
   }
 
   if (RESULT_NO_CHANGES == result) {
@@ -389,17 +401,18 @@ void policy::CheckAppPolicy::SetPendingPermissions(
       break;
     case RESULT_REQUEST_TYPE_CHANGED:
       permissions_diff.requestTypeChanged = true;
-      {
-        // Getting RequestTypes from PTU (not from cache)
-        policy_table::RequestTypes::const_iterator it_request_type =
-            app_policy.second.RequestType->begin();
-        for (; app_policy.second.RequestType->end() != it_request_type;
-             ++it_request_type) {
-          permissions_diff.requestType.push_back(
-              EnumToJsonString(*it_request_type));
-        }
-      }
 
+      // Getting Request Types from PTU (not from cache)
+      for (const auto& request_type : *app_policy.second.RequestType) {
+        permissions_diff.requestType.push_back(EnumToJsonString(request_type));
+      }
+      break;
+    case RESULT_REQUEST_SUBTYPE_CHANGED:
+      permissions_diff.requestSubTypeChanged = true;
+      // Getting Request SubTypes from PTU (not from cache)
+      for (const auto& request_subtype : *app_policy.second.RequestSubType) {
+        permissions_diff.requestSubType.push_back(request_subtype);
+      }
       break;
     default:
       return;
@@ -484,6 +497,32 @@ bool CheckAppPolicy::IsRequestTypeChanged(
   return diff.size();
 }
 
+bool CheckAppPolicy::IsRequestSubTypeChanged(
+    const AppPoliciesValueType& app_policy) const {
+  policy::AppPoliciesConstItr it =
+      snapshot_->policy_table.app_policies_section.apps.find(app_policy.first);
+
+  if (it == snapshot_->policy_table.app_policies_section.apps.end()) {
+    if (!app_policy.second.RequestSubType->empty()) {
+      return true;
+    }
+    return false;
+  }
+
+  if (it->second.RequestSubType->size() !=
+      app_policy.second.RequestSubType->size()) {
+    return true;
+  }
+
+  policy_table::RequestSubTypes diff;
+  std::set_difference(it->second.RequestSubType->begin(),
+                      it->second.RequestSubType->end(),
+                      app_policy.second.RequestSubType->begin(),
+                      app_policy.second.RequestSubType->end(),
+                      std::back_inserter(diff));
+  return diff.size();
+}
+
 void FillActionsForAppPolicies::operator()(
     const policy::CheckAppPolicyResults::value_type& value) {
   const std::string app_id = value.first;
@@ -510,6 +549,7 @@ void FillActionsForAppPolicies::operator()(
     case RESULT_CONSENT_NOT_REQIURED:
     case RESULT_PERMISSIONS_REVOKED:
     case RESULT_REQUEST_TYPE_CHANGED:
+    case RESULT_REQUEST_SUBTYPE_CHANGED:
       break;
     case RESULT_NO_CHANGES:
     default:
diff --git a/src/components/policy/policy_external/src/policy_manager_impl.cc b/src/components/policy/policy_external/src/policy_manager_impl.cc
index 433a7a6bca..56de26af64 100644
--- a/src/components/policy/policy_external/src/policy_manager_impl.cc
+++ b/src/components/policy/policy_external/src/policy_manager_impl.cc
@@ -563,6 +563,25 @@ const std::vector<std::string> PolicyManagerImpl::GetAppRequestTypes(
   return request_types;
 }
 
+RequestType::State PolicyManagerImpl::GetAppRequestTypesState(
+    const std::string& policy_app_id) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  return cache_->GetAppRequestTypesState(policy_app_id);
+}
+
+RequestSubType::State PolicyManagerImpl::GetAppRequestSubTypesState(
+    const std::string& policy_app_id) const {
+  LOG4CXX_AUTO_TRACE(logger_);
+  return cache_->GetAppRequestSubTypesState(policy_app_id);
+}
+
+const std::vector<std::string> PolicyManagerImpl::GetAppRequestSubTypes(
+    const std::string& policy_app_id) const {
+  std::vector<std::string> request_subtypes;
+  cache_->GetAppRequestSubTypes(policy_app_id, request_subtypes);
+  return request_subtypes;
+}
+
 const VehicleInfo PolicyManagerImpl::GetVehicleInfo() const {
   return cache_->GetVehicleInfo();
 }
diff --git a/src/components/policy/policy_external/src/policy_table/enums.cc b/src/components/policy/policy_external/src/policy_table/enums.cc
index beea68a276..881ae8cbf9 100644
--- a/src/components/policy/policy_external/src/policy_table/enums.cc
+++ b/src/components/policy/policy_external/src/policy_table/enums.cc
@@ -605,6 +605,10 @@ bool IsValidEnum(RequestType val) {
       return true;
     case RT_FOTA:
       return true;
+    case RT_OEM_SPECIFIC:
+      return true;
+    case RT_EMPTY:
+      return true;
     default:
       return false;
   }
@@ -652,6 +656,10 @@ const char* EnumToJsonString(RequestType val) {
       return "MEDIA";
     case RT_FOTA:
       return "FOTA";
+    case RT_OEM_SPECIFIC:
+      return "OEM_SPECIFIC";
+    case RT_EMPTY:
+      return "EMPTY";
     default:
       return "";
   }
@@ -737,6 +745,14 @@ bool EnumFromJsonString(const std::string& literal, RequestType* result) {
   if ("FOTA" == literal) {
     *result = RT_FOTA;
     return true;
+  }
+  if ("OEM_SPECIFIC" == literal) {
+    *result = RT_OEM_SPECIFIC;
+    return true;
+  }
+  if ("EMPTY" == literal) {
+    *result = RT_EMPTY;
+    return true;
   } else {
     return false;
   }
diff --git a/src/components/policy/policy_external/src/policy_table/types.cc b/src/components/policy/policy_external/src/policy_table/types.cc
index da83626448..6d0bc9d697 100644
--- a/src/components/policy/policy_external/src/policy_table/types.cc
+++ b/src/components/policy/policy_external/src/policy_table/types.cc
@@ -238,6 +238,7 @@ ApplicationParams::ApplicationParams(const Json::Value* value__)
     , nicknames(impl::ValueMember(value__, "nicknames"))
     , AppHMIType(impl::ValueMember(value__, "AppHMIType"))
     , RequestType(impl::ValueMember(value__, "RequestType"))
+    , RequestSubType(impl::ValueMember(value__, "RequestSubType"))
     , memory_kb(impl::ValueMember(value__, "memory_kb"), 0)
     , heart_beat_timeout_ms(impl::ValueMember(value__, "heart_beat_timeout_ms"))
 #ifdef SDL_REMOTE_CONTROL
@@ -251,6 +252,7 @@ Json::Value ApplicationParams::ToJsonValue() const {
   impl::WriteJsonField("nicknames", nicknames, &result__);
   impl::WriteJsonField("AppHMIType", AppHMIType, &result__);
   impl::WriteJsonField("RequestType", RequestType, &result__);
+  impl::WriteJsonField("RequestSubType", RequestSubType, &result__);
   impl::WriteJsonField("memory_kb", memory_kb, &result__);
   impl::WriteJsonField(
       "heart_beat_timeout_ms", heart_beat_timeout_ms, &result__);
@@ -303,6 +305,9 @@ bool ApplicationParams::struct_empty() const {
   if (RequestType.is_initialized()) {
     return false;
   }
+  if (RequestSubType.is_initialized()) {
+    return false;
+  }
   if (memory_kb.is_initialized()) {
     return false;
   }
@@ -337,6 +342,9 @@ void ApplicationParams::ReportErrors(rpc::ValidationReport* report__) const {
   if (!RequestType.is_valid()) {
     RequestType.ReportErrors(&report__->ReportSubobject("RequestType"));
   }
+  if (!RequestSubType.is_valid()) {
+    RequestSubType.ReportErrors(&report__->ReportSubobject("RequestSubType"));
+  }
   if (!priority.is_valid()) {
     priority.ReportErrors(&report__->ReportSubobject("priority"));
   }
@@ -368,6 +376,7 @@ void ApplicationParams::SetPolicyTableType(PolicyTableType pt_type) {
   PolicyBase::SetPolicyTableType(pt_type);
   AppHMIType.SetPolicyTableType(pt_type);
   RequestType.SetPolicyTableType(pt_type);
+  RequestSubType.SetPolicyTableType(pt_type);
   memory_kb.SetPolicyTableType(pt_type);
   heart_beat_timeout_ms.SetPolicyTableType(pt_type);
 #ifdef SDL_REMOTE_CONTROL
diff --git a/src/components/policy/policy_external/src/policy_table/validation.cc b/src/components/policy/policy_external/src/policy_table/validation.cc
index 48a8578855..6936948c84 100644
--- a/src/components/policy/policy_external/src/policy_table/validation.cc
+++ b/src/components/policy/policy_external/src/policy_table/validation.cc
@@ -89,6 +89,7 @@ bool ApplicationPoliciesSection::Validate() const {
       continue;
     }
 
+    LOG4CXX_TRACE(logger_, "Checking app Request Types...");
     RequestTypes& app_request_types = *iter->second.RequestType;
 
     if (app_request_types.is_omitted()) {
@@ -133,6 +134,33 @@ bool ApplicationPoliciesSection::Validate() const {
     ++iter;
   }
 
+  LOG4CXX_TRACE(logger_, "Checking app Request SubTypes...");
+  iter = apps.begin();
+  while (iter != end_iter) {
+    if (it_default_policy == iter || it_pre_data_policy == iter) {
+      ++iter;
+      continue;
+    }
+    ApplicationParams& app_params = (*iter).second;
+    const bool is_request_subtype_omitted =
+        !app_params.RequestSubType.is_initialized();
+
+    if (is_request_subtype_omitted) {
+      LOG4CXX_WARN(logger_,
+                   "App policy RequestSubTypes omitted."
+                   " Will be replaced with default.");
+      app_params.RequestSubType = apps[kDefaultApp].RequestSubType;
+      ++iter;
+      continue;
+    }
+
+    const bool is_request_subtype_empty = app_params.RequestSubType->empty();
+    if (is_request_subtype_empty) {
+      LOG4CXX_WARN(logger_, "App policy RequestSubTypes empty.");
+    }
+    ++iter;
+  }
+
   return true;
 }
 
diff --git a/src/components/policy/policy_external/src/sql_pt_ext_representation.cc b/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
index f58a7f0b82..5bb602244e 100644
--- a/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
+++ b/src/components/policy/policy_external/src/sql_pt_ext_representation.cc
@@ -670,6 +670,11 @@ bool SQLPTExtRepresentation::SaveApplicationPoliciesSection(
     return false;
   }
 
+  if (!query_delete.Exec(sql_pt::kDeleteRequestSubType)) {
+    LOG4CXX_WARN(logger_, "Incorrect delete from request subtype.");
+    return false;
+  }
+
   // First, all predefined apps (e.g. default, pre_DataConsent) should be saved,
   // otherwise another app with the predefined permissions can get incorrect
   // permissions
@@ -713,18 +718,17 @@ bool SQLPTExtRepresentation::SaveSpecificAppPolicy(
       if (!SetDefaultPolicy(app.first)) {
         return false;
       }
-      if (!SaveRequestType(app.first, *app.second.RequestType)) {
-        return false;
-      }
     } else if (kPreDataConsentId.compare(app.second.get_string()) == 0) {
       if (!SetPredataPolicy(app.first)) {
         return false;
       }
-      if (!SaveRequestType(app.first, *app.second.RequestType)) {
-        return false;
-      }
     }
-
+    if (!SaveRequestType(app.first, *app.second.RequestType)) {
+      return false;
+    }
+    if (!SaveRequestSubType(app.first, *app.second.RequestSubType)) {
+      return false;
+    }
     // Stop saving other params, since predefined permissions already set
     return true;
   }
@@ -771,6 +775,10 @@ bool SQLPTExtRepresentation::SaveSpecificAppPolicy(
     return false;
   }
 
+  if (!SaveRequestSubType(app.first, *app.second.RequestSubType)) {
+    return false;
+  }
+
   return true;
 }
 
diff --git a/src/components/policy/policy_external/src/sql_pt_queries.cc b/src/components/policy/policy_external/src/sql_pt_queries.cc
index 9702c315b0..ee53eb1487 100644
--- a/src/components/policy/policy_external/src/sql_pt_queries.cc
+++ b/src/components/policy/policy_external/src/sql_pt_queries.cc
@@ -271,13 +271,21 @@ const std::string kCreateSchema =
     "    REFERENCES `application`(`id`) "
     "); "
     "CREATE TABLE IF NOT EXISTS `request_type`( "
-    "  `request_type` VARCHAR(50) NOT NULL, "
+    "  `request_type` VARCHAR(50), "
     "  `application_id` VARCHAR(45) NOT NULL COLLATE NOCASE, "
     "  PRIMARY KEY(`request_type`,`application_id`), "
     "  CONSTRAINT `fk_app_type_application1` "
     "    FOREIGN KEY(`application_id`) "
     "    REFERENCES `application`(`id`) "
     "); "
+    "CREATE TABLE IF NOT EXISTS `request_subtype`( "
+    "  `request_subtype` VARCHAR(50), "
+    "  `application_id` VARCHAR(45) NOT NULL COLLATE NOCASE, "
+    "  PRIMARY KEY(`request_subtype`,`application_id`), "
+    "  CONSTRAINT `fk_request_subtype_app_id` "
+    "    FOREIGN KEY(`application_id`) "
+    "    REFERENCES `application`(`id`) "
+    "); "
     "CREATE INDEX IF NOT EXISTS `app_type.fk_app_type_application1_idx` "
     "  ON `app_type`(`application_id` COLLATE NOCASE); "
     "CREATE TABLE IF NOT EXISTS `consent_group`( "
@@ -482,6 +490,7 @@ const std::string kDropSchema =
     "DROP INDEX IF EXISTS `app_type.fk_app_type_application1_idx`; "
     "DROP TABLE IF EXISTS `app_type`; "
     "DROP TABLE IF EXISTS `request_type`; "
+    "DROP TABLE IF EXISTS `request_subtype`; "
     "DROP INDEX IF EXISTS `nickname.fk_nickname_application1_idx`; "
     "DROP TABLE IF EXISTS `nickname`; "
     "DROP INDEX IF EXISTS `app_level.fk_app_level_language2_idx`; "
@@ -636,6 +645,19 @@ const std::string kInsertRequestType =
     "INSERT OR IGNORE INTO `request_type` (`application_id`, `request_type`) "
     "VALUES (?, ?)";
 
+const std::string kInsertOmittedRequestType =
+    "INSERT INTO `request_type` (`application_id`) "
+    "VALUES (?)";
+
+const std::string kInsertRequestSubType =
+    "INSERT INTO `request_subtype` (`application_id`, "
+    "`request_subtype`) "
+    "VALUES (?, ?)";
+
+const std::string kInsertOmittedRequestSubType =
+    "INSERT INTO `request_subtype` (`application_id`) "
+    "VALUES (?)";
+
 const std::string kUpdateVersion = "UPDATE `version` SET `number`= ?";
 
 const std::string kInsertMessageType =
@@ -760,6 +782,11 @@ const std::string kSelectRequestTypes =
     "SELECT DISTINCT `request_type` FROM `request_type` WHERE `application_id` "
     "= ?";
 
+const std::string kSelectRequestSubTypes =
+    "SELECT DISTINCT `request_subtype` FROM `request_subtype` WHERE "
+    "`application_id` "
+    "= ?";
+
 const std::string kSelectSecondsBetweenRetries =
     "SELECT `value` FROM `seconds_between_retry` ORDER BY `index`";
 
@@ -805,6 +832,8 @@ const std::string kDeleteApplication = "DELETE FROM `application`";
 
 const std::string kDeleteRequestType = "DELETE FROM `request_type`";
 
+const std::string kDeleteRequestSubType = "DELETE FROM `request_subtype`";
+
 const std::string kSelectApplicationRevoked =
     "SELECT `is_revoked` FROM `application` WHERE `id` = ?";
 
diff --git a/src/components/policy/policy_external/src/sql_pt_representation.cc b/src/components/policy/policy_external/src/sql_pt_representation.cc
index 4315d99b3a..b05716dc3f 100644
--- a/src/components/policy/policy_external/src/sql_pt_representation.cc
+++ b/src/components/policy/policy_external/src/sql_pt_representation.cc
@@ -786,6 +786,9 @@ bool SQLPTRepresentation::GatherApplicationPoliciesSection(
     if (!GatherRequestType(app_id, &*params.RequestType)) {
       return false;
     }
+    if (!GatherRequestSubType(app_id, &*params.RequestSubType)) {
+      return false;
+    }
 
     (*policies).apps[app_id] = params;
   }
@@ -1175,15 +1178,83 @@ bool SQLPTRepresentation::SaveRequestType(
   }
 
   policy_table::RequestTypes::const_iterator it;
-  for (it = types.begin(); it != types.end(); ++it) {
+  if (!types.empty()) {
+    LOG4CXX_WARN(logger_, "Request types not empty.");
+    for (it = types.begin(); it != types.end(); ++it) {
+      query.Bind(0, app_id);
+      query.Bind(1, std::string(policy_table::EnumToJsonString(*it)));
+      if (!query.Exec() || !query.Reset()) {
+        LOG4CXX_WARN(logger_, "Incorrect insert into request types.");
+        return false;
+      }
+    }
+  } else if (types.is_initialized()) {
+    LOG4CXX_WARN(logger_, "Request types empty.");
     query.Bind(0, app_id);
-    query.Bind(1, std::string(policy_table::EnumToJsonString(*it)));
+    query.Bind(1,
+               std::string(policy_table::EnumToJsonString(
+                   policy_table::RequestType::RT_EMPTY)));
     if (!query.Exec() || !query.Reset()) {
       LOG4CXX_WARN(logger_, "Incorrect insert into request types.");
       return false;
     }
+  } else {
+    utils::dbms::SQLQuery query_omitted(db());
+    if (!query_omitted.Prepare(sql_pt::kInsertOmittedRequestType)) {
+      LOG4CXX_WARN(logger_, "Incorrect insert statement for request types.");
+      return false;
+    }
+    LOG4CXX_WARN(logger_, "Request types omitted.");
+    query_omitted.Bind(0, app_id);
+    if (!query_omitted.Exec() || !query_omitted.Reset()) {
+      LOG4CXX_WARN(logger_, "Incorrect insert into request types.");
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SQLPTRepresentation::SaveRequestSubType(
+    const std::string& app_id,
+    const policy_table::RequestSubTypes& request_subtypes) {
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kInsertRequestSubType)) {
+    LOG4CXX_WARN(logger_, "Incorrect insert statement for request subtypes.");
+    return false;
   }
 
+  policy_table::Strings::const_iterator it;
+  if (!request_subtypes.empty()) {
+    LOG4CXX_TRACE(logger_, "Request subtypes are not empty.");
+    for (it = request_subtypes.begin(); it != request_subtypes.end(); ++it) {
+      query.Bind(0, app_id);
+      query.Bind(1, *it);
+      if (!query.Exec() || !query.Reset()) {
+        LOG4CXX_WARN(logger_, "Incorrect insert into request subtypes.");
+        return false;
+      }
+    }
+  } else if (request_subtypes.is_initialized()) {
+    LOG4CXX_WARN(logger_, "Request subtypes empty.");
+    query.Bind(0, app_id);
+    query.Bind(1, std::string("EMPTY"));
+    if (!query.Exec() || !query.Reset()) {
+      LOG4CXX_WARN(logger_, "Incorrect insert into request subtypes.");
+      return false;
+    }
+  } else {
+    utils::dbms::SQLQuery query_omitted(db());
+    if (!query_omitted.Prepare(sql_pt::kInsertOmittedRequestSubType)) {
+      LOG4CXX_WARN(logger_, "Incorrect insert statement for request subtypes.");
+      return false;
+    }
+    LOG4CXX_WARN(logger_, "Request subtypes omitted.");
+    query_omitted.Bind(0, app_id);
+    if (!query_omitted.Exec() || !query_omitted.Reset()) {
+      LOG4CXX_WARN(logger_, "Incorrect insert into request subtypes.");
+      return false;
+    }
+  }
   return true;
 }
 
@@ -1583,11 +1654,36 @@ bool SQLPTRepresentation::GatherRequestType(
     if (!policy_table::EnumFromJsonString(query.GetString(0), &type)) {
       return false;
     }
+    if (policy_table::RequestType::RT_EMPTY == type) {
+      request_types->mark_initialized();
+      continue;
+    }
     request_types->push_back(type);
   }
   return true;
 }
 
+bool SQLPTRepresentation::GatherRequestSubType(
+    const std::string& app_id,
+    policy_table::RequestSubTypes* request_subtypes) const {
+  utils::dbms::SQLQuery query(db());
+  if (!query.Prepare(sql_pt::kSelectRequestSubTypes)) {
+    LOG4CXX_WARN(logger_, "Incorrect select from request subtypes.");
+    return false;
+  }
+
+  query.Bind(0, app_id);
+  while (query.Next()) {
+    const std::string request_subtype = query.GetString(0);
+    if ("EMPTY" == request_subtype) {
+      request_subtypes->mark_initialized();
+      continue;
+    }
+    request_subtypes->push_back(request_subtype);
+  }
+  return true;
+}
+
 bool SQLPTRepresentation::GatherNickName(
     const std::string& app_id, policy_table::Strings* nicknames) const {
   utils::dbms::SQLQuery query(db());
@@ -1907,6 +2003,13 @@ bool SQLPTRepresentation::SetDefaultPolicy(const std::string& app_id) {
       !SaveRequestType(app_id, request_types)) {
     return false;
   }
+
+  policy_table::Strings request_subtypes;
+  if (!GatherRequestSubType(kDefaultId, &request_subtypes) ||
+      !SaveRequestSubType(app_id, request_subtypes)) {
+    return false;
+  }
+
   policy_table::AppHMITypes app_types;
   if (!GatherAppType(kDefaultId, &app_types) ||
       !SaveAppType(app_id, app_types)) {