1 files changed, 226 insertions, 34 deletions

diff --git a/src/components/policy/src/policy/policy_table/table_struct/types.cc b/src/components/policy/src/policy/policy_table/table_struct/types.cc
index 92172e42a..dcbd66dce 100644
--- a/src/components/policy/src/policy/policy_table/table_struct/types.cc
+++ b/src/components/policy/src/policy/policy_table/table_struct/types.cc
@@ -22,39 +22,224 @@ namespace policy_table_interface_base {
       }
   }
 
+  // PolicyBase methods
+  PolicyBase::PolicyBase()
+    : CompositeType(kUninitialized) {
+  }
+  PolicyBase::PolicyBase(const Strings& groups, Priority priority, HmiLevel default_hmi, bool keep_context, bool steal_focus)
+    : CompositeType(kUninitialized),
+      groups(groups),
+      priority(priority),
+      default_hmi(default_hmi),
+      keep_context(keep_context),
+      steal_focus(steal_focus) {
+  }
+  PolicyBase::~PolicyBase() {
+  }
+  PolicyBase::PolicyBase(const Json::Value* value__)
+    : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+      groups(impl::ValueMember(value__, "groups")),
+      preconsented_groups(impl::ValueMember(value__, "preconsented_groups")),
+      priority(impl::ValueMember(value__, "priority")),
+      default_hmi(impl::ValueMember(value__, "default_hmi")),
+      keep_context(impl::ValueMember(value__, "keep_context")),
+      steal_focus(impl::ValueMember(value__, "steal_focus")) {
+  }
+  Json::Value PolicyBase::ToJsonValue() const {
+    Json::Value result__(Json::objectValue);
+    impl::WriteJsonField("groups", groups, &result__);
+    impl::WriteJsonField("preconsented_groups", preconsented_groups, &result__);
+    impl::WriteJsonField("priority", priority, &result__);
+    impl::WriteJsonField("default_hmi", default_hmi, &result__);
+    impl::WriteJsonField("keep_context", keep_context, &result__);
+    impl::WriteJsonField("steal_focus", steal_focus, &result__);
+    return result__;
+  }
+  bool PolicyBase::is_valid() const {
+    if (!groups.is_valid()) {
+      return false;
+    }
+    if (!preconsented_groups.is_valid()) {
+      return false;
+    }
+    if (!priority.is_valid()) {
+      return false;
+    }
+    if (!default_hmi.is_valid()) {
+      return false;
+    }
+    if (!keep_context.is_valid()) {
+      return false;
+    }
+    if (!steal_focus.is_valid()) {
+      return false;
+    }
+    return Validate();
+  }
+  bool PolicyBase::is_initialized() const {
+    return (initialization_state__ != kUninitialized) || (!struct_empty());
+  }
+  bool PolicyBase::struct_empty() const {
+    if (groups.is_initialized()) {
+      return false;
+    }
+    if (preconsented_groups.is_initialized()) {
+      return false;
+    }
+    if (priority.is_initialized()) {
+      return false;
+    }
+    if (default_hmi.is_initialized()) {
+      return false;
+    }
+    if (keep_context.is_initialized()) {
+      return false;
+    }
+    if (steal_focus.is_initialized()) {
+      return false;
+    }
+    return true;
+  }
+  void PolicyBase::ReportErrors(rpc::ValidationReport* report__) const {
+    if (struct_empty()) {
+      rpc::CompositeType::ReportErrors(report__);
+    }
+    if (!groups.is_valid()) {
+      groups.ReportErrors(&report__->ReportSubobject("groups"));
+    }
+    if (!preconsented_groups.is_valid()) {
+      preconsented_groups.ReportErrors(&report__->ReportSubobject("preconsented_groups"));
+    }
+    if (!priority.is_valid()) {
+      priority.ReportErrors(&report__->ReportSubobject("priority"));
+    }
+    if (!default_hmi.is_valid()) {
+      default_hmi.ReportErrors(&report__->ReportSubobject("default_hmi"));
+    }
+    if (!keep_context.is_valid()) {
+      keep_context.ReportErrors(&report__->ReportSubobject("keep_context"));
+    }
+    if (!steal_focus.is_valid()) {
+      steal_focus.ReportErrors(&report__->ReportSubobject("steal_focus"));
+    }
+  }
+
+  void PolicyBase::SetPolicyTableType(PolicyTableType pt_type) {
+    CompositeType::SetPolicyTableType(pt_type);
+    groups.SetPolicyTableType(pt_type);
+    priority.SetPolicyTableType(pt_type);
+  }
+
+  // DevicePolicy methods
+  DevicePolicy::DevicePolicy()
+    : PolicyBase() {
+  }
+  DevicePolicy::DevicePolicy(const Strings& groups, Priority priority, HmiLevel default_hmi, bool keep_context, bool steal_focus)
+    : PolicyBase(groups, priority, default_hmi, keep_context, steal_focus) {
+  }
+  DevicePolicy::~DevicePolicy() {
+  }
+  DevicePolicy::DevicePolicy(const Json::Value* value__)
+    : PolicyBase(value__) {
+  }
+
+  // AppPoliciesSection methods
+  ApplicationPoliciesSection::ApplicationPoliciesSection()
+    : CompositeType(kUninitialized) {
+  }
+  ApplicationPoliciesSection::ApplicationPoliciesSection(const ApplicationPolicies& apps, const DevicePolicy& device)
+    : CompositeType(kUninitialized),
+      apps(apps),
+      device(device) {
+  }
+  ApplicationPoliciesSection::~ApplicationPoliciesSection() {
+  }
+  ApplicationPoliciesSection::ApplicationPoliciesSection(const Json::Value* value__)
+    : CompositeType(InitHelper(value__, &Json::Value::isObject)),
+      apps(value__),
+      device(impl::ValueMember(value__, "device")) {
+    // Since "device" is moved to separate struct, we have to delete it from
+    // parsed apps to avoid validation issues due to possible wrong params in
+    // device section
+    apps.erase("device");
+  }
+  Json::Value ApplicationPoliciesSection::ToJsonValue() const {
+    Json::Value result__(Json::objectValue);
+    result__ = apps.ToJsonValue();
+    impl::WriteJsonField("device", device, &result__);
+    return result__;
+  }
+  bool ApplicationPoliciesSection::is_valid() const {
+    if (!device.is_valid()) {
+      return false;
+    }
+    if (!apps.is_valid()) {
+      return false;
+    }
+    return Validate();
+  }
+  bool ApplicationPoliciesSection::is_initialized() const {
+    return (initialization_state__ != kUninitialized) || (!struct_empty());
+  }
+  bool ApplicationPoliciesSection::struct_empty() const {
+    if (device.is_initialized()) {
+      return false;
+    }
+    if (apps.is_initialized()) {
+      return false;
+    }
+    return true;
+  }
+  void ApplicationPoliciesSection::ReportErrors(rpc::ValidationReport* report__) const {
+    if (struct_empty()) {
+      rpc::CompositeType::ReportErrors(report__);
+    }
+    if (!device.is_valid()) {
+      device.ReportErrors(&report__->ReportSubobject("device"));
+    }
+    if (!apps.is_valid()) {
+      apps.ReportErrors(&report__->ReportSubobject("apps"));
+    }
+  }
+
+  void ApplicationPoliciesSection::SetPolicyTableType(PolicyTableType pt_type) {
+    CompositeType::SetPolicyTableType(pt_type);
+    device.SetPolicyTableType(pt_type);
+    apps.SetPolicyTableType(pt_type);
+  }
+
 // ApplicationParams methods
 ApplicationParams::ApplicationParams()
