protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var members = GetSerializableMembers(type).Where(x => x.GetCustomAttribute <IgnoreAttribute>() == null);
var properties = new JsonPropertyCollection(type);
foreach (var member in members)
{
var property = CreateProperty(member, memberSerialization);
if (EntityType.IsAssignableFrom(property.PropertyType) ||
(property.PropertyType != typeof(string) && EnumerableType.IsAssignableFrom(property.PropertyType)))
{
property.ShouldSerialize = (x) =>
{
if (!NHibernateUtil.IsPropertyInitialized(x, member.Name))
{
return(false);
}
return(NHibernateUtil.IsInitialized(x.GetMemberValue(member.Name)));
};
}
properties.AddProperty(property);
}
return(properties.OrderBy(p => p.Order ?? -1).ToList());
}
/// <summary>
/// CreateProperties
/// </summary>
/// <param name="type"></param>
/// <param name="memberSerialization"></param>
/// <returns></returns>
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
List <MemberInfo> members = GetSerializableMembers(type);
if (members == null)
{
throw new JsonSerializationException("Null collection of seralizable members returned.");
}
var properties = new JsonPropertyCollection(type);
foreach (MemberInfo member in members)
{
JsonProperty property = CreateProperty(member, memberSerialization);
if (property != null)
{
if (!property.Order.HasValue)
{
property.Order = 1000;
}
properties.AddProperty(property);
}
}
//List<JsonProperty> orderedProperties = properties.OrderBy(p => p.Order + (MaxPropertiesPerContract * GetTypeDepth(p.DeclaringType)) ?? -1).ToList();
List <JsonProperty> orderedProperties = properties.OrderBy(p => p.Order).ToList();
return(orderedProperties);
}
/// <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(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);
}
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());
}
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();
}
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 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();
}