private string GetWhereConditionsForDataModel(DbContextAction contextAction, object dataModel)
{
var conditionCount = 0;
var tableName = dataModel.GetThuriaDataModelTableName();
var dataModelConditions = dataModel.GetThuriaDataModelConditions(contextAction);
string whereCondition;
lock (_conditionBuilderLock)
{
_conditionBuilder.Clear();
foreach (var currentCondition in dataModelConditions)
{
var propertyValue = currentCondition.Value;
if (propertyValue == null || propertyValue.Equals(propertyValue.GetType().GetDefaultData()))
{
continue;
}
if (conditionCount > 0)
{
_conditionBuilder = _conditionBuilder.WithAnd();
}
_conditionBuilder = _conditionBuilder.WithCondition(tableName, currentCondition.ColumnName, EqualityOperators.Equals, propertyValue);
conditionCount++;
}
whereCondition = _conditionBuilder.Build();
}
return(whereCondition);
}
public void GetThuriaDataModelConditions_GivenDataModelWithNoConditions_ShouldReturnEmptyConditionList(DbContextAction DbContextAction)
{
//---------------Set up test pack-------------------
var dataModel = new ThuriaPocoDataModel
{
Id = Guid.NewGuid(),
Name = RandomValueGenerator.CreateRandomString(),
Description = RandomValueGenerator.CreateRandomString(),
ModifiedDate = RandomValueGenerator.CreateRandomDate(),
IsActive = true
};
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var allConditions = dataModel.GetThuriaDataModelConditions(DbContextAction);
//---------------Test Result -----------------------
var dataModelConditions = allConditions.ToList();
dataModelConditions.Should().NotBeNull();
dataModelConditions.Count.Should().Be(0);
}
public void GetThuriaDataModelColumns_ShouldReturnTheExpectedColumnAttributes(DbContextAction DbContextAction, string columnName, string propertyName, bool isExpectedInList = true)
{
//---------------Set up test pack-------------------
var dataModel = new ThuriaTestDataModel();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var dataModelColumns = dataModel.GetThuriaDataModelColumns(DbContextAction);
//---------------Test Result -----------------------
var columnAttributes = dataModelColumns.ToList();
columnAttributes.Should().NotBeNull();
if (isExpectedInList)
{
columnAttributes.Should().Contain(attribute => attribute.ColumnName == columnName);
columnAttributes.Should().Contain(attribute => attribute.PropertyName == propertyName);
}
else
{
columnAttributes.Should().NotContain(attribute => attribute.ColumnName == columnName);
columnAttributes.Should().NotContain(attribute => attribute.PropertyName == propertyName);
}
}
/// <inheritdoc />
public override async Task <IDbContextActionResult <T> > ExecuteActionAsync <T>(DbContextAction dbContextAction,
T dataModel = default(T),
string sqlCommandText = null,
IEnumerable <IDataAccessParameter> dataParameters = null)
{
var actionResult = new DbContextActionResult <T>();
var mapData = true;
var wasConnectionOpen = DbConnection?.State == ConnectionState.Open;
try
{
var dbCommand = DbConnection.CreateCommand();
dbCommand.CommandTimeout = CommandTimeout;
dbCommand.CommandType = CommandType.Text;
switch (dbContextAction)
{
case DbContextAction.Retrieve:
dbCommand.CommandText = _sqlStatementBuildProvider.BuildSelectStatement(dataModel);
break;
case DbContextAction.Create:
dbCommand.CommandText = _sqlStatementBuildProvider.BuildInsertStatement(dataModel);
mapData = false;
break;
case DbContextAction.StoredProcedure:
dbCommand.CommandType = CommandType.StoredProcedure;
break;
default:
throw new InvalidEnumArgumentException(nameof(dbContextAction), (int)dbContextAction, typeof(DbContextActionResult));
}
await OpenAsync();
var resultData = new List <T>();
if (mapData)
{
var dataReader = dbCommand.ExecuteReader();
while (dataReader.Read())
{
var rowData = Enumerable.Range(0, dataReader.FieldCount)
.ToDictionary(i => dataReader.GetName(i), i => dataReader.GetValue(i));
resultData.Add((T)await _dataModelPopulateProvider.PopulateAsync(typeof(T), rowData, dbContextAction));
}
dataReader.Close();
}
else
{
dbCommand.ExecuteNonQuery();
}
if (!wasConnectionOpen)
{
await CloseAsync();
}
actionResult.SetSuccessResult(resultData);
}
catch (Exception runtimeException)
{
actionResult.SetExceptionResult(runtimeException);
}
return(actionResult);
}
/// <summary>
/// Retrieve the Given Data Models Columns based on the Action to be performed
/// </summary>
/// <param name="dataModel">Data Model</param>
/// <param name="contextAction">Context Action</param>
/// <returns>A list of Column Attributes for the specified Thark Action</returns>
public static IEnumerable <ThuriaColumnAttribute> GetThuriaDataModelColumns(this object dataModel, DbContextAction contextAction)
{
var dataModelType = dataModel.GetType();
var allProperties = dataModelType.GetProperties();
return((from currentProperty in allProperties
let thuriaIgnoreAttribute = currentProperty.GetCustomAttribute <ThuriaIgnoreAttribute>()
where thuriaIgnoreAttribute == null
let thuriaRelationshipAttribute = currentProperty.GetCustomAttribute <ThuriaRelationshipAttribute>()
where thuriaRelationshipAttribute == null
let thuriaColumnAttribute = currentProperty.GetCustomAttribute <ThuriaColumnAttribute>()
select thuriaColumnAttribute?.SetPropertyName(currentProperty.Name) ?? new ThuriaColumnAttribute(currentProperty.Name).SetPropertyName(currentProperty.Name))
.Where(thuriaColumnAttribute =>
{
switch (contextAction)
{
case DbContextAction.Create:
return thuriaColumnAttribute.IsInsertColumn;
case DbContextAction.Update:
return thuriaColumnAttribute.IsUpdateColumn;
default:
return true;
}
}));
}
/// <summary>
/// Retrieve the Conditions for a given Data Model for a specific Thark Action
/// </summary>
/// <param name="dataModel">Data Model</param>
/// <param name="contextAction">Context Action</param>
/// <returns></returns>
public static IEnumerable <ThuriaDataModelConditionMetadata> GetThuriaDataModelConditions(this object dataModel, DbContextAction contextAction)
{
var allConditions = new List <ThuriaDataModelConditionMetadata>();
var dataModelType = dataModel.GetType();
var allProperties = dataModelType.GetProperties();
foreach (var currentProperty in allProperties)
{
if (currentProperty.GetCustomAttribute <ThuriaIgnoreAttribute>() != null)
{
continue;
}
var propertyValue = currentProperty.GetValue(dataModel);
var conditionColumnAttribute = currentProperty.GetCustomAttributes <ThuriaConditionColumnAttribute>()
.FirstOrDefault(attribute => attribute.ContextAction == contextAction);
if (propertyValue == null)
{
continue;
}
if (contextAction != DbContextAction.Retrieve && contextAction != DbContextAction.Delete && conditionColumnAttribute == null)
{
continue;
}
var isRequired = conditionColumnAttribute == null ? false : conditionColumnAttribute.IsRequired;
var columnName = dataModel.GetThuriaDataModelColumnName(currentProperty.Name);
var conditionMetadata = new ThuriaDataModelConditionMetadata(columnName.ColumnName, isRequired, propertyValue);
allConditions.Add(conditionMetadata);
}
return(allConditions);
}
/// <inheritdoc />
public abstract Task <IDbContextActionResult <T> > ExecuteActionAsync <T>(DbContextAction dbContextAction,
T dataModel = default(T),
string sqlCommandText = null,
IEnumerable <IDataAccessParameter> dataParameters = null)
where T : class;
public async Task ExecuteActionAsync_GivenContextAction_ShouldSetCommandTextAsExpected(DbContextAction contextAction, CommandType expectedCommandType)
{
//---------------Set up test pack-------------------
var dbConnection = Substitute.For <IDbConnection>();
var dbCommand = Substitute.For <IDbCommand>();
dbConnection.CreateCommand().Returns(dbCommand);
var databaseConnectionProvider = Substitute.For <IDatabaseConnectionProvider>();
databaseConnectionProvider.GetConnection(Arg.Any <string>()).Returns(dbConnection);
var dbContext = CreateDatabaseContext(databaseConnectionProvider: databaseConnectionProvider);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
await dbContext.ExecuteActionAsync(contextAction, new FakeTestDataModel());
//---------------Test Result -----------------------
dbCommand.Received(1).CommandType = expectedCommandType;
}
private Task <object> PopulateDataModelAsync(object dataModel, IDictionary <string, object> sourceData, DbContextAction contextAction)
{
var taskCompletionSource = new TaskCompletionSource <object>();
try
{
var allProperties = dataModel.GetType().GetProperties();
var dataModelColumns = dataModel.GetThuriaDataModelColumns(contextAction);
Parallel.ForEach(dataModelColumns, column =>
{
var propertyInfo = allProperties.FirstOrDefault(info => info.Name == column.PropertyName);
if (!sourceData.ContainsKey(column.ColumnName) || propertyInfo == null)
{
return;
}
lock (_populateLock)
{
dataModel.SetPropertyValue(column.Alias ?? column.PropertyName, sourceData[column.ColumnName], true);
}
});
taskCompletionSource.SetResult(dataModel);
}
catch (Exception runtimeException)
{
taskCompletionSource.SetException(runtimeException);
}
return(taskCompletionSource.Task);
}
/// <inheritdoc />
public async Task <T> PopulateAsync <T>(IDictionary <string, object> sourceData, DbContextAction contextAction) where T : class
{
var dataModel = Activator.CreateInstance <T>();
return(sourceData.Any()
? (T) await PopulateDataModelAsync(dataModel, sourceData, contextAction)
: dataModel);
}
/// <inheritdoc />
public async Task <object> PopulateAsync(Type dataModelType, IDictionary <string, object> sourceData, DbContextAction contextAction)
{
var dataModel = Activator.CreateInstance(dataModelType);
return(sourceData.Any()
? await PopulateDataModelAsync(dataModel, sourceData, contextAction)
: dataModel);
}
/// <summary>
/// Thuria Condition Column Attribute constructor
/// </summary>
/// <param name="contextAction">Context Action</param>
/// <param name="isRequired">Required indicator (Default True)</param>
public ThuriaConditionColumnAttribute(DbContextAction contextAction, bool isRequired = true)
{
ContextAction = contextAction;
IsRequired = isRequired;
}
