public async Task <List <CatalogBO> > GetByTypeAsync(string type)
{
var catalogList = await _queries.GetByTypeAsync(type);
if (catalogList != null)
{
return(catalogList
.Select(rec => MapEntityToModel(rec))
.ToList());
}
return(null);
}
public async Task <SearchTagBO> SearchRulesAsync(List <Guid> collectionsSelected, List <Guid> containersSelected, List <int> tagsSelected, string name, string diagnostic, int?detailsDestination, int?severityId)
{
SearchTagBO result = new SearchTagBO();
List <Rule> allRules = await _ruleQueries
.GetByCollectionOrContainerOrTagAsync(collectionsSelected, containersSelected, tagsSelected
.ToList());
if (!string.IsNullOrEmpty(name))
{
allRules = allRules
.Where(rec => rec.Name.ToLower().Contains(name.ToLower()))
.ToList();
}
if (!string.IsNullOrEmpty(diagnostic))
{
allRules = allRules
.Where(rec => rec.DiagnosticSql.ToLower().Contains(diagnostic.ToLower()))
.ToList();
}
if (detailsDestination != null)
{
var collectionsByDestination = await _collectionQueries.GetByRulesDestinationIdAsync(detailsDestination.Value);
if (collectionsByDestination != null && collectionsByDestination.Any())
{
List <Guid> containersByDestination = new List <Guid>();
foreach (var collection in collectionsByDestination)
{
if (collection.ChildContainers != null && collection.ChildContainers.Any())
{
containersByDestination.AddRange(collection.ChildContainers.Select(rec => rec.Id));
}
}
if (containersByDestination.Any())
{
containersByDestination = containersByDestination.Distinct().ToList();
allRules = allRules
.Where(rec => containersByDestination.Contains(rec.ContainerId))
.ToList();
}
}
}
if (severityId != null)
{
allRules = allRules
.Where(rec => rec.ErrorSeverityLevel == severityId.Value)
.ToList();
}
result.Rules = allRules
.Select(rec => MapEntityToModel(rec))
.ToList();
if (result.Rules != null && result.Rules.Count > 0)
{
var listEnvironmentType = await _catalogQueries.GetByTypeAsync("EnvironmentType");
List <Guid> containersParents = result
.Rules
.Select(rec => rec.ContainerId)
.ToList();
containersParents = containersParents.Distinct().ToList();
List <Container> allContainersParents = await _collectionQueries
.GetByListAsync(containersParents);
List <Container> allContainersMain = await _collectionQueries
.GetByListAsync(allContainersParents.Select(rec => rec.ParentContainerId.Value).ToList());
foreach (RuleBO rule in result.Rules)
{
Container existParent = allContainersParents.FirstOrDefault(rec => rec.Id == rule.ContainerId);
if (existParent != null && existParent.ParentContainerId != null)
{
Container existParentMain = allContainersMain.FirstOrDefault(rec => rec.Id == existParent.ParentContainerId.Value);
if (existParentMain != null)
{
Catalog existType = listEnvironmentType.FirstOrDefault(rec => rec.Id == existParentMain.EnvironmentType);
if (existType != null)
{
rule.ParentContainer = existParentMain.Id;
rule.EnvironmentTypeText = existType.Name;
rule.CollectionContainerName = $"{existParentMain.Name}/{existParent.Name}";
rule.ContainerName = existParent.Name;
rule.CollectionName = existParentMain.Name;
}
}
}
}
result.Rules = result.Rules.OrderBy(rec => rec.CollectionContainerName).ToList();
}
return(result);
}
