public async Task <List <CatalogBO> > GetAsync() { var catalogList = await _queries.GetAsync(); if (catalogList != null) { return(catalogList .Select(rec => MapEntityToModel(rec)) .ToList()); } return(null); }
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 <ContainerBO> GetToCommunityAsync(Guid containerId) { Container container = await this._collectionQueries.GetAsync(containerId); var collectionCategory = new ContainerBO(); collectionCategory.Id = container.Id; collectionCategory.Name = container.Name; collectionCategory.Description = container.Description; collectionCategory.EnvironmentType = container.EnvironmentType; collectionCategory.ChildContainers = new List <ContainerBO>(); collectionCategory.ContainerTypeId = container.ContainerTypeId; //collectionCategory.CreatedByUserId = container.CreatedByUserId; collectionCategory.Tags = new List <TagBO>(); collectionCategory.Tags = (await _tagQueries.GetByContainerIdAsync(collectionCategory.Id)).Select(rec => new TagBO(rec)).ToList(); collectionCategory.RuleDetailsDestinationId = container.RuleDetailsDestinationId; var environmentCatalog = await _catalogQueries.GetAsync(container.EnvironmentType); if (environmentCatalog != null) { collectionCategory.CatalogEnvironmentType = new CatalogBO { CatalogType = environmentCatalog.CatalogType, Description = environmentCatalog.Description, Name = environmentCatalog.Name } } ; if (collectionCategory.Tags.Any()) { collectionCategory.Tags = collectionCategory.Tags.Where(rec => rec.IsPublic).ToList(); } if (collectionCategory.RuleDetailsDestinationId != null) { var existCatalog = await _catalogQueries.GetAsync(collectionCategory.RuleDetailsDestinationId.Value); if (existCatalog != null) { var listColumns = await _edFiRuleExecutionLogDetailQueries.GetColumnsByTableAsync(existCatalog.Name, "destination"); if (listColumns != null) { collectionCategory.ContainerDestination = new ContainerDestinationBO { CatalogId = existCatalog.Id, ContainerId = collectionCategory.Id, DestinationName = existCatalog.Name, DestinationStructure = JsonConvert.SerializeObject(listColumns) }; } } } foreach (var itemContainer in container.ChildContainers) { var category = new ContainerBO { Id = itemContainer.Id, Name = itemContainer.Name, Description = itemContainer.Description, ParentContainerId = itemContainer.ParentContainerId, Rules = new List <RuleBO>(), Tags = new List <TagBO>() }; category.Tags = (await _tagQueries.GetByContainerIdAsync(itemContainer.Id)).Select(rec => new TagBO(rec)).ToList(); category.Rules = await _ruleService.GetByContainerIdAsync(itemContainer.Id); if (category.Tags.Any()) { category.Tags = category.Tags.Where(rec => rec.IsPublic).ToList(); } if (category.Rules.Any()) { category.Rules.ForEach(rec => { if (rec.Tags != null && rec.Tags.Any()) { rec.Tags = rec.Tags.Where(recTags => recTags.IsPublic).ToList(); } }); } collectionCategory.ChildContainers.Add(category); } return(collectionCategory); }
public async Task <RuleExecutionLogDetailBO> GetByRuleExecutionLogIdAsync(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 && ruleExecutionLog.RuleDetailsDestinationId != null) { var existRule = await _queriesRule.GetAsync(ruleExecutionLog.RuleId); var existDatabaseEnvironment = await _queriesDatabaseEnvironments.GetAsync(ruleExecutionLog.DatabaseEnvironmentId); result.RuleName = existRule.Name; result.EnvironmentName = existDatabaseEnvironment.Name; result.ExecutionDateTime = ruleExecutionLog.ExecutionDate.ToLocalTime().ToString("MM/dd/yyyy HH:mm"); var catalog = await _queriesCatalog.GetAsync(ruleExecutionLog.RuleDetailsDestinationId.Value); if (catalog != null) { result.DestinationTable = catalog.Name; result.RuleDiagnosticSql = ruleExecutionLog.DiagnosticSql; Dictionary <string, string> columnsFromLog = new Dictionary <string, string>(); if (!string.IsNullOrEmpty(ruleExecutionLog.DetailsSchema)) { columnsFromLog = JsonConvert.DeserializeObject <Dictionary <string, string> >(ruleExecutionLog.DetailsSchema); } var reader = await _queries.GetByRuleExecutionLogIdAsync(id, catalog.Name); if (reader != null) { List <string> columnsToIgnore = new List <string>() { "id", "otherdetails", "ruleexecutionlogid" }; List <string> columnsToExport = new List <string>(); foreach (DataColumn column in reader.Columns) { string columnName = column.ColumnName.ToLower(); if (!columnsToIgnore.Contains(columnName) && (columnsFromLog.Count == 0 || columnsFromLog.ContainsKey(columnName))) { columnsToExport.Add(columnName); } } List <Dictionary <string, string> > rowsToExport = new List <Dictionary <string, string> >(); foreach (DataRow row in reader.Rows) { Dictionary <string, string> newRow = new Dictionary <string, string>(); foreach (var column in columnsToExport) { newRow.Add(column, row[column].ToString()); } string otherDetails = row.Field <string>("otherdetails").ToString(); if (!string.IsNullOrEmpty(otherDetails)) { Dictionary <string, string> jsonValues = JsonConvert.DeserializeObject <Dictionary <string, string> >(otherDetails); foreach (var element in jsonValues) { if (columnsToExport.Contains(element.Key) || columnsFromLog.ContainsKey(element.Key)) { newRow.Add(element.Key, element.Value); } } } rowsToExport.Add(newRow); } if (columnsFromLog.Count > 0) { columnsToExport = columnsFromLog.Select(rec => rec.Key).ToList(); } result.RuleExecutionLogId = id; result.Columns = columnsToExport; result.Rows = rowsToExport; } } } return(result); }