internal static bool IsAssociation(MemberInfo member, IEntityMetadataProvider classMetadataProvider, out bool isScalar, out Type memberType)
{
memberType = member.GetUnderlyingType();
if (memberType == typeof(string))
{
isScalar = false;
return(false);
}
if (memberType.TryGetGenericType(typeof(IEnumerable <>), out var genericType))
{
isScalar = false;
memberType = genericType.GetGenericArguments()[0];
}
else if (typeof(IEnumerable).IsAssignableFrom(memberType))
{
memberType = null;
isScalar = false;
return(true); // To be safe in case the enumerable is an uninitialized NHibernate collection
}
else
{
isScalar = true;
}
return(classMetadataProvider.IsEntityType(memberType));
}
public void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
foreach (OrderByItem item in _orderByItems)
{
item.Validate(entityType, entityMetadataProvider);
}
}
private BaseBlock ToExpression(Type entityType, DataType returnDataType, IEntityMetadataProvider entityMetadataProvider)
{
String text = _sb.ToString();
if (this._fnArgs == null)
{
if (PropertySignature.IsProperty(entityType, text, entityMetadataProvider))
{
// TODO: we could check that the PropBlock dataType is compatible with the returnDataType
return(new PropBlock(text, entityType, entityMetadataProvider));
}
else
{
return(new LitBlock(text, returnDataType));
}
}
else
{
String fnName = text;
var argTypes = FnBlock.GetArgTypes(fnName);
if (argTypes.Count != _fnArgs.Count)
{
throw new Exception("Incorrect number of arguments to '" + fnName
+ "' function; was expecting " + argTypes.Count);
}
var exprs = _fnArgs.Select((token, ix) => token.ToExpression(entityType, argTypes[ix], entityMetadataProvider)).ToList();
// TODO: we could check that the FnBlock dataType is compatible with the returnDataType
return(new FnBlock(text, exprs));
}
}
// returns an IEnumerable<PropertyInfo> with nulls if invalid and throwOnError = true
public static IEnumerable <PropertyInfo> GetProperties(
Type instanceType,
String propertyPath,
IEntityMetadataProvider entityMetadataProvider,
bool throwOnError = true)
{
return(GetProperties(instanceType, propertyPath, entityMetadataProvider, null, throwOnError));
}
/// <summary>
/// Constructs an instance of <see cref="ClientModelMetadataProvider"/>.
/// </summary>
public ClientModelMetadataProvider(
IEntityMetadataProvider entityMetadataProvider,
ISyntheticPropertyNameConvention syntheticPropertyNameConvention,
IDataTypeProvider dataTypeProvider)
{
_entityMetadataProvider = entityMetadataProvider;
_syntheticPropertyNameConvention = syntheticPropertyNameConvention;
_dataTypeProvider = dataTypeProvider;
}
public FluentValidationPropertyValidatorsProvider(
IValidatorFactory validatorFactory,
IEntityMetadataProvider entityMetadataProvider,
IClientModelMetadataProvider clientModelMetadataProvider)
{
_validatorFactory = validatorFactory;
_entityMetadataProvider = entityMetadataProvider;
_clientModelMetadataProvider = clientModelMetadataProvider;
}
/// <summary>
/// Constructs an instance of <see cref="SaveWorkStateFactory"/>.
/// </summary>
public SaveWorkStateFactory(
IEntityMetadataProvider entityMetadataProvider,
IJsonSerializerSettingsProvider jsonSerializerSettingsProvider,
INHibernateClassMetadataProvider classMetadataProvider)
{
_entityMetadataProvider = entityMetadataProvider;
_classMetadataProvider = classMetadataProvider;
_jsonSerializer = JsonSerializer.Create(jsonSerializerSettingsProvider.GetForSave());
}
/// <summary>
/// Constructs an instance of <see cref="BreezeContractResolver"/>.
/// </summary>
public BreezeContractResolver(
IBreezeConfigurator breezeConfigurator,
IEntityMetadataProvider entityMetadataProvider,
IClientModelMetadataProvider clientModelMetadataProvider,
ILazyLoadGuardProvider lazyLoadGuardProvider)
{
_breezeConfigurator = breezeConfigurator;
_entityMetadataProvider = entityMetadataProvider;
_clientModelMetadataProvider = clientModelMetadataProvider;
_lazyLoadGuardProvider = lazyLoadGuardProvider;
}
public PropBlock(String propertyPath, Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
EntityType = entityType;
PropertyPath = propertyPath;
Property = new PropertySignature(entityType, propertyPath, entityMetadataProvider);
if (Property == null)
{
throw new Exception("Unable to validate propertyPath: " + PropertyPath + " on EntityType: " + entityType.Name);
}
}
/// <summary>
/// Constructs an instance of <see cref="BreezeMetadataBuilder"/>.
/// </summary>
public BreezeMetadataBuilder(
INHibernateClassMetadataProvider classMetadataProvider,
IEntityMetadataProvider entityMetadataProvider,
IBreezeConfigurator breezeConfigurator,
IClientModelMetadataProvider clientModelMetadataProvider,
IPropertyValidatorsProvider propertyValidatorsProvider,
IDataTypeProvider dataTypeProvider)
{
_classMetadataProvider = classMetadataProvider;
_entityMetadataProvider = entityMetadataProvider;
_breezeConfigurator = breezeConfigurator;
_clientModelMetadataProvider = clientModelMetadataProvider;
_propertyValidatorsProvider = propertyValidatorsProvider;
_dataTypeProvider = dataTypeProvider;
}
/**
* Validates that all of the clauses that make up this query are consistent with the
* specified EntityType.
* @param entityType A EntityType
*/
#region Modified code - Added entityMetadataProvider parameter
public void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
_entityType = entityType;
if (_wherePredicate != null)
{
_wherePredicate.Validate(entityType, entityMetadataProvider);
}
if (_orderByClause != null)
{
_orderByClause.Validate(entityType, entityMetadataProvider);
}
if (_selectClause != null)
{
_selectClause.Validate(entityType, entityMetadataProvider);
}
}
public override void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
var block = BaseBlock.CreateLHSBlock(ExprSource, entityType, entityMetadataProvider);
if (!(block is PropBlock))
{
throw new Exception("The first expression of this AnyAllPredicate must be a PropertyExpression");
}
this.NavPropBlock = (PropBlock)block;
var prop = NavPropBlock.Property;
if (prop.IsDataProperty || prop.ElementType == null)
{
throw new Exception("The first expression of this AnyAllPredicate must be a nonscalar Navigation PropertyExpression");
}
this.Predicate.Validate(prop.ElementType, entityMetadataProvider);
}
// will return either a PropBlock or a FnBlock
#region Modified code - Added entityMetadataProvider parameter
public static BaseBlock CreateLHSBlock(Object exprSource,
Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
if (exprSource == null)
{
throw new Exception(
"Null expressions are only permitted on the right hand side of a BinaryPredicate");
}
if (exprSource is IDictionary)
{
throw new Exception(
"Object expressions are only permitted on the right hand side of a BinaryPredicate");
}
if (exprSource is IList)
{
throw new Exception(
"Array expressions are only permitted on the right hand side of a BinaryPredicate");
}
if (!(exprSource is String))
{
throw new Exception(
"Only string expressions are permitted on this predicate");
}
String source = (String)exprSource;
if (source.IndexOf("(") == -1)
{
return(new PropBlock(source, entityType, entityMetadataProvider));
}
else
{
return(FnBlock.CreateFrom(source, entityType, entityMetadataProvider));
}
}
public override void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
if (Expr1Source == null)
{
throw new Exception("Unable to validate 1st expression: " + this.Expr1Source);
}
this._block1 = BaseBlock.CreateLHSBlock(Expr1Source, entityType, entityMetadataProvider);
if (_op == Operator.In && !(Expr2Source is IList))
{
throw new Exception("The 'in' operator requires that its right hand argument be an array");
}
// Special purpose Enum handling
var enumType = GetEnumType(this._block1);
if (enumType != null)
{
if (Expr2Source != null)
{
var et = TypeFns.GetNonNullableType(enumType);
var expr2Enum = Enum.Parse(et, (String)Expr2Source);
this._block2 = BaseBlock.CreateRHSBlock(expr2Enum, entityType, null, entityMetadataProvider);
}
else
{
this._block2 = BaseBlock.CreateRHSBlock(null, entityType, null, entityMetadataProvider);
}
}
else
{
this._block2 = BaseBlock.CreateRHSBlock(Expr2Source, entityType, this._block1.DataType, entityMetadataProvider);
}
}
public static FnBlock CreateFrom(String source, Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
return(FnBlockToken.ToExpression(source, entityType, entityMetadataProvider));
}
public abstract void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider);
public BreezeEntityManager(IEntityMetadataProvider entityMetadataProvider)
{
_entityMetadataProvider = entityMetadataProvider;
}
// will return either a PropBlock or a LitBlock
#region Modified code - Added entityMetadataProvider parameter
public static BaseBlock CreateRHSBlock(Object exprSource,
Type entityType, DataType otherExprDataType, IEntityMetadataProvider entityMetadataProvider)
{
if (exprSource == null)
{
return(new LitBlock(exprSource, otherExprDataType));
}
if (exprSource is String)
{
String source = (String)exprSource;
if (entityType == null)
{
// if entityType is unknown then assume that the rhs is a
// literal
return(new LitBlock(source, otherExprDataType));
}
if (PropertySignature.IsProperty(entityType, source, entityMetadataProvider))
{
return(new PropBlock(source, entityType, entityMetadataProvider));
}
else
{
return(new LitBlock(source, otherExprDataType));
}
}
if (TypeFns.IsPredefinedType(exprSource.GetType()))
{
return(new LitBlock(exprSource, otherExprDataType));
}
if (exprSource is IDictionary <string, Object> )
{
var exprMap = (IDictionary <string, Object>)exprSource;
// note that this is NOT the same a using get and checking for null
// because null is a valid 'value'.
if (!exprMap.ContainsKey("value"))
{
throw new Exception(
"Unable to locate a 'value' property on: "
+ exprMap.ToString());
}
Object value = exprMap["value"];
if (exprMap.ContainsKey("isProperty"))
{
return(new PropBlock((String)value, entityType, entityMetadataProvider));
}
else
{
String dt = (String)exprMap["dataType"];
DataType dataType = (dt != null) ? DataType.FromName(dt) : otherExprDataType;
return(new LitBlock(value, dataType));
}
}
if (exprSource is IList)
{
// right now this pretty much implies the values on an 'in' clause
return(new LitBlock(exprSource, otherExprDataType));
}
if (TypeFns.IsEnumType(exprSource.GetType()))
{
return(new LitBlock(exprSource, otherExprDataType));
}
throw new Exception(
"Unable to parse the right hand side of this BinaryExpression: "
+ exprSource.ToString());
}
/// <summary>
/// Constructs an instance of <see cref="DefaultEntityQueryExecutor"/>.
/// </summary>
public DefaultEntityQueryExecutor(IEntityMetadataProvider entityMetadataProvider, IProxyInitializer proxyInitializer)
{
_entityMetadataProvider = entityMetadataProvider;
_proxyInitializer = proxyInitializer;
}
public void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
Property = new PropertySignature(entityType, PropertyPath, entityMetadataProvider);
}
public void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
_properties = _propertyPaths.Select(pp => new PropertySignature(entityType, pp, entityMetadataProvider)).ToList();
}
public PropertySignature(Type instanceType, String propertyPath, IEntityMetadataProvider entityMetadataProvider)
{
InstanceType = instanceType;
PropertyPath = propertyPath;
Properties = GetProperties(InstanceType, PropertyPath, entityMetadataProvider, _syntheticProperties).ToList();
}
public static FnBlock ToExpression(String source, Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
FnBlockToken token = ParseToken(source, 0);
return((FnBlock)token.ToExpression(entityType, null, entityMetadataProvider));
}
public override void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
Predicate.Validate(entityType, entityMetadataProvider);
}
public static bool IsProperty(Type instanceType, String propertyPath, IEntityMetadataProvider entityMetadataProvider)
{
return(GetProperties(instanceType, propertyPath, entityMetadataProvider, null, false).Any(pi => pi != null));
}
/// <summary>
/// Constructs an instance of <see cref="DefaultLazyLoadGuardProvider"/>.
/// </summary>
public DefaultLazyLoadGuardProvider(IEntityMetadataProvider entityMetadataProvider)
{
_entityMetadataProvider = entityMetadataProvider;
}
private static IEnumerable <PropertyInfo> GetProperties(Type instanceType, String propertyPath, IEntityMetadataProvider entityMetadataProvider,
ICollection <PropertyInfo> syntheticProperties, bool throwOnError = true)
{
var propertyNames = propertyPath.Split('.');
var nextInstanceType = instanceType;
var nextMetadata = entityMetadataProvider.IsEntityType(nextInstanceType) ? entityMetadataProvider.GetMetadata(instanceType) : null;
foreach (var propertyName in propertyNames)
{
PropertyInfo property;
if (nextMetadata != null && nextMetadata.SyntheticForeignKeyProperties.TryGetValue(propertyName, out var syntheticProperty))
{
yield return(GetProperty(nextInstanceType, syntheticProperty.AssociationPropertyName, throwOnError));
property = GetProperty(syntheticProperty.EntityType, syntheticProperty.IdentifierPropertyName, throwOnError);
syntheticProperties?.Add(property);
}
else
{
property = GetProperty(nextInstanceType, propertyName, throwOnError);
}
if (property != null)
{
yield return(property);
nextInstanceType = property.PropertyType;
nextMetadata = entityMetadataProvider.IsEntityType(nextInstanceType) ? entityMetadataProvider.GetMetadata(nextInstanceType) : null;
}
else
{
break;
}
}
}
public override void Validate(Type entityType, IEntityMetadataProvider entityMetadataProvider)
{
_predicates.ForEach(p => p.Validate(entityType, entityMetadataProvider));
}
