public async Task <ActionResult> Update([FromBody] DatabaseEnvironmentBO model) { await _databaseEnvironmentService .UpdateAsync(model); return(NoContent()); }
private DatabaseEnvironmentBO MapEntityToModel(DatabaseEnvironment entity) { DatabaseEnvironmentBO model = new DatabaseEnvironmentBO { CreatedDate = entity.CreatedDate, Database = entity.Database, DataSource = entity.DataSource, ExtraData = entity.ExtraData, Id = entity.Id, MapTables = entity.MapTables, Name = entity.Name, Password = entity.Password, SecurityIntegrated = entity.SecurityIntegrated == null ? false : entity.SecurityIntegrated.Value, User = entity.User, Version = entity.Version, MaxNumberResults = entity.MaxNumberResults, TimeoutInMinutes = entity.TimeoutInMinutes }; if (entity.UserParams != null) { model.UserParams = entity.UserParams.Select(rec => new UserParamBO { DatabaseEnvironmentId = rec.DatabaseEnvironmentId, Id = rec.Id, Name = rec.Name, Value = rec.Value }).ToList(); } return(model); }
private DatabaseEnvironment MapModelToEntity(DatabaseEnvironmentBO model) { DatabaseEnvironment entity = new DatabaseEnvironment { CreatedDate = model.CreatedDate, Database = model.Database, DataSource = model.DataSource, ExtraData = model.ExtraData, Id = model.Id, MapTables = model.MapTables, Name = model.Name, Password = model.Password, SecurityIntegrated = model.SecurityIntegrated == null ? false : model.SecurityIntegrated.Value, User = model.User, Version = model.Version, MaxNumberResults = model.MaxNumberResults, TimeoutInMinutes = model.TimeoutInMinutes }; if (model.UserParams != null) { entity.UserParams = model.UserParams.Select(rec => new Persistence.UserParams.UserParam { DatabaseEnvironmentId = rec.DatabaseEnvironmentId, Id = rec.Id, Name = rec.Name, Value = rec.Value }).ToList(); } return(entity); }
public async Task <DatabaseEnvironmentBO> UpdateAsync(DatabaseEnvironmentBO model) { var map = await this.GetTablesAndColumnsByConnectionString(model.GetConnectionString()); if (map != null) { model.MapTables = JsonConvert.SerializeObject(map, Formatting.Indented); } var environment = await this._databaseEnvironmentQueries.GetAsync(model.Id); environment.Name = model.Name; environment.User = model.User; environment.DataSource = model.DataSource; environment.ExtraData = model.ExtraData; environment.Database = model.Database; environment.SecurityIntegrated = model.SecurityIntegrated; environment.MapTables = model.MapTables; environment.Version = model.Version; environment.TimeoutInMinutes = model.TimeoutInMinutes; if (environment.SecurityIntegrated != null && environment.SecurityIntegrated.Value) { environment.User = string.Empty; environment.Password = string.Empty; } else if (!string.IsNullOrEmpty(model.Password)) { environment.Password = model.Password; } var result = await this._databaseEnvironmentCommands.UpdateAsync(environment); return(MapEntityToModel(result)); }
public async Task <ActionResult> Add([FromBody] DatabaseEnvironmentBO model) { var databaseEnvironment = await _databaseEnvironmentService .AddAsync(model); if (databaseEnvironment != null) { return(CreatedAtAction("Get", new { id = databaseEnvironment.Id }, databaseEnvironment)); } return(BadRequest()); }
public async Task <ActionResult> TestConnectionById([FromBody] DatabaseEnvironmentBO model) { var result = await _databaseEnvironmentService .TestConnectionByIdAsync(model.Id); if (result != null) { return(Ok(result)); } return(BadRequest()); }
public async Task <DatabaseEnvironmentBO> AddAsync(DatabaseEnvironmentBO model) { var map = await this.GetTablesAndColumnsByConnectionString(model.GetConnectionString()); if (map != null) { model.MapTables = JsonConvert.SerializeObject(map, Formatting.Indented); } var result = await this._databaseEnvironmentCommands.AddAsync(MapModelToEntity(model)); return(MapEntityToModel(result)); }
public async Task <RuleTestResult> ExecuteRuleByEnvironmentIdAsync(Guid ruleId, DatabaseEnvironmentBO databaseEnvironment) { int?ruleDetailsDestinationId = null; var rule = await _ruleService.GetAsync(ruleId); var executionLogs = await _ruleExecutionLogQueries.GetByRuleIdAsync(ruleId); var connectionString = databaseEnvironment.GetConnectionString(); var stopWatch = System.Diagnostics.Stopwatch.StartNew(); RuleTestResult testResult = await ExecuteRuleAsync(rule, connectionString, databaseEnvironment.UserParams, databaseEnvironment.TimeoutInMinutes); var containerParent = await _collectionQueries.GetAsync(rule.ContainerId); if (containerParent.ParentContainerId != null) { var collectionParent = await _collectionQueries.GetAsync(containerParent.ParentContainerId.Value); ruleDetailsDestinationId = collectionParent.RuleDetailsDestinationId; } RuleExecutionLog ruleExecutionLog = new RuleExecutionLog() { Id = 0, Evaluation = testResult.Evaluation, RuleId = ruleId, StatusId = (int)testResult.Status, Result = testResult.Result, Response = testResult.Evaluation ? "Ok" : testResult.ErrorMessage, DatabaseEnvironmentId = databaseEnvironment.Id, ExecutedSql = testResult.ExecutedSql, DiagnosticSql = rule.DiagnosticSql, RuleDetailsDestinationId = ruleDetailsDestinationId }; if (ruleExecutionLog.RuleDetailsDestinationId == null || ruleExecutionLog.RuleDetailsDestinationId.Value == 0) { ruleExecutionLog.RuleDetailsDestinationId = null; } testResult.LastExecuted = executionLogs.Any() ? executionLogs.FirstOrDefault().ExecutionDate : (DateTime?)null; ruleExecutionLog.ExecutionTimeMs = stopWatch.ElapsedMilliseconds; ruleExecutionLog.Result = testResult.Result; var newRuleExecutionLog = await _ruleExecutionLogCommands.AddAsync(ruleExecutionLog); testResult.TestResults = await _ruleService.GetTopResults(ruleId, databaseEnvironment.Id); if (!testResult.Evaluation) { testResult.DiagnosticSql = rule.DiagnosticSql; } try { //Validate if the rule is going to any queue table if (ruleDetailsDestinationId != null && ruleDetailsDestinationId.Value > 0) { var existCatalog = await _catalogQueries.GetAsync(ruleDetailsDestinationId.Value); if (existCatalog != null) { int maxNumberResults = databaseEnvironment.MaxNumberResults.Value; if (rule.MaxNumberResults != null) { maxNumberResults = rule.MaxNumberResults.Value; } await InsertDiagnosticSqlIntoDetails(rule, newRuleExecutionLog, connectionString, databaseEnvironment.UserParams, existCatalog.Name, maxNumberResults); } } } catch (Exception ex) { newRuleExecutionLog.Result = -1; newRuleExecutionLog.Response = ex.Message; await _ruleExecutionLogCommands.UpdateAsync(newRuleExecutionLog); } return(testResult); }
public async Task <List <RuleTestResult> > ExecuteRulesByEnvironmentIdAsync(List <RuleBO> rules, DatabaseEnvironmentBO databaseEnvironment) { var results = new List <RuleTestResult>(); var connectionString = databaseEnvironment .GetConnectionString(); foreach (var rule in rules) { results.Add(await ExecuteRuleAsync(rule, connectionString, databaseEnvironment.UserParams, databaseEnvironment.TimeoutInMinutes)); } return(results); }
public async Task <TableResult> ExecuteRuleDiagnosticByRuleLogIdAndEnvironmentIdAsync(int ruleLogId, DatabaseEnvironmentBO databaseEnvironment) { TableResult result = new TableResult(); var existLog = await _ruleExecutionLogQueries.GetAsync(ruleLogId); var connectionString = databaseEnvironment.GetConnectionString(); try { if (!connectionString.ToLower().Contains("timeout") && databaseEnvironment.TimeoutInMinutes == null) { connectionString += " Connection Timeout = 60"; } else if (databaseEnvironment.TimeoutInMinutes != null) { connectionString += " Connection Timeout = " + (databaseEnvironment.TimeoutInMinutes.Value * 60).ToString(); } using (var conn = new SqlConnection(connectionString)) { await conn.OpenAsync(); using (var cmd = new SqlCommand(existLog.DiagnosticSql, conn)) { if (databaseEnvironment.TimeoutInMinutes != null) { cmd.CommandTimeout = (databaseEnvironment.TimeoutInMinutes.Value * 60); } AddParameters(existLog.DiagnosticSql, cmd, databaseEnvironment.UserParams); var getReader = await cmd.ExecuteReaderAsync(); DataTable dt = new DataTable(); dt.Load(getReader); result.Columns = dt.Columns.Count; foreach (var dataColumn in dt.Columns) { result.ColumnsName.Add(dataColumn.ToString()); } var informationAsList = (from x in dt.AsEnumerable() select x).ToList(); result.Information = Utils.Serialize(result.ColumnsName, informationAsList); result.Rows = result.Information.Count; } } } catch (Exception ex) { result.MessageError = ex.Message; } return(result); }
public async Task <RuleExecutionLogDetailBO> ExecutionDiagnosticSqlByLogIdAsync(int id) { RuleExecutionLogDetailBO result = new RuleExecutionLogDetailBO { Columns = new List <string>(), Rows = new List <Dictionary <string, string> >() }; var ruleExecutionLog = await _queriesRuleExecutionLog.GetAsync(id); if (ruleExecutionLog != null) { var existDatabaseEnvironment = await _queriesDatabaseEnvironments.GetAsync(ruleExecutionLog.DatabaseEnvironmentId); DatabaseEnvironmentBO envBO = new DatabaseEnvironmentBO { Database = existDatabaseEnvironment.Database, DataSource = existDatabaseEnvironment.DataSource, ExtraData = existDatabaseEnvironment.ExtraData, Password = existDatabaseEnvironment.Password, SecurityIntegrated = existDatabaseEnvironment.SecurityIntegrated, TimeoutInMinutes = existDatabaseEnvironment.TimeoutInMinutes, User = existDatabaseEnvironment.User }; string connectionString = envBO.GetConnectionString(); if (!connectionString.ToLower().Contains("timeout") && envBO.TimeoutInMinutes == null) { connectionString += " Connection Timeout = 60"; } else if (envBO.TimeoutInMinutes != null) { connectionString += " Connection Timeout = " + (envBO.TimeoutInMinutes.Value * 60).ToString(); } try { using (var conn = new SqlConnection(connectionString)) { conn.Open(); using (var cmd = new SqlCommand(ruleExecutionLog.DiagnosticSql, conn)) { if (envBO.TimeoutInMinutes != null) { cmd.CommandTimeout = (envBO.TimeoutInMinutes.Value * 60); } result.RuleDiagnosticSql = ruleExecutionLog.DiagnosticSql; var reader = await cmd.ExecuteReaderAsync(); if (reader.HasRows) { DataTable dt = new DataTable(); dt.Load(reader); if (dt != null) { List <string> columnsToExport = new List <string>(); foreach (DataColumn column in dt.Columns) { string columnName = column.ColumnName.ToLower(); columnsToExport.Add(columnName); } List <Dictionary <string, string> > rowsToExport = new List <Dictionary <string, string> >(); foreach (DataRow row in dt.Rows) { Dictionary <string, string> newRow = new Dictionary <string, string>(); foreach (var column in columnsToExport) { newRow.Add(column, row[column].ToString()); } rowsToExport.Add(newRow); } result.RuleExecutionLogId = id; result.Columns = columnsToExport; result.Rows = rowsToExport; } } } } } catch { } } return(result); }