/// <summary> /// Add is used by various operations (eg: add, copy, ...), yet through different operations; /// This method allows code reuse yet reporting the correct operation on error /// </summary> private void Add(string path, object value, T objectToApplyTo, Operation <T> operationToReport) { // add, in this implementation, does not just "add" properties - that's // technically impossible; It can however be used to add items to arrays, // or to replace values. // first up: if the path ends in a numeric value, we're inserting in a list and // that value represents the position; if the path ends in "-", we're appending // to the list. var appendList = false; var positionAsInteger = -1; var actualPathToProperty = path; if (path.EndsWith("/-")) { appendList = true; actualPathToProperty = path.Substring(0, path.Length - 2); } else { positionAsInteger = PropertyHelpers.GetNumericEnd(path); if (positionAsInteger > -1) { actualPathToProperty = path.Substring(0, path.IndexOf('/' + positionAsInteger.ToString())); } } var patchProperty = PropertyHelpers .FindPropertyAndParent(objectToApplyTo, actualPathToProperty, ContractResolver); // does property at path exist? CheckIfPropertyExists(patchProperty, objectToApplyTo, operationToReport, path); // it exists. If it' an array, add to that array. If it's not, we replace. // is the path an array (but not a string (= char[]))? In this case, // the path must end with "/position" or "/-", which we already determined before. if (appendList || positionAsInteger > -1) { // what if it's an array but there's no position?? if (IsNonStringArray(patchProperty)) { // now, get the generic type of the enumerable var genericTypeOfArray = PropertyHelpers.GetEnumerableType( patchProperty.Property.PropertyType); var conversionResult = PropertyHelpers.ConvertToActualType(genericTypeOfArray, value); CheckIfPropertyCanBeSet(conversionResult, objectToApplyTo, operationToReport, path); // get value (it can be cast, we just checked that) var array = (IList)patchProperty.Property.ValueProvider.GetValue(patchProperty.Parent); if (appendList) { array.Add(conversionResult.ConvertedInstance); } else { // specified index must not be greater than the amount of items in the array if (positionAsInteger <= array.Count) { array.Insert(positionAsInteger, conversionResult.ConvertedInstance); } else { throw new JsonPatchException <T>(operationToReport, string.Format("Patch failed: provided path is invalid for array property type at " + "location path: {0}: position larger than array size", path, 422), objectToApplyTo); } } } else { throw new JsonPatchException <T>(operationToReport, string.Format("Patch failed: provided path is invalid for array property type at location " + "path: {0}: expected array", path), objectToApplyTo, 422); } } else { var conversionResultTuple = PropertyHelpers.ConvertToActualType( patchProperty.Property.PropertyType, value); // Is conversion successful CheckIfPropertyCanBeSet(conversionResultTuple, objectToApplyTo, operationToReport, path); patchProperty.Property.ValueProvider.SetValue( patchProperty.Parent, conversionResultTuple.ConvertedInstance); } }
/// <summary> /// The "test" operation tests that a value at the target location is /// equal to a specified value. /// /// The operation object MUST contain a "value" member that conveys the /// value to be compared to the target location's value. /// /// The target location MUST be equal to the "value" value for the /// operation to be considered successful. /// /// Here, "equal" means that the value at the target location and the /// value conveyed by "value" are of the same JSON type, and that they /// are considered equal by the following rules for that type: /// /// o strings: are considered equal if they contain the same number of /// Unicode characters and their code points are byte-by-byte equal. /// /// o numbers: are considered equal if their values are numerically /// equal. /// /// o arrays: are considered equal if they contain the same number of /// values, and if each value can be considered equal to the value at /// the corresponding position in the other array, using this list of /// type-specific rules. /// /// o objects: are considered equal if they contain the same number of /// members, and if each member can be considered equal to a member in /// the other object, by comparing their keys (as strings) and their /// values (using this list of type-specific rules). /// /// o literals (false, true, and null): are considered equal if they are /// the same. /// /// Note that the comparison that is done is a logical comparison; e.g., /// whitespace between the member values of an array is not significant. /// /// Also, note that ordering of the serialization of object members is /// not significant. /// /// Note that we divert from the rules here - we use .NET's comparison, /// not the one above. In a future version, a "strict" setting might /// be added (configurable), that takes into account above rules. /// /// For example: /// /// { "op": "test", "path": "/a/b/c", "value": "foo" } /// </summary> /// <param name="operation">The test operation</param> /// <param name="objectApplyTo">Object to apply the operation to</param> public void Test(Operation <T> operation, T objectToApplyTo) { // get value at path location object valueAtPathLocation = null; var positionInPathAsInteger = -1; var actualPathProperty = operation.path; positionInPathAsInteger = PropertyHelpers.GetNumericEnd(operation.path); if (positionInPathAsInteger > -1) { actualPathProperty = operation.path.Substring(0, operation.path.IndexOf('/' + positionInPathAsInteger.ToString())); } var patchProperty = PropertyHelpers .FindPropertyAndParent(objectToApplyTo, actualPathProperty, ContractResolver); // does property at path exist? CheckIfPropertyExists(patchProperty, objectToApplyTo, operation, operation.path); // get the property path Type typeOfFinalPropertyAtPathLocation; // is the path an array (but not a string (= char[]))? In this case, // the path must end with "/position" or "/-", which we already determined before. if (positionInPathAsInteger > -1) { if (IsNonStringArray(patchProperty)) { // now, get the generic type of the enumerable typeOfFinalPropertyAtPathLocation = PropertyHelpers .GetEnumerableType(patchProperty.Property.PropertyType); // get value (it can be cast, we just checked that) var array = (IList)patchProperty.Property.ValueProvider.GetValue(patchProperty.Parent); if (array.Count <= positionInPathAsInteger) { throw new JsonPatchException <T>(operation, string.Format("Patch failed: provided from path is invalid for array property type at " + "location path: {0}: invalid position", operation.path), objectToApplyTo, 422); } valueAtPathLocation = array[positionInPathAsInteger]; } else { throw new JsonPatchException <T>(operation, string.Format("Patch failed: provided from path is invalid for array property type at " + "location path: {0}: expected array", operation.path), objectToApplyTo, 422); } } else { // no list, just get the value valueAtPathLocation = patchProperty.Property.ValueProvider.GetValue(patchProperty.Parent); typeOfFinalPropertyAtPathLocation = patchProperty.Property.PropertyType; } var conversionResultTuple = PropertyHelpers.ConvertToActualType( typeOfFinalPropertyAtPathLocation, operation.value); // Is conversion successful CheckIfPropertyCanBeSet(conversionResultTuple, objectToApplyTo, operation, operation.path); //Compare }
/// <summary> /// The "copy" operation copies the value at a specified location to the /// target location. /// /// The operation object MUST contain a "from" member, which is a string /// containing a JSON Pointer value that references the location in the /// target document to copy the value from. /// /// The "from" location MUST exist for the operation to be successful. /// /// For example: /// /// { "op": "copy", "from": "/a/b/c", "path": "/a/b/e" } /// /// This operation is functionally identical to an "add" operation at the /// target location using the value specified in the "from" member. /// /// Note: even though it's the same functionally, we do not call add with /// the value specified in from for performance reasons (multiple checks of same requirements). /// </summary> /// <param name="operation">The copy operation</param> /// <param name="objectApplyTo">Object to apply the operation to</param> public void Copy(Operation <T> operation, T objectToApplyTo) { // get value at from location object valueAtFromLocation = null; var positionAsInteger = -1; var actualFromProperty = operation.from; positionAsInteger = PropertyHelpers.GetNumericEnd(operation.from); if (positionAsInteger > -1) { actualFromProperty = operation.from.Substring(0, operation.from.IndexOf('/' + positionAsInteger.ToString())); } var patchProperty = PropertyHelpers .FindPropertyAndParent(objectToApplyTo, actualFromProperty, ContractResolver); // does property at from exist? CheckIfPropertyExists(patchProperty, objectToApplyTo, operation, operation.from); // get the property path // is the path an array (but not a string (= char[]))? In this case, // the path must end with "/position" or "/-", which we already determined before. if (positionAsInteger > -1) { if (IsNonStringArray(patchProperty)) { // now, get the generic type of the enumerable var genericTypeOfArray = PropertyHelpers.GetEnumerableType(patchProperty.Property.PropertyType); // get value (it can be cast, we just checked that) var array = (IList)patchProperty.Property.ValueProvider.GetValue(patchProperty.Parent); if (array.Count <= positionAsInteger) { throw new JsonPatchException <T>(operation, string.Format("Patch failed: provided from path is invalid for array property type at " + "location from: {0}: invalid position", operation.from), objectToApplyTo, 422); } valueAtFromLocation = array[positionAsInteger]; } else { throw new JsonPatchException <T>(operation, string.Format("Patch failed: provided from path is invalid for array property type at " + "location from: {0}: expected array", operation.from), objectToApplyTo, 422); } } else { // no list, just get the value // set the new value valueAtFromLocation = patchProperty.Property.ValueProvider.GetValue(patchProperty.Parent); } // add operation to target location with that value. Add(operation.path, valueAtFromLocation, objectToApplyTo, operation); }
/// <summary> /// Remove is used by various operations (eg: remove, move, ...), yet through different operations; /// This method allows code reuse yet reporting the correct operation on error /// </summary> private void Remove(string path, T objectToApplyTo, Operation <T> operationToReport) { var removeFromList = false; var positionAsInteger = -1; var actualPathToProperty = path; if (path.EndsWith("/-")) { removeFromList = true; actualPathToProperty = path.Substring(0, path.Length - 2); } else { positionAsInteger = PropertyHelpers.GetNumericEnd(path); if (positionAsInteger > -1) { actualPathToProperty = path.Substring(0, path.IndexOf('/' + positionAsInteger.ToString())); } } var patchProperty = PropertyHelpers .FindPropertyAndParent(objectToApplyTo, actualPathToProperty, ContractResolver); // does the target location exist? CheckIfPropertyExists(patchProperty, objectToApplyTo, operationToReport, path); // get the property, and remove it - in this case, for DTO's, that means setting // it to null or its default value; in case of an array, remove at provided index // or at the end. if (removeFromList || positionAsInteger > -1) { // what if it's an array but there's no position?? if (IsNonStringArray(patchProperty)) { // now, get the generic type of the enumerable var genericTypeOfArray = PropertyHelpers.GetEnumerableType(patchProperty.Property.PropertyType); // get value (it can be cast, we just checked that) var array = (IList)patchProperty.Property.ValueProvider.GetValue(patchProperty.Parent); if (removeFromList) { array.RemoveAt(array.Count - 1); } else { if (positionAsInteger < array.Count) { array.RemoveAt(positionAsInteger); } else { throw new JsonPatchException <T>(operationToReport, string.Format("Patch failed: provided path is invalid for array property type at " + "location path: {0}: position larger than array size", path), objectToApplyTo, 422); } } } else { throw new JsonPatchException <T>(operationToReport, string.Format("Patch failed: provided path is invalid for array property type at " + "location path: {0}: expected array", path), objectToApplyTo, 422); } } else { // setting the value to "null" will use the default value in case of value types, and // null in case of reference types object value = null; if (patchProperty.Property.PropertyType.GetTypeInfo().IsValueType && Nullable.GetUnderlyingType(patchProperty.Property.PropertyType) == null) { value = Activator.CreateInstance(patchProperty.Property.PropertyType); } patchProperty.Property.ValueProvider.SetValue(patchProperty.Parent, value); } }