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; }