/// <summary>
/// Initializes a new instance of the <see cref="JsonDynamicContract"/> class.
/// </summary>
/// <param name="underlyingType">The underlying type for the contract.</param>
public JsonDynamicContract(Type underlyingType)
: base(underlyingType)
{
ContractType = JsonContractType.Dynamic;
Properties = new JsonPropertyCollection(UnderlyingType);
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonObjectContract"/> class.
/// </summary>
/// <param name="underlyingType">The underlying type for the contract.</param>
public JsonObjectContract(Type underlyingType)
: base(underlyingType)
{
ContractType = JsonContractType.Object;
Properties = new JsonPropertyCollection(UnderlyingType);
ConstructorParameters = new JsonPropertyCollection(UnderlyingType);
}
/// <summary>
/// Creates properties for the given <see cref="JsonContract"/>.
/// </summary>
/// <param name="type">The type to create properties for.</param>
/// /// <param name="memberSerialization">The member serialization mode for the type.</param>
/// <returns>Properties for the given <see cref="JsonContract"/>.</returns>
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var members = GetSerializableMembers(type);
if (members == null)
{
throw new JsonSerializationException("Null collection of seralizable members returned.");
}
var properties = new JsonPropertyCollection(type);
var modelConfiguration = _breezeConfigurator.GetModelConfiguration(type);
foreach (var member in members)
{
var property = CreateProperty(type, member, memberSerialization, modelConfiguration);
if (property != null)
{
var nameTable = DefaultContractResolverStateNameTableField.GetValue(this);
// nametable is not thread-safe for multiple writers
lock (nameTable)
{
property.PropertyName = (string)PropertyNameTableAddMethod
.Invoke(nameTable, new object[] { property.PropertyName });
}
properties.AddProperty(property);
}
}
var syntheticPoperties = _getMetadataFunc(type).GetSyntheticProperties();
if (syntheticPoperties != null && syntheticPoperties.Any())
{
foreach (var syntheticProp in syntheticPoperties)
{
var propertyName = ResolvePropertyName(syntheticProp.Name);
// Skip manually added syntetic properties
if (!properties.Any(x => x.PropertyName == propertyName))
{
properties.Add(new JsonProperty
{
Readable = true,
Writable = true,
PropertyName = propertyName,
PropertyType = syntheticProp.PkType.ReturnedClass,
ValueProvider = new NHSyntheticPropertyValueProvider(syntheticProp)
});
}
}
}
IList <JsonProperty> orderedProperties = properties.OrderBy(p => p.Order ?? -1).ToList();
ApplySerializationRules(type, orderedProperties, memberSerialization);
return(orderedProperties);
}
protected override IList <JsonProperty> CreateProperties(JsonObjectContract contract)
{
IList <JsonProperty> properties = base.CreateProperties(contract);
JsonPropertyCollection c = new JsonPropertyCollection();
CollectionUtils.AddRange(c, (IEnumerable)properties.Where(m => m.PropertyName != "Root"));
return(c);
}
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
IList <JsonProperty> properties = base.CreateProperties(type, memberSerialization);
JsonPropertyCollection c = new JsonPropertyCollection(type);
c.AddRange(properties.Where(m => m.PropertyName != "Root"));
return(c);
}
/// <summary>
/// Creates a list of <see cref="JsonPathProperty"/> from the <paramref name="properties"/>
/// that has been attributed with the <see cref="JsonPathAttribute"/>.
/// </summary>
/// <param name="properties"></param>
protected virtual List <JsonPathProperty> GetJsonPathProperties(JsonPropertyCollection properties)
{
var jsonPathProperties = from jsonProperty in properties
let attribute = jsonProperty.GetAttribute <JsonPathAttribute>()
where attribute != null
select new JsonPathProperty
{
JsonProperty = jsonProperty,
Expression = attribute.Expression
};
return(jsonPathProperties.ToList());
}
protected override IList <JsonProperty> CreateConstructorParameters(ConstructorInfo constructor, JsonPropertyCollection memberProperties)
{
var constructorParameters = constructor.GetParameters();
JsonPropertyCollection parameterCollection = new JsonPropertyCollection(constructor.DeclaringType);
foreach (ParameterInfo parameterInfo in constructorParameters)
{
var matchingMemberProperty = (parameterInfo.Name != null) ? memberProperties.GetClosestMatchProperty(parameterInfo.Name) : null;
// Constructor type must be assignable from property type.
// Note that this is the only difference between this method and the method it overrides in DefaultContractResolver.
// In DefaultContractResolver, the types must match exactly.
if (matchingMemberProperty != null)
{
var memberType = matchingMemberProperty.PropertyType;
var memberTypeIsGeneric = memberType.IsGenericType;
var memberGenericArguments = memberType.GetGenericArguments();
var parameterTypeIsArray = parameterInfo.ParameterType.IsArray;
var parameterElementType = parameterInfo.ParameterType.GetElementType();
if (parameterTypeIsArray &&
memberTypeIsGeneric &&
memberGenericArguments.Length == 1 &&
memberType.IsAssignableTo(typeof(IEnumerable <>).MakeGenericType(parameterElementType)))
{
// NO-OP - this allows for the constructor parameter to be a "params" array while still using a collection property as the source.
}
else if (memberType.IsAssignableTo(parameterInfo.ParameterType))
{
// NO-OP - vanilla assignable type to constructor check.
}
else
{
// no way to do this so null out and the let the next step error with a clean message.
matchingMemberProperty = null;
}
}
if (matchingMemberProperty != null || parameterInfo.Name != null)
{
var property = this.CreatePropertyFromConstructorParameterWithConstructorInfo(matchingMemberProperty, parameterInfo, constructor);
if (property != null)
{
parameterCollection.AddProperty(property);
}
}
}
return(parameterCollection);
}
//////////////////////////////////////////////////
///
/// <author>Nicholas Paldino</author>
/// <created>2014-03-21</created>
/// <summary>Given a <paramref name="type"/>, resolves
/// the <see cref="JsonContract"/> for that type.</summary>
/// <param name="type">The <see cref="Type"/> that the contract
/// is to be resolved to.</param>
/// <returns>The <see cref="JsonContract"/> that was resolved from
/// the type.</returns>
///
//////////////////////////////////////////////////
public JsonContract ResolveContract(Type type)
{
// Validate parameters.
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
// Call the decorated instance.
JsonContract contract = _contractResolver.ResolveContract(type);
// The properties collection.
JsonPropertyCollection properties = null;
// Check for type.
var objectContract = contract as JsonObjectContract;
// Assign.
if (objectContract != null)
{
properties = objectContract.Properties;
}
else
{
// Type sniff.
var dynamicContract = contract as JsonDynamicContract;
// Assign.
if (dynamicContract != null)
{
properties = dynamicContract.Properties;
}
}
// If the properties is null, return the contract.
if (properties == null)
{
return(contract);
}
// Cycle through the properties.
foreach (JsonProperty property in properties)
{
// Make writable.
property.Writable = true;
}
// Return the contract.
return(contract);
}
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization serialization)
{
var properties = new JsonPropertyCollection(type);
foreach (JsonProperty property in GetSerializableMembers(type).Select(m => CreateProperty(m, serialization)).WhereNotNull())
{
properties.AddProperty(property);
}
return(properties
.OrderBy(p => p.Order ?? -1)
.ThenBy(IsPropertyCollection)
.ThenBy(GetPropertyTypeDepth)
.ThenBy(p => p.PropertyName)
.ToList());
}
/// <inheritdoc />
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
if (typeof(INHibernateProxy).IsAssignableFrom(type))
{
return(new List <JsonProperty>()); // They will be copied from the base type
}
var members = GetSerializableMembers(type);
if (members == null)
{
throw new JsonSerializationException("Null collection of serializable members returned.");
}
var propertyMembers = new Dictionary <JsonProperty, MemberInfo>(members.Count);
var modelConfiguration = _breezeConfigurator.GetModelConfiguration(type);
var metadata = GetTypeMetadata(type);
var properties = new JsonPropertyCollection(type);
foreach (var member in members)
{
var property = CreateProperty(member, memberSerialization, metadata);
propertyMembers.Add(property, member);
properties.AddProperty(property);
}
foreach (var syntheticMember in modelConfiguration.SyntheticMembers.Values.Where(o => o.Added))
{
properties.AddProperty(CreateSyntheticProperty(syntheticMember));
}
if (metadata != null)
{
foreach (var syntheticProperty in metadata.SyntheticForeignKeyProperties.Values)
{
properties.AddProperty(CreateSyntheticForeignKeyProperty(
type,
syntheticProperty,
modelConfiguration.GetSyntheticMember(syntheticProperty.Name),
modelConfiguration.GetMember(syntheticProperty.AssociationPropertyName)));
}
}
ApplyModelConfiguration(type, properties, modelConfiguration, metadata, propertyMembers);
return(properties.OrderBy(p => p.Order ?? -1).ToList());
}
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
if (!type.Implements <IDwarf>())
{
return(base.CreateProperties(type, memberSerialization));
}
var members = GetSerializableMembers(type);
if (members == null)
{
throw new JsonSerializationException("Null collection of seralizable members returned.");
}
var properties = new JsonPropertyCollection(type);
foreach (var member in members)
{
var property = CreateProperty(member, memberSerialization);
if (member.GetCustomAttributes <IgnoreDataMemberAttribute>().Any())
{
continue;
}
if (member.GetCustomAttributes <JsonIdOnlyAttribute>().Any())
{
property.PropertyName += "Id";
property.Converter = jsonIdOnlyConverter;
}
if (property != null)
{
properties.AddProperty(property);
}
}
var orderedProperties = properties.OrderBy(p => p.Order ?? -1).ToList();
orderedProperties.Move(orderedProperties.FirstOrDefault(x => x.PropertyName == "id"), 0);
orderedProperties.Move(orderedProperties.FirstOrDefault(x => x.PropertyName == "isSaved"), 1);
return(orderedProperties);
}
private Type ResolveImplType(Type objectType, JObject givenJObject, JsonSerializer serializer)
{
Type targetType = ResolveImplTypeUsingTypeResolverMethod(objectType, givenJObject, serializer);
if (targetType != null)
{
return(targetType);
}
IEnumerable <Type> knownImplTypes =
System.Attribute.GetCustomAttributes(objectType) // Select all custom attribute
.Where(ca => ca is KnownTypeAttribute) // filter which are KnownTypeAttribute
.Select(kta => (kta as KnownTypeAttribute).Type); // return type of Attribute as type of KnownTypeAttribute
var jsonKeysInJsonString = givenJObject.Select <KeyValuePair <string, JToken>, string>(kv => kv.Key).ToList();
var candidateJsonPropertiesUnion = new JsonPropertyCollection(objectType).Select(p => p.PropertyName);
foreach (var candidateImplType in knownImplTypes)
{
var jsonContract = serializer.ContractResolver.ResolveContract(candidateImplType) as JsonObjectContract;
candidateJsonPropertiesUnion = candidateJsonPropertiesUnion.Union(jsonContract.Properties.Select(p => p.PropertyName));
}
var relevantJsonKeysInJson = jsonKeysInJsonString.Intersect(candidateJsonPropertiesUnion);
foreach (var candidateImplType in knownImplTypes)
{
var jsonContract = serializer.ContractResolver.ResolveContract(candidateImplType) as JsonObjectContract;
var jsonPropsInType = jsonContract.Properties;
var jsonPropNamesInType = jsonPropsInType.Select(p => p.PropertyName);
var missingProperties = relevantJsonKeysInJson.Except(jsonPropNamesInType);
if (missingProperties.FirstOrDefault() == null)
{
return(candidateImplType);
}
}
throw new FabricSerializationException(
string.Format("KnownTypeJsonConverter(): None of the known types: {0} has all the properties contained in given json string. Properties in json string: {1}.",
string.Join(",", knownImplTypes.Select(t => t.Name)), // comma separated names of known types.
string.Join(",", jsonKeysInJsonString))); // comma separated keys in json object
}
private void ApplyModelConfiguration(
Type type,
JsonPropertyCollection properties,
ModelConfiguration modelConfiguration,
ModelMetadata metadata,
Dictionary <JsonProperty, MemberInfo> propertyMembers)
{
foreach (var property in properties)
{
var memberConfiguration = modelConfiguration.GetMember(property.UnderlyingName);
if (memberConfiguration != null)
{
ConfigureProperty(property, memberConfiguration);
}
var isMappedProperty = metadata?.AllProperties.Contains(property.UnderlyingName);
var syntheticConfiguration = modelConfiguration.GetSyntheticMember(property.UnderlyingName);
if (syntheticConfiguration == null &&
isMappedProperty == false &&
memberConfiguration?.Serialize != true &&
memberConfiguration?.Deserialize != true)
{
// Do not serialize a non mapped entity property by default (we do not want to expose data that the client will not use)
property.Ignored = memberConfiguration?.Ignored ?? true;
}
if (syntheticConfiguration?.SerializeFunction != null ||
memberConfiguration?.SerializeFunction != null ||
propertyMembers.TryGetValue(property, out var member) && member.IsProperty() && !member.IsAutoProperty(true))
{
// Throw when a non auto or synthetic property lazy loads an uninitialized association (e.g. CustomerId => Organization.Customer.Id)
property.ValueProvider = CreateLazyLoadGuard(property.ValueProvider, type, property.UnderlyingName);
}
if (isMappedProperty == true)
{
property.Writable = memberConfiguration?.Deserialize ?? true; // Non public mapped property setter shall be writable by default
}
}
}
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
List<MemberInfo> members = this.GetSerializableMembers(type);
if (members == null)
{
throw new JsonSerializationException("Null collection of seralizable members returned.");
}
JsonPropertyCollection properties = new JsonPropertyCollection(type);
foreach (MemberInfo member in members)
{
JsonProperty property = this.CreateProperty(member, memberSerialization);
if (property != null)
{
properties.AddProperty(property);
}
}
// IList<JsonProperty> orderedProperties = properties.OrderBy(p => p.Order ?? -1).ToList();
return properties;
}
protected override IList <JsonProperty> CreateConstructorParameters(
ConstructorInfo constructor,
JsonPropertyCollection memberProperties)
{
var constructorParameters = constructor.GetParameters();
var result = new JsonPropertyCollection(constructor.DeclaringType);
foreach (var parameterInfo in constructorParameters)
{
var matchingMemberProperty = (parameterInfo.Name != null) ? memberProperties.GetClosestMatchProperty(parameterInfo.Name) : null;
// Constructor type must be assignable from property type.
// Note that this is the only difference between this method and the method it overrides in DefaultContractResolver.
// In DefaultContractResolver, the types must match exactly.
if (matchingMemberProperty != null)
{
var memberType = matchingMemberProperty.PropertyType;
var memberTypeIsGeneric = memberType.IsGenericType;
var memberGenericArguments = memberType.GenericTypeArguments;
var parameterTypeIsArray = parameterInfo.ParameterType.IsArray;
var parameterElementType = parameterInfo.ParameterType.GetElementType();
if (parameterTypeIsArray &&
memberTypeIsGeneric &&
memberGenericArguments.Length == 1 &&
memberType.IsAssignableTo(typeof(IEnumerable <>).MakeGenericType(parameterElementType)))
{
// NO-OP
// this allows for the constructor parameter to be a "params" array while still using a collection property as the source.
}
else if (memberType.IsAssignableTo(parameterInfo.ParameterType))
{
// NO-OP
// The property type and the constructor parameter type are equal.
// OR
// The property type is assignable to the constructor parameter type.
// In this case, the constructor is taking a less derived type and converting it
// to a more derived type before assigning to the property
// (e.g. constructor takes IEnumerable<string>, but property is an IReadOnlyCollection<string>
// because the constructor calls .ToList() before assigning to the property).
}
else if (parameterInfo.ParameterType.IsAssignableTo(memberType))
{
// NO-OP
// The constructor parameter type is assignable to the property type.
// In this case, the constructor is taking a more derived type and assigning
// it to the property that is less derived.
// (e.g. constructor takes IReadOnlyCollection<string> and assigns it to a property
// of type IEnumerable<string>).
}
else
{
// no way to do this so null out and the let the next step error with a clean message.
matchingMemberProperty = null;
}
}
if (matchingMemberProperty != null || parameterInfo.Name != null)
{
var property = this.CreatePropertyFromConstructorParameterWithConstructorInfo(matchingMemberProperty, parameterInfo, constructor);
if (property != null)
{
result.AddProperty(property);
}
}
}
return(result);
}
/// <summary>
/// Creates properties for the given <see cref="JsonObjectContract"/>.
/// </summary>
/// <param name="contract">The contract to create properties for.</param>
/// <returns>Properties for the given <see cref="JsonObjectContract"/>.</returns>
protected virtual IList<JsonProperty> CreateProperties(JsonObjectContract contract)
{
List<MemberInfo> members = GetSerializableMembers(contract.UnderlyingType);
if (members == null)
throw new JsonSerializationException("Null collection of seralizable members returned.");
JsonPropertyCollection properties = new JsonPropertyCollection(contract);
foreach (MemberInfo member in members)
{
JsonProperty property = CreateProperty(contract, member);
if (property != null)
properties.AddProperty(property);
}
return properties;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonObjectContract"/> class.
/// </summary>
/// <param name="underlyingType">The underlying type for the contract.</param>
public JsonObjectContract(Type underlyingType)
: base(underlyingType)
{
Properties = new JsonPropertyCollection();
CreatedType = underlyingType;
}
protected override IList<JsonProperty> CreateProperties (Type type, MemberSerialization serialization)
{
var properties = new JsonPropertyCollection(type);
foreach (JsonProperty property in GetSerializableMembers(type).Select(m => CreateProperty(m, serialization)).WhereNotNull())
properties.AddProperty(property);
return properties
.OrderBy(p => p.Order ?? -1)
.ThenBy(IsPropertyCollection)
.ThenBy(GetPropertyTypeDepth)
.ThenBy(p => p.PropertyName)
.ToList();
}
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var objectType = type.GetBaseObjectType() ?? type;
if (!_propertyies.ContainsKey(objectType))
{
var props = base.CreateProperties(objectType, memberSerialization);
if (!objectType.IsBaseObject())
{
_propertyies.Add(objectType, props);
return _propertyies[objectType];
}
if (_config.TypeEntity == objectType)
{
var resProps = new List<JsonProperty>();
foreach (var prop in props)
{
if (prop.PropertyType.IsBaseObject() || prop.PropertyType.IsBaseCollection())
{
if (_editors.All(x => x.PropertyName != prop.PropertyName)) continue;
}
resProps.Add(prop);
}
_propertyies.Add(objectType, resProps);
}
else
{
var config = _uiFasade.GetViewModelConfig(objectType);
if (config == null) return props;
if (objectType.IsDefined(typeof(ComplexTypeAttribute), false)) return props;
var editor = _editors.FirstOrDefault(x => x.EditorType == objectType);
if (editor == null) return props;
if (editor.EditorTemplate == "EasyCollection")
{
var typeEasyCollection = editor.ViewModelConfig.TypeEntity;
if (!_propertyies.ContainsKey(typeEasyCollection))
{
var properties = new JsonPropertyCollection(typeEasyCollection);
properties.AddProperty(CreateProperty(typeEasyCollection.GetProperty("ID"),
memberSerialization));
if (editor.ViewModelConfig.LookupProperty != "ID")
properties.AddProperty(CreateProperty(
typeEasyCollection.GetProperty(editor.ViewModelConfig.LookupProperty), memberSerialization));
_propertyies.Add(typeEasyCollection, properties);
}
}
if (editor.Relationship == Relationship.OneToMany) return props;
var sysColumns = _uiFasade.GetEditors(objectType)
.Where(
c =>
c.IsSystemPropery &&
(c.PropertyName != "RowVersion" && c.PropertyName != "Hidden" &&
c.PropertyName != "SortOrder")).ToList();
props =
props.Where(
p =>
p.PropertyName == config.LookupProperty ||
sysColumns.Any(x => x.PropertyName == p.PropertyName && x.IsSystemPropery)).ToList();
_propertyies.Add(objectType, props);
}
}
return _propertyies[objectType];
}
protected override IList <JsonProperty> CreateConstructorParameters(System.Reflection.ConstructorInfo constructor, JsonPropertyCollection memberProperties)
{
var parameters = base.CreateConstructorParameters(constructor, memberProperties);
foreach (var jsonProperty in parameters)
{
//set obfuscated name
jsonProperty.PropertyName = GetObfuscatedName(parameters.IndexOf(jsonProperty));
}
return(parameters);
}
private static Expression <ObjectConstructor <object> > CreateFactory(Type type, JsonPropertyCollection properties, List <Func <ModelObjectSerializationContext, object> > injectors, ParameterExpression context)
{
var arrayArg = Expression.Parameter(typeof(object[]));
var constructor = type.GetConstructor(properties.Select(p => p.PropertyType).ToArray());
var arguments = properties.Select(CreateArgumentExpression);
return(Expression.Lambda <ObjectConstructor <object> >(
Expression.New(constructor, arguments),
arrayArg));
UnaryExpression CreateArgumentExpression(JsonProperty property, int i) =>
Expression.Convert(
injectors[i] != null ?
(Expression)Expression.Invoke(Expression.Constant(injectors[i]), context) :
Expression.ArrayIndex(arrayArg, Expression.Constant(i)),
property.PropertyType);
}
protected virtual IList<JsonProperty> CreateConstructorParameters(ConstructorInfo constructor, JsonPropertyCollection memberProperties)
{
ParameterInfo[] parameters = constructor.GetParameters();
JsonPropertyCollection propertyCollection = new JsonPropertyCollection(constructor.DeclaringType);
foreach (ParameterInfo parameterInfo in parameters)
{
JsonProperty matchingMemberProperty = parameterInfo.Name != null ? memberProperties.GetClosestMatchProperty(parameterInfo.Name) : (JsonProperty) null;
if (matchingMemberProperty != null && matchingMemberProperty.PropertyType != parameterInfo.ParameterType)
matchingMemberProperty = (JsonProperty) null;
JsonProperty constructorParameter = this.CreatePropertyFromConstructorParameter(matchingMemberProperty, parameterInfo);
if (constructorParameter != null)
propertyCollection.AddProperty(constructorParameter);
}
return (IList<JsonProperty>) propertyCollection;
}
internal static bool ResolveEntityProperties(IList <JsonProperty> jsonProperties,
Type entityType, EntityTypeInfo entityTypeInfo,
EntityService entityService, DefaultContractResolver resolver,
Func <PropertyInfo, JsonProperty> createPropertyFunc)
{
if (entityService.ContainsEntityType(entityType))
{
if (jsonProperties.Any(jp => jp.PropertyName == Defaults.MetadataPropertyName &&
jp.UnderlyingName == Defaults.DummyMetadataPropertyInfo.Name))
{
return(false); //if we ever find the metadata property there, assume it has been resolved.
}
var _properties = new JsonPropertyCollection(entityType);
var isComplex = entityType.IsComplex();
var propertiesToIgnore = entityTypeInfo.PropertiesToIgnore.ToArray();
foreach (var jsonProp in jsonProperties)
{
if (isComplex)
{
jsonProp.NullValueHandling = NullValueHandling.Include; //we need null values for complex types
jsonProp.DefaultValueHandling =
DefaultValueHandling.Include; //we need all properties serialized
}
if (!jsonProp.Ignored &&
propertiesToIgnore.Any(np => np.Name == jsonProp.UnderlyingName))
{
jsonProp.Ignored = true;
}
_properties.Add(jsonProp);
}
lock (entityTypeInfo)
{
//check for complextypes
var complexTypedProperties = entityTypeInfo.ComplexTypedProperties;
var complexJsonProperties = new List <JsonProperty>();
if (complexTypedProperties?.Count > 0)
{
//filter to complexproperties
var filteredJsonProperties = _properties?
.Select(p => new
{
JsonProperty = p,
PropertyInfo = complexTypedProperties.Where(pi => pi.Name == p.UnderlyingName)
.FirstOrDefault()
})
.Where(np => np.PropertyInfo != null)
.ToDictionary(np => np.JsonProperty, np => np.PropertyInfo);
Func <Type, IList <JsonProperty> > getResolvedPropertiesFunc = t =>
{
var contract = resolver.ResolveContract(t) as JsonObjectContract;
if (contract.Properties?.Count > 0)
{
ResolveEntityProperties
(contract.Properties, t, entityService.GetEntityTypeInfo(t),
entityService, resolver, createPropertyFunc);
}
return(contract.Properties);
};
//generate new properties with new names for the complex types
foreach (var complexTypedJsonProp in filteredJsonProperties)
{
//get the complexTypedProperty's own jsonproperties
//include derived classes
var derivedTypes = entityService
.GetDerivedEntityTypes(complexTypedJsonProp.Key.PropertyType)?
.Where(t => t.IsComplex()).ToList();
if (derivedTypes == null || derivedTypes.Count == 0)
{
entityService.AddEntityType(complexTypedJsonProp.Key.PropertyType);
derivedTypes = new List <Type> {
complexTypedJsonProp.Key.PropertyType
};
}
var childProperties = derivedTypes
.SelectMany(dt =>
getResolvedPropertiesFunc(dt)?.Where
(p => /*!p.Ignored &&*/ p.PropertyName != Defaults.MetadataPropertyName) ??
new JsonProperty[0],
(dt, property) => new
{
DerivedType = dt,
Property = property
})
.Where(jp => jp.Property != null)
.GroupBy(jp => jp.Property.PropertyName)
.Select(jpg => jpg.FirstOrDefault())
.ToList();
foreach (var childProp in childProperties)
{
//add the child to this type's properties
try
{
var newChildProp = GetComplexTypedPropertyChild
(childProp.DerivedType, complexTypedJsonProp.Key,
complexTypedJsonProp.Value, childProp.Property);
_properties.AddProperty(newChildProp);
complexJsonProperties.Add(newChildProp);
}
catch (JsonSerializationException e)
{
//for some reason member already exists and is duplicate
}
}
//ignore all complex typed properties
complexTypedJsonProp.Key.Ignored = true;
}
}
var nextIdx = -1;
//clear and re-add these properties
jsonProperties.Clear();
var orderedProperties = _properties.OrderBy(p => p.Order ?? nextIdx++);
foreach (var prop in orderedProperties)
{
jsonProperties.Add(prop);
}
//create metadata property and add it last
var metadataJsonProperty = createPropertyFunc(Defaults.DummyMetadataPropertyInfo);
metadataJsonProperty.PropertyName = Defaults.MetadataPropertyName;
metadataJsonProperty.ValueProvider = new MetadataValueProvider(entityType, complexJsonProperties);
metadataJsonProperty.ShouldSerialize = instance =>
{
return(!(metadataJsonProperty.ValueProvider as MetadataValueProvider)
.BuildMetadata(instance).IsEmpty());
};
metadataJsonProperty.Order = int.MaxValue; //try to make it the last serialized
jsonProperties.Add(metadataJsonProperty);
//assign and resolve these properties
entityTypeInfo.JsonProperties = new List <JsonProperty>(jsonProperties);
return(true);
}
}
return(false);
}
protected virtual IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
List<MemberInfo> serializableMembers = this.GetSerializableMembers(type);
if (serializableMembers == null)
throw new JsonSerializationException("Null collection of seralizable members returned.");
JsonPropertyCollection propertyCollection = new JsonPropertyCollection(type);
foreach (MemberInfo member in serializableMembers)
{
JsonProperty property = this.CreateProperty(member, memberSerialization);
if (property != null)
propertyCollection.AddProperty(property);
}
return (IList<JsonProperty>) Enumerable.ToList<JsonProperty>((IEnumerable<JsonProperty>) Enumerable.OrderBy<JsonProperty, int>((IEnumerable<JsonProperty>) propertyCollection, (Func<JsonProperty, int>) (p => p.Order ?? -1)));
}
protected override IList <JsonProperty> CreateConstructorParameters(ConstructorInfo constructor, JsonPropertyCollection memberProperties)
{
var constructorParameters = constructor.GetParameters();
JsonPropertyCollection parameterCollection = new JsonPropertyCollection(constructor.DeclaringType);
foreach (ParameterInfo parameterInfo in constructorParameters)
{
JsonProperty matchingMemberProperty = (parameterInfo.Name != null) ? memberProperties.GetClosestMatchProperty(parameterInfo.Name) : null;
// Constructor type must be assignable from property type.
// Note that this is the only difference between this method and the method it overrides in DefaultContractResolver.
// In DefaultContractResolver, the types must match exactly.
if (matchingMemberProperty != null && !parameterInfo.ParameterType.IsAssignableFrom(matchingMemberProperty.PropertyType))
{
matchingMemberProperty = null;
}
if (matchingMemberProperty != null || parameterInfo.Name != null)
{
JsonProperty property = CreatePropertyFromConstructorParameterWithConstructorInfo(matchingMemberProperty, parameterInfo, constructor);
if (property != null)
{
parameterCollection.AddProperty(property);
}
}
}
return(parameterCollection);
}
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var serializableMembers = GetSerializableMembers(type).Cast <PropertyInfo>();
if (serializableMembers == null)
{
throw new JsonSerializationException("Null collection of seralizable members returned.");
}
var typeDefinition = _ServerConfiguration.GetScimTypeDefinition(type);
var propertyCollection = new JsonPropertyCollection(type);
foreach (var member in serializableMembers)
{
var property = CreateProperty(member, memberSerialization);
if (property != null)
{
var state = _InstanceState;
var propertyNameTable = state.NameTable;
bool lockTaken = false;
try
{
Monitor.Enter(propertyNameTable, ref lockTaken);
property.PropertyName = state.NameTable.Add(property.PropertyName);
IScimTypeAttributeDefinition attributeDefinition;
if (typeDefinition != null && typeDefinition.AttributeDefinitions.TryGetValue(member, out attributeDefinition))
{
// Internal json.net deserialization logic will hit the ShouldDeserialize delegate before checking property.Writable
// Still, we'll set Writable to accurately reflect this
property.Writable = attributeDefinition.Mutability != Mutability.ReadOnly; // deserializable?
// setting property.Readable will shortcut the ShouldSerialize delegate
// INTERNAL JSON.NET LOGIC
// if (!property.Ignored && property.Readable && ShouldSerialize(writer, property, value) && IsSpecified(writer, property, value))
property.Readable = attributeDefinition.Mutability != Mutability.WriteOnly; // serializable?
// Only attach a conditional deserialization delegate if the attribute is not ReadWrite.
if (attributeDefinition.Mutability != Mutability.ReadWrite)
{
property.ShouldDeserialize = o =>
{
if (attributeDefinition.Mutability == Mutability.ReadOnly)
{
return(false);
}
return(true);
};
}
// Only attach a conditional serialization delegate if the attribute is not Always returned.
if (attributeDefinition.Returned != Returned.Always)
{
var existingShouldSerializeFunc = property.ShouldSerialize;
property.ShouldSerialize = o =>
{
if (attributeDefinition.Mutability == Mutability.WriteOnly || attributeDefinition.Returned == Returned.Never)
{
return(false);
}
var httpMethod = AmbientRequestService.HttpMethod;
if (attributeDefinition.Returned == Returned.Default ||
(attributeDefinition.Returned == Returned.Request && (httpMethod == HttpMethod.Post || httpMethod == _Patch || httpMethod == HttpMethod.Put)))
{
var queryOptions = AmbientRequestService.QueryOptions;
if (queryOptions.Attributes.Any() && !queryOptions.Attributes.Contains(property.PropertyName))
{
return(false);
}
if (queryOptions.ExcludedAttributes.Any() && queryOptions.ExcludedAttributes.Contains(property.PropertyName))
{
return(false);
}
}
if (existingShouldSerializeFunc != null)
{
return(existingShouldSerializeFunc(o));
}
return(true);
};
}
}
}
finally
{
if (lockTaken)
{
Monitor.Exit(propertyNameTable);
}
}
propertyCollection.AddProperty(property);
}
}
return(propertyCollection.OrderBy(p => p.Order ?? -1).ToList());
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonObjectContract"/> class.
/// </summary>
/// <param name="underlyingType">The underlying type for the contract.</param>
public JsonObjectContract(Type underlyingType)
: base(underlyingType)
{
Properties = new JsonPropertyCollection(UnderlyingType);
}
protected override IList <JsonProperty> CreateConstructorParameters(ConstructorInfo constructor, JsonPropertyCollection memberProperties)
{
var rslt = base.CreateConstructorParameters(constructor, memberProperties);
return(rslt);
}
internal static void ExtendProperties(this IDictionary <string, Schema> schemaProperties, JsonPropertyCollection jsonProperties)
{
if (schemaProperties is null)
{
return;
}
foreach (var schemaProperty in schemaProperties)
{
var jsonProperty = jsonProperties.FirstOrDefault(x => x.PropertyName == schemaProperty.Key);
schemaProperty.Value.ExtendProperty(jsonProperty);
}
}
protected override IList <JsonProperty> CreateConstructorParameters(ConstructorInfo constructor, JsonPropertyCollection memberProperties)
{
var properties = base.CreateConstructorParameters(constructor, memberProperties);
foreach (var property in properties.Where(p => p.PropertyType == typeof(string)))
{
property.DefaultValue = ConstructorParametersRespectDefaultValue.DefaultValue;
property.DefaultValueHandling = DefaultValueHandling.Populate;
}
return(properties);
}
protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var serializableMembers = GetSerializableMembers(type).Cast<PropertyInfo>();
if (serializableMembers == null)
throw new JsonSerializationException("Null collection of seralizable members returned.");
var typeDefinition = _ServerConfiguration.GetScimTypeDefinition(type);
var propertyCollection = new JsonPropertyCollection(type);
foreach (var member in serializableMembers)
{
var property = CreateProperty(member, memberSerialization);
if (property != null)
{
var state = _InstanceState;
var propertyNameTable = state.NameTable;
bool lockTaken = false;
try
{
Monitor.Enter(propertyNameTable, ref lockTaken);
property.PropertyName = state.NameTable.Add(property.PropertyName);
IScimTypeAttributeDefinition attributeDefinition;
if (typeDefinition != null && typeDefinition.AttributeDefinitions.TryGetValue(member, out attributeDefinition))
{
// Internal json.net deserialization logic will hit the ShouldDeserialize delegate before checking property.Writable
// Still, we'll set Writable to accurately reflect this
property.Writable = attributeDefinition.Mutability != Mutability.ReadOnly; // deserializable?
// setting property.Readable will shortcut the ShouldSerialize delegate
// INTERNAL JSON.NET LOGIC
// if (!property.Ignored && property.Readable && ShouldSerialize(writer, property, value) && IsSpecified(writer, property, value))
property.Readable = attributeDefinition.Mutability != Mutability.WriteOnly; // serializable?
// Only attach a conditional deserialization delegate if the attribute is not ReadWrite.
if (attributeDefinition.Mutability != Mutability.ReadWrite)
{
property.ShouldDeserialize = o =>
{
if (attributeDefinition.Mutability == Mutability.ReadOnly)
return false;
return true;
};
}
// Only attach a conditional serialization delegate if the attribute is not Always returned.
if (attributeDefinition.Returned != Returned.Always)
{
var existingShouldSerializeFunc = property.ShouldSerialize;
property.ShouldSerialize = o =>
{
if (attributeDefinition.Mutability == Mutability.WriteOnly || attributeDefinition.Returned == Returned.Never)
return false;
var httpMethod = AmbientRequestService.HttpMethod;
if (attributeDefinition.Returned == Returned.Default ||
(attributeDefinition.Returned == Returned.Request && (httpMethod == HttpMethod.Post || httpMethod == _Patch || httpMethod == HttpMethod.Put)))
{
var queryOptions = AmbientRequestService.QueryOptions;
if (queryOptions.Attributes.Any() && !queryOptions.Attributes.Contains(property.PropertyName))
return false;
if (queryOptions.ExcludedAttributes.Any() && queryOptions.ExcludedAttributes.Contains(property.PropertyName))
return false;
}
if (existingShouldSerializeFunc != null)
return existingShouldSerializeFunc(o);
return true;
};
}
}
}
finally
{
if (lockTaken)
Monitor.Exit(propertyNameTable);
}
propertyCollection.AddProperty(property);
}
}
return propertyCollection.OrderBy(p => p.Order ?? -1).ToList();
}
private Expression <Func <ModelObjectSerializationContext, ObjectConstructor <object> > > TryCreateFactoryProvider(Type type, JsonPropertyCollection properties)
{
var injectors = (from p in properties select _modelObjectSpecialValueProvider.TryGetInjector(type, p)).ToList();
if (injectors.Any(i => i != null))
{
var closureContext = Expression.Parameter(typeof(ModelObjectSerializationContext));
return(Expression.Lambda <Func <ModelObjectSerializationContext, ObjectConstructor <object> > >(
CreateFactory(type, properties, injectors, closureContext),
closureContext));
}
return(null);
}
