/// <summary>
/// Sets all updateable values for the update set.
/// </summary>
/// <param name="entity">
/// Get
/// The entity containing the target values.
/// </param>
/// <param name="definitionProvider">
/// The definition provider for the target repository.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="entity"/> or <paramref name="definitionProvider"/> is null.
/// </exception>
/// <returns>
/// The current <see cref="UpdateSet{T}"/> with all updateable attribute values set.
/// </returns>
public UpdateSet <T> Set([NotNull] T entity, [NotNull] IEntityDefinitionProvider definitionProvider)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (definitionProvider == null)
{
throw new ArgumentNullException(nameof(definitionProvider));
}
this.attributesToSet.Clear();
var entityDefinition = definitionProvider.Resolve <T>();
foreach (var attributeDefinition in entityDefinition.UpdateableAttributes)
{
this.attributesToSet.Add(
new ValueState(
new AttributeLocation(attributeDefinition.PropertyInfo, EntityReference),
attributeDefinition.GetValueDelegate.Method.Invoke(entity, null)));
}
return(this);
}
public static string ToSql(this IConditionalExpression conditionalExpression,
IEntityDefinitionProvider definitionProvider)
{
var sb = new StringBuilder();
conditionalExpression.appendTo(sb, definitionProvider);
return(sb.ToString());
}
/// <summary>
/// Gets the entity definition for the given type, or null if not found.
/// </summary>
/// <param name="cancellationToken">The token used for cancelling this operation.</param>
/// <returns>Returns the entity definition if found, or null otherwise.</returns>
public static Task <EntityDefinition> GetEntityDefinition <Tentity>(this IEntityDefinitionProvider provider, CancellationToken cancellationToken)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
return(provider.GetEntityDefinition(typeof(Tentity), cancellationToken));
}
public IReadOnlyList <IFieldDefinition> Fields(IEntityDefinitionProvider entityDefinitionProvider)
{
if (_fieldDefinitions != null)
{
return(_fieldDefinitions);
}
_fieldDefinitions = EvaluateFields(entityDefinitionProvider).ToList();
return(_fieldDefinitions);
}
/// <summary>
/// Sets the default relations for the entity set using the specified <paramref name="definitionProvider"/>.
/// </summary>
/// <param name="definitionProvider">
/// The definition provider to get the default relations from.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="definitionProvider"/> is null.
/// </exception>
public void SetDefaultRelations([NotNull] IEntityDefinitionProvider definitionProvider)
{
if (definitionProvider == null)
{
throw new ArgumentNullException(nameof(definitionProvider));
}
this.relations.Clear();
this.relations.AddRange(definitionProvider.Resolve <T>().DefaultRelations);
}
/// <summary>
/// Initializes a new instance of the <see cref="DataTableLoader{T}"/> class.
/// </summary>
/// <param name="definitionProvider">
/// The definition provider.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="definitionProvider"/> is null.
/// </exception>
public DataTableLoader([NotNull] IEntityDefinitionProvider definitionProvider)
{
if (definitionProvider == null)
{
throw new ArgumentNullException(nameof(definitionProvider));
}
this.propertyDictionary = new Lazy <Dictionary <string, PropertyInfo> >(
() => definitionProvider.Resolve <T>()
.AllAttributes.OrderBy(definition => definition.Ordinal)
.ToDictionary(definition => definition.PropertyInfo.Name, definition => definition.PropertyInfo));
}
/// <summary>
/// Gets the entity definition for the given type from the provider, or throws if not found.
/// (Can be used for ensuring no null is returned.)
/// </summary>
/// <param name="provider">The provider to get entity definitions from.</param>
/// <param name="entityType">The type of the entity to get definition for.</param>
/// <param name="cancellationToken">The token used for cancelling this operation.</param>
/// <returns>Returns the non-null entity definition if found, or throws an exception.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="provider"/> or <paramref name="entityType"/> is null.</exception>
/// <exception cref="NullReferenceException">Thrown if <paramref name="provider"/> returns null.</exception>
public static async Task <EntityDefinition> GetEntityDefinitionOrThrow(this IEntityDefinitionProvider provider, Type entityType, CancellationToken cancellationToken)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
var entityDefinition = await provider.GetEntityDefinition(entityType, cancellationToken).ConfigureAwait(false);
if (entityDefinition == null)
{
throw new NullReferenceException($"Entity definition provider of type '{provider.GetType().FullName}' could not get entity for type '{entityType.FullName}'.");
}
return(entityDefinition);
}
/// <summary>
/// The mock command provider.
/// </summary>
/// <param name="items">
/// The merge items.
/// </param>
/// <param name="definitionProvider">
/// The definition provider.
/// </param>
/// <param name="nameQualifier">
/// The name qualifier.
/// </param>
/// <typeparam name="T">
/// The type of item in the list to create an <see cref="IDbTableCommandFactory"/> mock for.
/// </typeparam>
/// <returns>
/// The <see cref="Mock"/>.
/// </returns>
public static Mock <IDbTableCommandFactory> MockCommandFactory <T>(
[NotNull] this IReadOnlyCollection <T> items,
[NotNull] IEntityDefinitionProvider definitionProvider,
[NotNull] INameQualifier nameQualifier)
{
if (items == null)
{
throw new ArgumentNullException(nameof(items));
}
if (definitionProvider == null)
{
throw new ArgumentNullException(nameof(definitionProvider));
}
if (nameQualifier == null)
{
throw new ArgumentNullException(nameof(nameQualifier));
}
var structureDefinition = definitionProvider.Resolve <T>();
var orderedAttributes = structureDefinition.ReturnableAttributes.OrderBy(definition => definition.Ordinal).ToList();
var reader = items.MockDataReaderForList(orderedAttributes);
var command = new Mock <IDbCommand>();
command.Setup(dbCommand => dbCommand.ExecuteReader()).Returns(reader.Object);
var commandProvider = new Mock <IDbTableCommandFactory>();
var databaseContext = new Mock <IDatabaseContext>();
var repositoryAdapter = new Mock <IRepositoryAdapter>();
repositoryAdapter.Setup(adapter => adapter.NameQualifier).Returns(nameQualifier);
repositoryAdapter.Setup(adapter => adapter.DefinitionProvider).Returns(definitionProvider);
databaseContext.Setup(context => context.RepositoryAdapter).Returns(repositoryAdapter.Object);
////commandProvider.Setup(provider => provider.DatabaseContext).Returns(databaseContext.Object);
////commandProvider
//// .Setup(provider => provider.Create(It.IsAny<ITableCommand>(), It.IsAny<DataTable>(), It.IsAny<IDbTransaction>()))
//// .Returns(command.Object);
commandProvider
.Setup(provider => provider.Create(It.IsAny <IDatabaseContext>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IEnumerable <T> >()))
.Returns(command.Object);
return(commandProvider);
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityDefinition"/> class.
/// </summary>
/// <param name="definitionProvider">
/// The definition provider.
/// </param>
/// <param name="entityReference">
/// The entity reference.
/// </param>
public EntityDefinition([NotNull] IEntityDefinitionProvider definitionProvider, [NotNull] EntityReference entityReference)
{
if (entityReference == null)
{
throw new ArgumentNullException(nameof(entityReference));
}
this.DefinitionProvider = definitionProvider ?? throw new ArgumentNullException(nameof(definitionProvider));
this.allAttributes = new Lazy <List <EntityAttributeDefinition> >(
() => new List <EntityAttributeDefinition>(this.DefinitionProvider.ResolveDefinitions(entityReference.EntityType)));
// Do not include mapped attributes.
this.returnableAttributes =
new Lazy <List <EntityAttributeDefinition> >(this.allAttributes.Value.Where(x => x.IsMetadata == false).ToList);
// Do not include related attributes.
this.directAttributes = new Lazy <List <EntityAttributeDefinition> >(this.returnableAttributes.Value.Where(x => x.IsDirect).ToList);
this.primaryKeyAttributes = new Lazy <List <EntityAttributeDefinition> >(this.directAttributes.Value.Where(x => x.IsPrimaryKey).ToList);
this.rowIdentity = new Lazy <EntityAttributeDefinition?>(this.GetRowIdentity);
// Do not include identity columns.
this.insertableAttributes = new Lazy <List <EntityAttributeDefinition> >(
this.directAttributes.Value.Where(definition => definition.IsIdentityColumn == false && definition.IsComputed == false).ToList);
// Do not include primary keys.
this.updateableAttributes =
new Lazy <List <EntityAttributeDefinition> >(this.insertableAttributes.Value.Except(this.primaryKeyAttributes.Value).ToList);
this.entityLocation = new Lazy <EntityLocation>(() => definitionProvider.GetEntityLocation(entityReference));
var type = entityReference.EntityType;
this.defaultRelations = new Lazy <List <IEntityRelation> >(
() =>
{
if (typeof(IEntityAggregate).IsAssignableFrom(type) && type.GetConstructor(Array.Empty <Type>()) != null)
{
// We have to make an instance to get the relations.
// TODO: Use T4 template in conjunction with property declarations to build this without instantiation
var entity = Activator.CreateInstance(type);
return(((IEntityAggregate)entity).EntityRelations.ToList());
}
return(new List <IEntityRelation>());
});
}
/// <summary>
/// Initializes a new instance of the <see cref="PostgreSqlAdapter"/> class.
/// </summary>
/// <param name="definitionProvider">
/// The definition provider.
/// </param>
public PostgreSqlAdapter([NotNull] IEntityDefinitionProvider definitionProvider)
: base(definitionProvider, new PostgreSqlQualifier())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RaisedPocoFactory"/> class.
/// </summary>
/// <param name="definitionProvider">
/// The definition provider.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="definitionProvider"/> is not null.
/// </exception>
public RaisedPocoFactory([NotNull] IEntityDefinitionProvider definitionProvider)
{
this.definitionProvider = definitionProvider ?? throw new ArgumentNullException(nameof(definitionProvider));
}
/// <summary>
/// Initializes a new instance of the <see cref="PostgreSqlProviderFactory"/> class.
/// </summary>
/// <param name="definitionProvider">
/// The definition provider.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="definitionProvider"/> is null.
/// </exception>
public PostgreSqlProviderFactory([NotNull] IEntityDefinitionProvider definitionProvider)
{
this.definitionProvider = definitionProvider ?? throw new ArgumentNullException(nameof(definitionProvider));
}
/// <summary>
/// Gets the entity definition for the given type from the provider, or throws if not found.
/// </summary>
/// <param name="provider">The provider to get entity definitions from.</param>
/// <param name="cancellationToken">The token used for cancelling this operation.</param>
/// <returns>Returns the non-null entity definition if found, or throws an exception.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="provider"/> is null.</exception>
/// <exception cref="NullReferenceException">Thrown if <paramref name="provider"/> returns null.</exception>
public static Task <EntityDefinition> GetEntityDefinitionOrThrow <Tentity>(this IEntityDefinitionProvider provider, CancellationToken cancellationToken)
{
return(GetEntityDefinitionOrThrow(provider, typeof(Tentity), cancellationToken));
}
/// <summary>
/// Matches the primary key of the specified <paramref name="entity"/>.
/// </summary>
/// <param name="entity">
/// The entity to match the key for.
/// </param>
/// <param name="definitionProvider">
/// The definition provider for the entity.
/// </param>
/// <param name="explicitKeyAttributes">
/// The explicit key attributes for this match.
/// </param>
/// <returns>
/// The current <see cref="ValueFilterSet{T}"/>.
/// </returns>
/// <remarks>
/// This operation will clear any existing filters.
/// </remarks>
public ValueFilterSet <T> MatchKey(
[NotNull] T entity,
[NotNull] IEntityDefinitionProvider definitionProvider,
[NotNull] params Expression <Func <T, object> >[] explicitKeyAttributes)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (definitionProvider == null)
{
throw new ArgumentNullException(nameof(definitionProvider));
}
if (explicitKeyAttributes == null)
{
throw new ArgumentNullException(nameof(explicitKeyAttributes));
}
this.valueFilters.Clear();
var entityDefinition = definitionProvider.Resolve <T>();
var keyAttributes = explicitKeyAttributes.Any()
? explicitKeyAttributes.Select(entityDefinition.Find)
: entityDefinition.PrimaryKeyAttributes;
foreach (var keyAttribute in keyAttributes)
{
var entityReference = new EntityReference
{
EntityAlias = keyAttribute.Entity.Alias,
EntityType = keyAttribute.Entity.EntityType
};
var attributeLocation = new AttributeLocation(keyAttribute.PropertyInfo, entityReference);
var valueFilter = new ValueFilter(attributeLocation, FilterType.Equality, keyAttribute.GetValueDelegate.DynamicInvoke(entity));
this.valueFilters.Add(valueFilter);
}
// Use all available values if no keys are defined.
if (this.valueFilters.Any())
{
return(this);
}
Trace.TraceWarning($"{typeof(T).FullName} does not have any key attributes defined.");
foreach (var attribute in entityDefinition.DirectAttributes)
{
var entityReference = new EntityReference
{
EntityAlias = attribute.Entity.Alias,
EntityType = attribute.Entity.EntityType
};
var attributeLocation = new AttributeLocation(attribute.PropertyInfo, entityReference);
var valueFilter = new ValueFilter(attributeLocation, FilterType.Equality, attribute.GetValueDelegate.DynamicInvoke(entity));
this.valueFilters.Add(valueFilter);
}
return(this);
}
public void Setup()
{
_conditionalExpression = new ConditionalExpressionParser(ReflectedEntityKey.EntityKey <TestClass>());
_entityDefinitionProvider = new ReflectionEntityDefinitionProvider();
}
public void appendTo(StringBuilder sb, IEntityDefinitionProvider definitionProvider)
{
_entityDefinition = definitionProvider.GetEntityDefinition(_baseEntityKey);
sb.Append(Visit(_expression));
}
/// <summary>
/// Initializes a new instance of the <see cref="JoinClause"/> class.
/// </summary>
/// <param name="definitionProvider">
/// The definition provider.
/// </param>
/// <param name="nameQualifier">
/// The SQL name qualifier.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="definitionProvider"/> or <paramref name="nameQualifier"/> is null.
/// </exception>
public JoinClause([NotNull] IEntityDefinitionProvider definitionProvider, [NotNull] INameQualifier nameQualifier)
{
this.definitionProvider = definitionProvider ?? throw new ArgumentNullException(nameof(definitionProvider));
this.nameQualifier = nameQualifier ?? throw new ArgumentNullException(nameof(nameQualifier));
}
public ReflectionMapper(IEntityDefinitionProvider <ReflectedEntityKey> entityDefinitionProvider)
{
_entityDefinitionProvider = entityDefinitionProvider;
}
protected virtual IEnumerable <IFieldDefinition> EvaluateFields(
IEntityDefinitionProvider entityDefinitionProvider)
{
return(EvaluateFields(entityDefinitionProvider.GetEntityDefinition(EntityKey)));
}
/// <summary>
/// Initializes a new instance of the <see cref="TransactSqlAdapter"/> class.
/// </summary>
/// <param name="definitionProvider">
/// The definition provider for the SQL statements.
/// </param>
public TransactSqlAdapter(IEntityDefinitionProvider definitionProvider)
: base(definitionProvider, new TransactSqlQualifier())
{
}
