public void Replace(Operation operation, object objectToApplyTo)
{
var removeResult = Remove(operation.path, objectToApplyTo, operation);
if (removeResult.HasError)
{
// return => currently not applicable, will throw exception in Remove method
}
if (!removeResult.HasError && removeResult.ActualType == null)
{
// the remove operation completed succesfully, but we could not determine the type.
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operation,
string.Format("Patch failed: could not determine type of property at location {0}", operation.path)),
422);
}
var conversionResult = PropertyHelpers.ConvertToActualType(removeResult.ActualType, operation.value);
if (!conversionResult.CanBeConverted)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operation,
string.Format("Patch failed: property value cannot be converted to type of path location {0}", operation.path)),
422);
}
Add(operation.path, conversionResult.ConvertedInstance, objectToApplyTo, operation);
}
/// <summary>
/// The "replace" operation replaces the value at the target location
/// with a new value. The operation object MUST contain a "value" member
/// whose content specifies the replacement value.
///
/// The target location MUST exist for the operation to be successful.
///
/// For example:
///
/// { "op": "replace", "path": "/a/b/c", "value": 42 }
///
/// This operation is functionally identical to a "remove" operation for
/// a value, followed immediately by an "add" operation at the same
/// location with the replacement value.
/// </summary>
/// <param name="operation">The replace operation</param>
/// <param name="objectApplyTo">Object to apply the operation to</param>
public void Replace(Operation <T> operation, T objectToApplyTo)
{
var removeResult = Remove(operation.path, objectToApplyTo, operation);
if (removeResult.HasError)
{
// return => currently not applicable, will throw exception in Remove method
}
if (!removeResult.HasError && removeResult.ActualType == null)
{
// the remove operation completed succesfully, but we could not determine the type.
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operation,
string.Format("Patch failed: could not determine type of property at location {0}", operation.path)),
422);
}
ConversionResult conversionResult;
var propType = removeResult.ActualType;
var value = operation.value;
if (!propType.IsValueType && propType != typeof(string) && value != null && value.GetType() == typeof(string))
{
object newObj;
if (CustomDeserializationHandler != null)
{
newObj = CustomDeserializationHandler(value.ToString(), propType);
}
else
{
newObj = JsonConvert.DeserializeObject(value.ToString(), propType);
}
conversionResult = new ConversionResult(true, newObj);
}
else
{
conversionResult = PropertyHelpers.ConvertToActualType(removeResult.ActualType, operation.value);
}
if (!conversionResult.CanBeConverted)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operation,
string.Format("Patch failed: property value cannot be converted to type of path location {0}", operation.path)),
422);
}
Add(operation.path, conversionResult.ConvertedInstance, objectToApplyTo, operation);
}
/// <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, object objectToApplyTo, Operation operationToReport)
{
// add, in this implementation, CAN add properties if the container is an
// ExpandoObject.
// 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.
// get path result
var pathResult = PropertyHelpers.GetActualPropertyPath(
path,
objectToApplyTo,
operationToReport,
true);
var appendList = pathResult.ExecuteAtEnd;
var positionAsInteger = pathResult.NumericEnd;
var actualPathToProperty = pathResult.PathToProperty;
var result = new ObjectTreeAnalysisResult(objectToApplyTo, actualPathToProperty, ContractResolver);
if (result.UseDynamicLogic)
{
if (result.IsValidPathForAdd)
{
if (result.Container.ContainsCaseInsensitiveKey(result.PropertyPathInParent))
{
// Existing property.
// If it's not an array, we need to check if the value fits the property type
//
// If it's an array, we need to check if the value fits in that array type,
// and add it at the correct position (if allowed).
if (appendList || positionAsInteger > -1)
{
// get the actual type
var typeOfPathProperty = result.Container
.GetValueForCaseInsensitiveKey(result.PropertyPathInParent).GetType();
if (PropertyHelpers.IsNonStringArray(typeOfPathProperty))
{
// now, get the generic type of the enumerable
var genericTypeOfArray = PropertyHelpers.GetIListType(typeOfPathProperty);
var conversionResult = PropertyHelpers.ConvertToActualType(genericTypeOfArray, value);
if (!conversionResult.CanBeConverted)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided value is invalid for array property type at location path: {0}", path)),
422);
}
// get value (it can be cast, we just checked that)
// var array = containerDictionary[finalPath] as IList;
var array = result.Container.GetValueForCaseInsensitiveKey(result.PropertyPathInParent) as IList;
if (appendList)
{
array.Add(conversionResult.ConvertedInstance);
result.Container.SetValueForCaseInsensitiveKey(result.PropertyPathInParent, array);
}
else
{
// specified index must not be greater than
// the amount of items in the array
if (positionAsInteger > array.Count)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path)),
422);
}
array.Insert(positionAsInteger, conversionResult.ConvertedInstance);
result.Container.SetValueForCaseInsensitiveKey(
result.PropertyPathInParent, array);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: expected array", path)),
422);
}
}
else
{
// get the actual type
var typeOfPathProperty = result.Container.GetValueForCaseInsensitiveKey(result.PropertyPathInParent).GetType();
// can the value be converted to the actual type?
var conversionResultTuple =
PropertyHelpers.ConvertToActualType(typeOfPathProperty, value);
// conversion successful
if (conversionResultTuple.CanBeConverted)
{
result.Container.SetValueForCaseInsensitiveKey(result.PropertyPathInParent,
conversionResultTuple.ConvertedInstance);
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided value is invalid for property type at location path: {0}", path)),
422);
}
}
}
else
{
// New property - add it.
result.Container.Add(result.PropertyPathInParent, value);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot add to the parent of the property at location path: {0}. To be able to dynamically add properties, the parent must be an ExpandoObject.", path)),
422);
}
}
else
{
if (!result.IsValidPathForAdd)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: the provided path is invalid: {0}.", path)),
422);
}
// 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.
var patchProperty = result.JsonPatchProperty;
if (appendList || positionAsInteger > -1)
{
if (PropertyHelpers.IsNonStringArray(patchProperty.Property.PropertyType))
{
// now, get the generic type of the IList<> from Property type.
var genericTypeOfArray = PropertyHelpers.GetIListType(patchProperty.Property.PropertyType);
var conversionResult = PropertyHelpers.ConvertToActualType(genericTypeOfArray, value);
if (!conversionResult.CanBeConverted)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided value is invalid for array property type at location path: {0}", path)),
422);
}
if (patchProperty.Property.Readable)
{
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(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path)),
422);
}
}
}
else
{
// cannot read the property
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot get property value at path {0}. Possible cause: the property doesn't have an accessible getter.", path)),
422);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: expected array", path)),
422);
}
}
else
{
var conversionResultTuple = PropertyHelpers.ConvertToActualType(
patchProperty.Property.PropertyType,
value);
if (conversionResultTuple.CanBeConverted)
{
if (patchProperty.Property.Writable)
{
patchProperty.Property.ValueProvider.SetValue(
patchProperty.Parent,
conversionResultTuple.ConvertedInstance);
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property at path location cannot be set: {0}. Possible causes: the property may not have an accessible setter, or the property may be part of an anonymous object (and thus cannot be changed after initialization).", path)),
422);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property value cannot be converted to type of path location {0}.", path)),
422);
}
}
}
}
/// <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.
// get path result
var pathResult = PropertyHelpers.GetActualPropertyPath(
path,
objectToApplyTo,
operationToReport,
true);
var appendList = pathResult.ExecuteAtEnd;
var positionAsInteger = pathResult.NumericEnd;
var actualPathToProperty = pathResult.PathToProperty;
var result = new ObjectTreeAnalysisResult(objectToApplyTo, actualPathToProperty, ContractResolver);
if (!result.IsValidPathForAdd)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: the provided path is invalid: {0}.", path)),
422);
}
// 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.
var patchProperty = result.JsonPatchProperty;
if (appendList || positionAsInteger > -1)
{
if (PropertyHelpers.IsNonStringList(patchProperty.Property.PropertyType))
{
// now, get the generic type of the enumerable
var genericTypeOfArray = PropertyHelpers.GetEnumerableType(patchProperty.Property.PropertyType);
var conversionResult = PropertyHelpers.ConvertToActualType(genericTypeOfArray, value);
if (!conversionResult.CanBeConverted)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided value is invalid for array property type at location path: {0}", path)),
422);
}
if (patchProperty.Property.Readable)
{
var array = (IList)patchProperty.Property.ValueProvider
.GetValue(patchProperty.Parent);
if (array == null)
{
array = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(genericTypeOfArray));
patchProperty.Property.ValueProvider.SetValue(patchProperty.Parent, array);
}
if (appendList)
{
SetValueEventArgs eArg = new SetValueEventArgs(operationToReport)
{
Cancel = false,
Index = array.Count + 1,
NewValue = conversionResult.ConvertedInstance,
ParentObject = patchProperty.Parent,
Property = patchProperty.Property
};
InvokeWithBeforeSetValue(eArg, () => array.Add(eArg.NewValue));
}
else
{
// specified index must not be greater than the amount of items in the
// array
if (positionAsInteger <= array.Count)
{
SetValueEventArgs eArg = new SetValueEventArgs(operationToReport)
{
Cancel = false,
Index = positionAsInteger,
NewValue = conversionResult.ConvertedInstance,
ParentObject = patchProperty.Parent,
Property = patchProperty.Property
};
InvokeWithBeforeSetValue(eArg, () => array.Insert(positionAsInteger, eArg.NewValue));
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path)),
422);
}
}
}
else
{
// cannot read the property
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot get property value at path {0}. Possible cause: the property doesn't have an accessible getter.", path)),
422);
}
}
else if (PropertyHelpers.IsNonStringCollection(patchProperty.Property.PropertyType))
{
// we need to do a little work with collections here. All generic collections have an "Add" operation. In this case, we should ONLY
// support adding to the end.
if (!(positionAsInteger == -1 || appendList))
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: can only insert at end of array when target type is ICollection", path)),
422);
}
var genericTypeOfCollection = PropertyHelpers.GetEnumerableType(patchProperty.Property.PropertyType);
ConversionResult conversionResult;// = PropertyHelpers.ConvertToActualType(genericTypeOfCollection, value);
if (!genericTypeOfCollection.IsValueType && genericTypeOfCollection != typeof(string) && value != null && value.GetType() == typeof(string))
{
object newObj;
if (CustomDeserializationHandler != null)
{
newObj = CustomDeserializationHandler(value.ToString(), genericTypeOfCollection);
}
else
{
newObj = JsonConvert.DeserializeObject(value.ToString(), genericTypeOfCollection);
}
conversionResult = new ConversionResult(true, newObj);
}
else if (value != null && genericTypeOfCollection.IsAssignableFrom(value.GetType()))
{
conversionResult = new ConversionResult(true, value);
}
else
{
conversionResult = PropertyHelpers.ConvertToActualType(
genericTypeOfCollection,
value);
}
if (!conversionResult.CanBeConverted)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided value is invalid for array property type at location path: {0}", path)),
422);
}
if (patchProperty.Property.Readable)
{
var array = patchProperty.Property.ValueProvider
.GetValue(patchProperty.Parent);
if (array == null)
{
// the array was null. This might mean we are dealing with a fresh object. This is okay. Lets initialize it with a basic collection.
array = Activator.CreateInstance(typeof(Collection <>).MakeGenericType(genericTypeOfCollection));
patchProperty.Property.ValueProvider.SetValue(patchProperty.Parent, array);
}
var addMethod = patchProperty.Property.PropertyType.GetMethod("Add");
SetValueEventArgs eArg = new SetValueEventArgs(operationToReport)
{
Cancel = false,
Index = -1,
NewValue = conversionResult.ConvertedInstance,
ParentObject = patchProperty.Parent,
Property = patchProperty.Property
};
InvokeWithBeforeSetValue(eArg, () => addMethod.Invoke(array, new object[] { eArg.NewValue }));
}
else
{
// cannot read the property
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot get property value at path {0}. Possible cause: the property doesn't have an accessible getter.", path)),
422);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: expected array", path)),
422);
}
}
else
{
Type propType = patchProperty.Property.PropertyType;
ConversionResult conversionResultTuple;
if (!propType.IsValueType && propType != typeof(string) && value != null && value.GetType() == typeof(string))
{
object newObj;
if (CustomDeserializationHandler != null)
{
newObj = CustomDeserializationHandler(value.ToString(), propType);
}
else
{
newObj = JsonConvert.DeserializeObject(value.ToString(), propType);
}
conversionResultTuple = new ConversionResult(true, newObj);
}
else if (value != null && patchProperty.Property.PropertyType.IsAssignableFrom(value.GetType()))
{
conversionResultTuple = new ConversionResult(true, value);
}
else
{
conversionResultTuple = PropertyHelpers.ConvertToActualType(
patchProperty.Property.PropertyType,
value);
}
if (conversionResultTuple.CanBeConverted)
{
if (patchProperty.Property.Writable)
{
SetValueEventArgs eArg = new SetValueEventArgs(operationToReport)
{
Cancel = false,
NewValue = conversionResultTuple.ConvertedInstance,
ParentObject = patchProperty.Parent,
Property = patchProperty.Property
};
InvokeWithBeforeSetValue(eArg, () => patchProperty.Property.ValueProvider.SetValue(
eArg.ParentObject,
eArg.NewValue));
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property at path location cannot be set: {0}. Possible causes: the property may not have an accessible setter, or the property may be part of an anonymous object (and thus cannot be changed after initialization).", path)),
422);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property value cannot be converted to type of path location {0}.", path)),
422);
}
}
}
/// <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 RemovedPropertyTypeResult Remove(string path, T objectToApplyTo, Operation <T> operationToReport)
{
// get path result
var pathResult = PropertyHelpers.GetActualPropertyPath(
path,
objectToApplyTo,
operationToReport,
false);
var removeFromList = pathResult.ExecuteAtEnd;
var positionAsInteger = pathResult.NumericEnd;
var actualPathToProperty = pathResult.PathToProperty;
var expressionToUse = pathResult.ExpressionEnd;
var result = new ObjectTreeAnalysisResult(objectToApplyTo, actualPathToProperty,
ContractResolver);
if (!result.IsValidPathForRemove)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: the provided path is invalid: {0}.", path)),
422);
}
var patchProperty = result.JsonPatchProperty;
if (removeFromList || positionAsInteger > -1)
{
if (expressionToUse != null)
{
// we have an expression.
var elementType = PropertyHelpers.GetCollectionType(patchProperty.Property.PropertyType);
object coll = patchProperty.Property.ValueProvider
.GetValue(patchProperty.Parent);
var remMethod = typeof(ICollection <>).MakeGenericType(elementType).GetMethod("Remove");
var objToRemove = ExpressionHelpers.GetElementAtFromObjectExpression(coll, expressionToUse);
var remResult = remMethod.Invoke(coll, new object[] { objToRemove });
if ((bool)remResult != true)
{
throw new Exception("D'oh");
}
return(new RemovedPropertyTypeResult(elementType, false));
}
else if (PropertyHelpers.IsNonStringList(patchProperty.Property.PropertyType))
{
// now, get the generic type of the enumerable
var genericTypeOfArray = PropertyHelpers.GetEnumerableType(patchProperty.Property.PropertyType);
if (patchProperty.Property.Readable)
{
var array = (IList)patchProperty.Property.ValueProvider
.GetValue(patchProperty.Parent);
if (removeFromList)
{
if (array.Count == 0)
{
// if the array is empty, we should throw an error
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path)),
422);
}
SetValueEventArgs eArg = new SetValueEventArgs(operationToReport)
{
Cancel = false,
//NewValue = conversionResultTuple.ConvertedInstance,
ParentObject = patchProperty.Parent,
Property = patchProperty.Property,
Index = array.Count - 1,
};
InvokeWithBeforeSetValue(eArg, () => array.RemoveAt(eArg.Index.Value));
// return the type of the value that has been removed
return(new RemovedPropertyTypeResult(genericTypeOfArray, false));
}
else
{
if (positionAsInteger >= array.Count)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path)),
422);
}
SetValueEventArgs eArg = new SetValueEventArgs(operationToReport)
{
Cancel = false,
//NewValue = conversionResultTuple.ConvertedInstance,
ParentObject = patchProperty.Parent,
Property = patchProperty.Property,
Index = positionAsInteger
};
InvokeWithBeforeSetValue(eArg, () => array.RemoveAt(eArg.Index.Value));
// return the type of the value that has been removed
return(new RemovedPropertyTypeResult(genericTypeOfArray, false));
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot get property value at path {0}. Possible cause: the property doesn't have an accessible getter.", path)),
422);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: expected array.", path)),
422);
}
}
else
{
if (!patchProperty.Property.Writable)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property at path location cannot be set: {0}. Possible causes: the property may not have an accessible setter, or the property may be part of an anonymous object (and thus cannot be changed after initialization).", path)),
422);
}
// set value to null, or for non-nullable value types, to its default value.
object value = null;
if (patchProperty.Property.PropertyType.GetType().IsValueType &&
Nullable.GetUnderlyingType(patchProperty.Property.PropertyType) == null)
{
value = Activator.CreateInstance(patchProperty.Property.PropertyType);
}
// check if it can be converted.
var conversionResultTuple = PropertyHelpers.ConvertToActualType(
patchProperty.Property.PropertyType,
value);
SetValueEventArgs eArg = new SetValueEventArgs(operationToReport)
{
Cancel = false,
//NewValue = conversionResultTuple.ConvertedInstance,
ParentObject = patchProperty.Parent,
Property = patchProperty.Property,
IsRemoveStepOfReplace = operationToReport.OperationType == OperationType.Replace
};
if (!conversionResultTuple.CanBeConverted)
{
// conversion failed, so use reflection (somewhat slower) to
// create a new default instance of the property type to set as value
eArg.NewValue = Activator.CreateInstance(patchProperty.Property.PropertyType);
//patchProperty.Property.ValueProvider.SetValue(patchProperty.Parent,
// Activator.CreateInstance(patchProperty.Property.PropertyType));
//return new RemovedPropertyTypeResult(patchProperty.Property.PropertyType, false);
}
else
{
eArg.NewValue = conversionResultTuple.ConvertedInstance;
}
InvokeWithBeforeSetValue(eArg, () => patchProperty.Property.ValueProvider.SetValue(eArg.ParentObject,
eArg.NewValue));
return(new RemovedPropertyTypeResult(patchProperty.Property.PropertyType, false));
}
}
/// <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>
/// 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.
// get path result
var pathResult = PropertyHelpers.GetActualPropertyPath(
path,
objectToApplyTo,
operationToReport,
true);
var appendList = pathResult.ExecuteAtEnd;
var positionAsInteger = pathResult.NumericEnd;
var actualPathToProperty = pathResult.PathToProperty;
var pathProperty = PropertyHelpers
.FindProperty(objectToApplyTo, actualPathToProperty);
// does property at path exist?
if (pathProperty == null)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property at location path: {0} does not exist", path))
, 422);
}
// 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 (pathProperty.PropertyType.IsNonStringList())
{
// now, get the generic type of the enumerable
var genericTypeOfArray = PropertyHelpers.GetEnumerableType(pathProperty.PropertyType);
var conversionResult = PropertyHelpers.ConvertToActualType(genericTypeOfArray, value);
if (!conversionResult.CanBeConverted)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided value is invalid for array property type at location path: {0}", path))
, 422);
}
if (!pathProperty.CanRead)
{
// cannot get the property
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot get property value at location from: {0}. Possible cause: the property doesn't have an accessible getter.", path)),
422);
}
// get value (it can be cast, we just checked that)
var array = PropertyHelpers.GetValue(pathProperty, objectToApplyTo, actualPathToProperty) as IList;
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(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path))
, 422);
}
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: expected array", path))
, 422);
}
}
else
{
var conversionResultTuple = PropertyHelpers.ConvertToActualType(pathProperty.PropertyType, value);
// conversion successful
if (conversionResultTuple.CanBeConverted)
{
if (!pathProperty.CanWrite)
{
// cannot set the property
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot set property value at path {0}. Possible cause: the property doesn't have an accessible setter.", path)),
422);
}
PropertyHelpers.SetValue(pathProperty, objectToApplyTo, actualPathToProperty,
conversionResultTuple.ConvertedInstance);
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided value is invalid for property type at location path: {0}", path))
, 422);
}
}
}
/// <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 RemovedPropertyTypeResult Remove(string path, T objectToApplyTo, Operation <T> operationToReport)
{
// get path result
var pathResult = PropertyHelpers.GetActualPropertyPath(
path,
objectToApplyTo,
operationToReport,
false);
var removeFromList = pathResult.ExecuteAtEnd;
var positionAsInteger = pathResult.NumericEnd;
var actualPathToProperty = pathResult.PathToProperty;
var result = new ObjectTreeAnalysisResult(objectToApplyTo, actualPathToProperty,
ContractResolver);
if (!result.IsValidPathForRemove)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: the provided path is invalid: {0}.", path)),
422);
}
var patchProperty = result.JsonPatchProperty;
if (removeFromList || positionAsInteger > -1)
{
if (PropertyHelpers.IsNonStringList(patchProperty.Property.PropertyType))
{
// now, get the generic type of the enumerable
var genericTypeOfArray = PropertyHelpers.GetEnumerableType(patchProperty.Property.PropertyType);
if (patchProperty.Property.Readable)
{
var array = (IList)patchProperty.Property.ValueProvider
.GetValue(patchProperty.Parent);
if (removeFromList)
{
if (array.Count == 0)
{
// if the array is empty, we should throw an error
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path)),
422);
}
array.RemoveAt(array.Count - 1);
// return the type of the value that has been removed
return(new RemovedPropertyTypeResult(genericTypeOfArray, false));
}
else
{
if (positionAsInteger >= array.Count)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path)),
422);
}
array.RemoveAt(positionAsInteger);
// return the type of the value that has been removed
return(new RemovedPropertyTypeResult(genericTypeOfArray, false));
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot get property value at path {0}. Possible cause: the property doesn't have an accessible getter.", path)),
422);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: expected array.", path)),
422);
}
}
else
{
if (!patchProperty.Property.Writable)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property at path location cannot be set: {0}. Possible causes: the property may not have an accessible setter, or the property may be part of an anonymous object (and thus cannot be changed after initialization).", path)),
422);
}
// set value to null, or for non-nullable value types, to its default value.
object value = null;
if (patchProperty.Property.PropertyType.GetType().IsValueType &&
Nullable.GetUnderlyingType(patchProperty.Property.PropertyType) == null)
{
value = Activator.CreateInstance(patchProperty.Property.PropertyType);
}
// check if it can be converted.
var conversionResultTuple = PropertyHelpers.ConvertToActualType(
patchProperty.Property.PropertyType,
value);
if (!conversionResultTuple.CanBeConverted)
{
// conversion failed, so use reflection (somewhat slower) to
// create a new default instance of the property type to set as value
patchProperty.Property.ValueProvider.SetValue(patchProperty.Parent,
Activator.CreateInstance(patchProperty.Property.PropertyType));
return(new RemovedPropertyTypeResult(patchProperty.Property.PropertyType, false));
}
patchProperty.Property.ValueProvider.SetValue(patchProperty.Parent,
conversionResultTuple.ConvertedInstance);
return(new RemovedPropertyTypeResult(patchProperty.Property.PropertyType, false));
}
}
/// <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.
// get path result
var pathResult = PropertyHelpers.GetActualPropertyPath(
path,
objectToApplyTo,
operationToReport,
true);
var appendList = pathResult.ExecuteAtEnd;
var positionAsInteger = pathResult.NumericEnd;
var actualPathToProperty = pathResult.PathToProperty;
var result = new ObjectTreeAnalysisResult(objectToApplyTo, actualPathToProperty, ContractResolver);
if (!result.IsValidPathForAdd)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: the provided path is invalid: {0}.", path)),
422);
}
// 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.
var patchProperty = result.JsonPatchProperty;
if (appendList || positionAsInteger > -1)
{
if (PropertyHelpers.IsNonStringList(patchProperty.Property.PropertyType))
{
// now, get the generic type of the enumerable
var genericTypeOfArray = PropertyHelpers.GetEnumerableType(patchProperty.Property.PropertyType);
var conversionResult = PropertyHelpers.ConvertToActualType(genericTypeOfArray, value);
if (!conversionResult.CanBeConverted)
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided value is invalid for array property type at location path: {0}", path)),
422);
}
if (patchProperty.Property.Readable)
{
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(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: position larger than array size", path)),
422);
}
}
}
else
{
// cannot read the property
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: cannot get property value at path {0}. Possible cause: the property doesn't have an accessible getter.", path)),
422);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: provided path is invalid for array property type at location path: {0}: expected array", path)),
422);
}
}
else
{
var conversionResultTuple = PropertyHelpers.ConvertToActualType(
patchProperty.Property.PropertyType,
value);
if (conversionResultTuple.CanBeConverted)
{
if (patchProperty.Property.Writable)
{
patchProperty.Property.ValueProvider.SetValue(
patchProperty.Parent,
conversionResultTuple.ConvertedInstance);
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property at path location cannot be set: {0}. Possible causes: the property may not have an accessible setter, or the property may be part of an anonymous object (and thus cannot be changed after initialization).", path)),
422);
}
}
else
{
throw new JsonPatchException(
new JsonPatchError(
objectToApplyTo,
operationToReport,
string.Format("Patch failed: property value cannot be converted to type of path location {0}.", path)),
422);
}
}
}