-  : CompositeType(kUninitialized) {
+  : PolicyBase() {
 }
-ApplicationParams::ApplicationParams(const Strings& groups)
-  : CompositeType(kUninitialized),
-    groups(groups) {
+ApplicationParams::ApplicationParams(const Strings& groups, Priority priority, HmiLevel default_hmi, bool keep_context, bool steal_focus)
+  : PolicyBase(groups, priority, default_hmi, keep_context, steal_focus) {
 }
 ApplicationParams::~ApplicationParams() {
 }
 ApplicationParams::ApplicationParams(const Json::Value* value__)
-  : CompositeType(InitHelper(value__, &Json::Value::isObject)),
-    groups(impl::ValueMember(value__, "groups")),
+  : PolicyBase(value__),
     nicknames(impl::ValueMember(value__, "nicknames")),
     AppHMIType(impl::ValueMember(value__, "AppHMIType")),
-    priority(impl::ValueMember(value__, "priority")),
-    memory_kb(impl::ValueMember(value__, "memory_kb")),
+    RequestType(impl::ValueMember(value__, "RequestType")),
+    memory_kb(impl::ValueMember(value__, "memory_kb"), 0),
     heart_beat_timeout_ms(impl::ValueMember(value__, "heart_beat_timeout_ms")),
-    certificate(impl::ValueMember(value__, "certificate")) {
+    certificate(impl::ValueMember(value__, "certificate"), "not_specified") {
 }
 Json::Value ApplicationParams::ToJsonValue() const {
-  Json::Value result__(Json::objectValue);
-  impl::WriteJsonField("groups", groups, &result__);
+  Json::Value result__(PolicyBase::ToJsonValue());
   impl::WriteJsonField("nicknames", nicknames, &result__);
   impl::WriteJsonField("AppHMIType", AppHMIType, &result__);
-  impl::WriteJsonField("priority", priority, &result__);
+  impl::WriteJsonField("RequestType", RequestType, &result__);
   impl::WriteJsonField("memory_kb", memory_kb, &result__);
   impl::WriteJsonField("heart_beat_timeout_ms", heart_beat_timeout_ms, &result__);
   impl::WriteJsonField("certificate", certificate, &result__);
   return result__;
 }
 bool ApplicationParams::is_valid() const {
-  if (!groups.is_valid()) {
+  // RequestType is not validated since there is high-level validation logic,
+  // which takes into account information not available here.
+  if (!PolicyBase::is_valid()) {
     return false;
   }
   if (!nicknames.is_valid()) {
@@ -63,9 +248,6 @@ bool ApplicationParams::is_valid() const {
   if (!AppHMIType.is_valid()) {
     return false;
   }
-  if (! priority.is_valid()) {
-    return false;
-  }
   if (!memory_kb.is_valid()) {
     return false;
   }
@@ -81,30 +263,27 @@ bool ApplicationParams::is_initialized() const {
   return (initialization_state__ != kUninitialized) || (!struct_empty());
 }
 bool ApplicationParams::struct_empty() const {
-  if (groups.is_initialized()) {
+  if (!PolicyBase::is_initialized()) {
     return false;
   }
   if (nicknames.is_initialized()) {
     return false;
   }
-
   if (AppHMIType.is_initialized()) {
     return false;
   }
-  if (priority.is_initialized()) {
+  if (RequestType.is_initialized()) {
     return false;
   }
   if (memory_kb.is_initialized()) {
     return false;
   }
-
   if (heart_beat_timeout_ms.is_initialized()) {
     return false;
   }
   if (certificate.is_initialized()) {
     return false;
   }
-
   return true;
 }
 void ApplicationParams::ReportErrors(rpc::ValidationReport* report__) const {
@@ -117,12 +296,27 @@ void ApplicationParams::ReportErrors(rpc::ValidationReport* report__) const {
   if (!nicknames.is_valid()) {
     nicknames.ReportErrors(&report__->ReportSubobject("nicknames"));
   }
+  if (!preconsented_groups.is_valid()) {
+    preconsented_groups.ReportErrors(&report__->ReportSubobject("preconsented_groups"));
+  }
   if (!AppHMIType.is_valid()) {
     AppHMIType.ReportErrors(&report__->ReportSubobject("AppHMIType"));
   }
+  if (!RequestType.is_valid()) {
+    RequestType.ReportErrors(&report__->ReportSubobject("RequestType"));
+  }
   if (!priority.is_valid()) {
     priority.ReportErrors(&report__->ReportSubobject("priority"));
   }
+  if (!default_hmi.is_valid()) {
+    default_hmi.ReportErrors(&report__->ReportSubobject("default_hmi"));
+  }
+  if (!keep_context.is_valid()) {
+    keep_context.ReportErrors(&report__->ReportSubobject("keep_context"));
+  }
+  if (!steal_focus.is_valid()) {
+    steal_focus.ReportErrors(&report__->ReportSubobject("steal_focus"));
+  }
   if (!memory_kb.is_valid()) {
     memory_kb.ReportErrors(&report__->ReportSubobject("memory_kb"));
   }
@@ -135,15 +329,13 @@ void ApplicationParams::ReportErrors(rpc::ValidationReport* report__) const {
 }
 
 void ApplicationParams::SetPolicyTableType(PolicyTableType pt_type) {
-  CompositeType::SetPolicyTableType(pt_type);
+  PolicyBase::SetPolicyTableType(pt_type);
   AppHMIType.SetPolicyTableType(pt_type);
-  groups.SetPolicyTableType(pt_type);
-  priority.SetPolicyTableType(pt_type);
+  RequestType.SetPolicyTableType(pt_type);
   memory_kb.SetPolicyTableType(pt_type);
   heart_beat_timeout_ms.SetPolicyTableType(pt_type);
   certificate.SetPolicyTableType(pt_type);
 }
-
 // RpcParameters methods
 RpcParameters::RpcParameters()
   : CompositeType(kUninitialized) {
@@ -853,9 +1045,9 @@ void DeviceParams::ReportErrors(rpc::ValidationReport* report__) const {
 PolicyTable::PolicyTable()
   : CompositeType(kUninitialized) {
 }
-PolicyTable::PolicyTable(const ApplicationPolicies& app_policies, const FunctionalGroupings& functional_groupings, const ConsumerFriendlyMessages& consumer_friendly_messages, const ModuleConfig& module_config)
+PolicyTable::PolicyTable(const ApplicationPoliciesSection& app_policies_section, const FunctionalGroupings& functional_groupings, const ConsumerFriendlyMessages& consumer_friendly_messages, const ModuleConfig& module_config)
   : CompositeType(kUninitialized),
-    app_policies(app_policies),
+    app_policies_section(app_policies_section),
     functional_groupings(functional_groupings),
     consumer_friendly_messages(consumer_friendly_messages),
     module_config(module_config) {
@@ -864,7 +1056,7 @@ PolicyTable::~PolicyTable() {
 }
 PolicyTable::PolicyTable(const Json::Value* value__)
   : CompositeType(InitHelper(value__, &Json::Value::isObject)),
-    app_policies(impl::ValueMember(value__, "app_policies")),
+    app_policies_section(impl::ValueMember(value__, "app_policies")),
     functional_groupings(impl::ValueMember(value__, "functional_groupings")),
     consumer_friendly_messages(impl::ValueMember(value__, "consumer_friendly_messages")),
     module_config(impl::ValueMember(value__, "module_config")),
@@ -874,7 +1066,7 @@ PolicyTable::PolicyTable(const Json::Value* value__)
 }
 Json::Value PolicyTable::ToJsonValue() const {
   Json::Value result__(Json::objectValue);
-  impl::WriteJsonField("app_policies", app_policies, &result__);
+  impl::WriteJsonField("app_policies", app_policies_section, &result__);
   impl::WriteJsonField("functional_groupings", functional_groupings, &result__);
   impl::WriteJsonField("consumer_friendly_messages", consumer_friendly_messages, &result__);
   impl::WriteJsonField("module_config", module_config, &result__);
@@ -884,7 +1076,7 @@ Json::Value PolicyTable::ToJsonValue() const {
   return result__;
 }
 bool PolicyTable::is_valid() const {
-  if (!app_policies.is_valid()) {
+  if (!app_policies_section.is_valid()) {
     return false;
   }
   if (!functional_groupings.is_valid()) {
@@ -911,7 +1103,7 @@ bool PolicyTable::is_initialized() const {
   return (initialization_state__ != kUninitialized) || (!struct_empty());
 }
 bool PolicyTable::struct_empty() const {
-  if (app_policies.is_initialized()) {
+  if (app_policies_section.is_initialized()) {
     return false;
   }
   if (functional_groupings.is_initialized()) {
@@ -950,8 +1142,8 @@ void PolicyTable::ReportErrors(rpc::ValidationReport* report__) const {
       report__->ReportSubobject("device_data").set_validation_info(validation_info);
     }
   }
-  if (!app_policies.is_valid()) {
-    app_policies.ReportErrors(&report__->ReportSubobject("app_policies"));
+  if (!app_policies_section.is_valid()) {
+    app_policies_section.ReportErrors(&report__->ReportSubobject("app_policies"));
   }
   if (!functional_groupings.is_valid()) {
     functional_groupings.ReportErrors(&report__->ReportSubobject("functional_groupings"));
@@ -975,7 +1167,7 @@ void PolicyTable::ReportErrors(rpc::ValidationReport* report__) const {
 
 void PolicyTable::SetPolicyTableType(PolicyTableType pt_type) {
   CompositeType::SetPolicyTableType(pt_type);
-  app_policies.SetPolicyTableType(pt_type);
+  app_policies_section.SetPolicyTableType(pt_type);
   functional_groupings.SetPolicyTableType(pt_type);
   consumer_friendly_messages.SetPolicyTableType(pt_type);
   module_config.SetPolicyTableType(pt_type);