1 files changed, 115 insertions, 31 deletions

diff --git a/src/components/smart_objects/src/object_schema_item.cc b/src/components/smart_objects/src/object_schema_item.cc
index 2bed3d9a26..742c2ec353 100644
--- a/src/components/smart_objects/src/object_schema_item.cc
+++ b/src/components/smart_objects/src/object_schema_item.cc
@@ -41,35 +41,83 @@ const char connection_key[] = "connection_key";
 const char binary_data[] = "binary_data";
 const char app_id[] = "appID";
 }
-namespace NsSmartDeviceLink {
-namespace NsSmartObjects {
+namespace ns_smart_device_link {
+namespace ns_smart_objects {
 
 CObjectSchemaItem::SMember::SMember()
-    : mSchemaItem(CAlwaysFalseSchemaItem::create()), mIsMandatory(true) {}
+    : mSchemaItem(CAlwaysFalseSchemaItem::create())
+    , mIsMandatory(true)
+    , mIsDeprecated(false)
+    , mIsRemoved(false) {}
 
-CObjectSchemaItem::SMember::SMember(const ISchemaItemPtr SchemaItem,
-                                    const bool IsMandatory)
-    : mSchemaItem(SchemaItem), mIsMandatory(IsMandatory) {}
+CObjectSchemaItem::SMember::SMember(
+    const ISchemaItemPtr SchemaItem,
+    const bool IsMandatory,
+    const std::string& Since,
+    const std::string& Until,
+    const bool IsDeprecated,
+    const bool IsRemoved,
+    const std::vector<CObjectSchemaItem::SMember>& history_vector)
+    : mSchemaItem(SchemaItem), mIsMandatory(IsMandatory) {
+  if (Since.size() > 0) {
+    utils::SemanticVersion since_struct(Since);
+    if (since_struct.isValid()) {
+      mSince = since_struct;
+    }
+  }
+  if (Until.size() > 0) {
+    utils::SemanticVersion until_struct(Until);
+    if (until_struct.isValid()) {
+      mUntil = until_struct;
+    }
+  }
+  mIsDeprecated = IsDeprecated;
+  mIsRemoved = IsRemoved;
+  mHistoryVector = history_vector;
+}
 
-utils::SharedPtr<CObjectSchemaItem> CObjectSchemaItem::create(
-    const Members& members) {
-  return new CObjectSchemaItem(members);
+bool CObjectSchemaItem::SMember::CheckHistoryFieldVersion(
+    const utils::SemanticVersion& MessageVersion) const {
+  if (MessageVersion.isValid()) {
+    if (mSince != boost::none) {
+      if (MessageVersion < mSince.get()) {
+        return false;  // Msg version predates `since` field
+      } else {
+        if (mUntil != boost::none && (MessageVersion >= mUntil.get())) {
+          return false;  // Msg version newer than `until` field
+        } else {
+          return true;  // Mobile msg version falls within specified version
+                        // range
+        }
+      }
+    }
+
+    if (mUntil != boost::none && (MessageVersion >= mUntil.get())) {
+      return false;  // Msg version newer than `until` field
+    } else {
+      return true;  // Mobile msg version falls within specified version range
+    }
+  }
+
+  return true;  // Not enough version information. Default true.
 }
 
-Errors::eType CObjectSchemaItem::validate(const SmartObject& object) {
-  rpc::ValidationReport report("RPC");
-  return validate(object, &report);
+std::shared_ptr<CObjectSchemaItem> CObjectSchemaItem::create(
+    const Members& members) {
+  return std::shared_ptr<CObjectSchemaItem>(new CObjectSchemaItem(members));
 }
 
-Errors::eType CObjectSchemaItem::validate(const SmartObject& object,
-                                          rpc::ValidationReport* report__) {
+errors::eType CObjectSchemaItem::validate(
+    const SmartObject& object,
+    rpc::ValidationReport* report__,
+    const utils::SemanticVersion& MessageVersion) {
   if (SmartType_Map != object.getType()) {
     std::string validation_info = "Incorrect type, expected: " +
                                   SmartObject::typeToString(SmartType_Map) +
                                   ", got: " +
                                   SmartObject::typeToString(object.getType());
     report__->set_validation_info(validation_info);
-    return Errors::INVALID_VALUE;
+    return errors::INVALID_VALUE;
   }
 
   std::set<std::string> object_keys = object.enumerate();
@@ -78,35 +126,42 @@ Errors::eType CObjectSchemaItem::validate(const SmartObject& object,
        ++it) {
     const std::string& key = it->first;
     const SMember& member = it->second;
+    const SMember& correct_member = GetCorrectMember(member, MessageVersion);
 
     std::set<std::string>::const_iterator key_it = object_keys.find(key);
     if (object_keys.end() == key_it) {
-      if (member.mIsMandatory) {
+      if (correct_member.mIsMandatory == true &&
+          correct_member.mIsRemoved == false) {
         std::string validation_info = "Missing mandatory parameter: " + key;
         report__->set_validation_info(validation_info);
-        return Errors::MISSING_MANDATORY_PARAMETER;
+        return errors::MISSING_MANDATORY_PARAMETER;
       }
       continue;
     }
     const SmartObject& field = object.getElement(key);
-    const Errors::eType result =
-        member.mSchemaItem->validate(field, &report__->ReportSubobject(key));
-    if (Errors::OK != result) {
+
+    errors::eType result = errors::OK;
+    // Check if MessageVersion matches schema version
+    result = correct_member.mSchemaItem->validate(
+        field, &report__->ReportSubobject(key), MessageVersion);
+    if (errors::OK != result) {
       return result;
     }
     object_keys.erase(key_it);
   }
-  return Errors::OK;
+  return errors::OK;
 }
 
-void CObjectSchemaItem::applySchema(SmartObject& Object,
-                                    const bool RemoveFakeParameters) {
+void CObjectSchemaItem::applySchema(
+    SmartObject& Object,
+    const bool RemoveFakeParameters,
+    const utils::SemanticVersion& MessageVersion) {
   if (SmartType_Map != Object.getType()) {
     return;
   }
 
   if (RemoveFakeParameters) {
-    RemoveFakeParams(Object);
+    RemoveFakeParams(Object, MessageVersion);
   }
 
   SmartObject default_value;
@@ -117,10 +172,12 @@ void CObjectSchemaItem::applySchema(SmartObject& Object,
     if (!Object.keyExists(key)) {
       if (member.mSchemaItem->setDefaultValue(default_value)) {
         Object[key] = default_value;
-        member.mSchemaItem->applySchema(Object[key], RemoveFakeParameters);
+        member.mSchemaItem->applySchema(
+            Object[key], RemoveFakeParameters, MessageVersion);
       }
     } else {
-      member.mSchemaItem->applySchema(Object[key], RemoveFakeParameters);
+      member.mSchemaItem->applySchema(
+          Object[key], RemoveFakeParameters, MessageVersion);
     }
   }
 }
@@ -173,22 +230,49 @@ size_t CObjectSchemaItem::GetMemberSize() {
 CObjectSchemaItem::CObjectSchemaItem(const Members& members)
     : mMembers(members) {}
 
-void CObjectSchemaItem::RemoveFakeParams(SmartObject& Object) {
+void CObjectSchemaItem::RemoveFakeParams(
+    SmartObject& Object, const utils::SemanticVersion& MessageVersion) {
   for (SmartMap::const_iterator it = Object.map_begin();
        it != Object.map_end();) {
     const std::string& key = it->first;
-    if (mMembers.end() == mMembers.find(key)
+    std::map<std::string, SMember>::const_iterator members_it =
+        mMembers.find(key);
+    if (mMembers.end() == members_it
         // FIXME(EZamakhov): Remove illegal usage of filed in AM
         &&
         key.compare(connection_key) != 0 && key.compare(binary_data) != 0 &&
         key.compare(app_id) != 0) {
       ++it;
       Object.erase(key);
+
+    } else if (mMembers.end() != members_it &&
+               GetCorrectMember(members_it->second, MessageVersion)
+                   .mIsRemoved) {
+      ++it;
+      Object.erase(key);
     } else {
-      it++;
+      ++it;
+    }
+  }
+}
+
+const CObjectSchemaItem::SMember& CObjectSchemaItem::GetCorrectMember(
+    const SMember& member, const utils::SemanticVersion& messageVersion) {
+  // Check if member is the correct version
+  if (member.CheckHistoryFieldVersion(messageVersion)) {
+    return member;
+  }
+  // Check for history tag items
+  if (!member.mHistoryVector.empty()) {
+    for (uint i = 0; i < member.mHistoryVector.size(); i++) {
+      if (member.mHistoryVector[i].CheckHistoryFieldVersion(messageVersion)) {
+        return member.mHistoryVector[i];
+      }
     }
   }
+  // Return member as default
+  return member;
 }
 
-}  // namespace NsSmartObjects
-}  // namespace NsSmartDeviceLink
+}  // namespace ns_smart_objects
+}  // namespace ns_smart_device_link