private void SearchQueryMSetOrderByShouldWork()
{
const OrderRule expected = OrderRule.Desc;
var obj = new SearchQueryM {
OrderBy = expected.ToString()
};
Assert.Equal(expected, obj.OrderByValue);
}
/// <summary>
/// Stat search method. units
/// </summary>
/// <param name = "filter"> Request </param>
/// <param name = "userId"> User Id </param>
/// <param name = "isDeleted"> Distance flag </param>
/// <returns> </returns>
public async Task <SearchVm> Search(SearchQueryM filter, string userId, bool isDeleted = false)
{
await _elasticService.CheckElasticSearchConnection();
bool isAdmin = await _userService.IsInRoleAsync(userId, DefaultRoleNames.Administrator);
long totalCount;
List <ElasticStatUnit> units;
if (filter.IsEmpty())
{
var baseQuery = _dbContext.StatUnitSearchView
.Where(s => s.IsDeleted == isDeleted && s.LiqDate == null);
totalCount = baseQuery.Count();
units = (await baseQuery.Skip((filter.Page - 1) * filter.PageSize).Take(filter.PageSize).ToListAsync())
.Select(Mapper.Map <StatUnitSearchView, ElasticStatUnit>).ToList();
}
else
{
var searchResponse = await _elasticService.Search(filter, userId, isDeleted);
totalCount = searchResponse.TotalCount;
units = searchResponse.Result.ToList();
}
var finalIds = units.Where(x => x.UnitType != StatUnitTypes.EnterpriseGroup)
.Select(x => x.RegId).ToList();
var finalRegionIds = units.Select(x => x.RegionId).ToList();
var unitsToPersonNames = await GetUnitsToPersonNamesByUnitIds(finalIds);
var unitsToMainActivities = await GetUnitsToPrimaryActivities(finalIds);
var regions = await GetRegionsFullPaths(finalRegionIds);
var permissions = await _userService.GetDataAccessAttributes(userId, null);
var helper = new StatUnitCheckPermissionsHelper(_dbContext);
var result = units
.Select(x => new SearchViewAdapterModel(x, unitsToPersonNames[x.RegId],
unitsToMainActivities[x.RegId],
regions.GetValueOrDefault(x.RegionId)))
.Select(x => SearchItemVm.Create(x, x.UnitType,
permissions.GetReadablePropNames(),
!isAdmin && !helper.IsRegionOrActivityContains(userId, x.RegionId != null ? new List <int> {
(int)x.RegionId
} : new List <int>(), x.ActivityCategoryIds)));
return(SearchVm.Create(result, totalCount));
}
private async Task GetAll()
{
using (var ctx = CreateDbContext())
{
var query = new SearchQueryM {
Wildcard = "2"
};
ctx.DataSources.AddRange(new DataSource {
Name = "123"
}, new DataSource {
Name = "234"
});
await ctx.SaveChangesAsync();
var actual = await new DataSourcesService(ctx).GetAllDataSources(query);
Assert.Equal(2, actual.Result.Count());
}
}
private async Task GetAllSortBy()
{
using (var ctx = CreateDbContext())
{
var query = new SearchQueryM
{
SortBy = nameof(DataSource.Name),
OrderBy = OrderRule.Desc.ToString(),
};
ctx.DataSources.AddRange(new DataSource {
Name = "123"
}, new DataSource {
Name = "234"
});
await ctx.SaveChangesAsync();
var actual = await new DataSourcesService(ctx).GetAllDataSources(query);
Assert.Equal("234", actual.Result.First()?.Name);
}
}
/// <summary>
/// Method for obtaining all data sources
/// </summary>
/// <param name = "query"> Request </param>
/// <returns> </returns>
public async Task <SearchVm <DataSourceVm> > GetAllDataSources(SearchQueryM query)
{
var wildcard = query.Wildcard;
var statUnitType = query.StatUnitType;
var priority = (DataSourcePriority)query.Priority;
var allowedOperations = (DataSourceAllowedOperation)query.AllowedOperations;
var sortBy = string.IsNullOrEmpty(query.SortBy)
? "Id"
: query.SortBy;
var orderRule = query.OrderByValue == OrderRule.Asc
? "ASC"
: "DESC";
var filtered = _context.DataSources
.AsNoTracking()
.Where(ds => string.IsNullOrEmpty(wildcard) || ds.Name.ToLower().Contains(wildcard.ToLower()))
.Where(ds => statUnitType == 0 || ds.StatUnitType == (StatUnitTypes)statUnitType)
.Where(ds => priority == 0 || ds.Priority == priority)
.Where(ds => allowedOperations == 0 || ds.AllowedOperations == allowedOperations)
.OrderBy($"{sortBy} {orderRule}");
var total = await filtered.CountAsync();
if (query.GetAll)
{
var res = await filtered.ToListAsync();
return(SearchVm <DataSourceVm> .Create(res.Select(DataSourceVm.Create), total));
}
var result = await filtered
.Skip(Pagination.CalculateSkip(query.PageSize, query.Page, total))
.Take(query.PageSize)
.ToListAsync();
return(SearchVm <DataSourceVm> .Create(result.Select(DataSourceVm.Create), total));
}
private async Task GetQueuesByStatus()
{
using (var ctx = CreateDbContext())
{
var query = new SearchQueryM {
Status = DataSourceQueueStatuses.DataLoadCompletedPartially
};
var dataSource = new DataSource {
Name = "TestDS"
};
ctx.DataSources.Add(dataSource);
var user = new User {
Name = "TestUser"
};
ctx.Users.Add(user);
ctx.DataSourceQueues.AddRange(
new DataSourceQueue
{
Status = DataSourceQueueStatuses.DataLoadCompletedPartially,
DataSource = dataSource,
User = user
},
new DataSourceQueue
{
Status = DataSourceQueueStatuses.InQueue,
DataSource = dataSource,
User = user
});
await ctx.SaveChangesAsync();
var result = await CreateEmptyConfiguredDataSourceQueueService(ctx).GetAllDataSourceQueues(query);
Assert.Single(result.Result);
Assert.Equal((int)DataSourceQueueStatuses.DataLoadCompletedPartially, result.Result.First()?.Status);
}
}
/// <summary>
/// Connection search method
/// </summary>
/// <param name = "search"> Link search model </param>
/// <param name = "userId"> user ID </param>
/// <returns> </returns>
public async Task <List <UnitNodeVm> > Search(LinkSearchM search, string userId)
{
var searchModel = new SearchQueryM()
{
Name = search.Wildcard,
Type = search.Type != null
? new List <StatUnitTypes> {
(StatUnitTypes)search.Type
}
: new List <StatUnitTypes>(),
RegId = search.Id,
RegionId = search.RegionCode,
LastChangeFrom = search.LastChangeFrom,
LastChangeTo = search.LastChangeTo,
DataSourceClassificationId = search.DataSourceClassificationId,
PageSize = 20
};
var searchResponse = await _elasticService.Search(searchModel, userId, false);
var units = searchResponse.Result.ToList();
var list = new List <IStatisticalUnit>();
var listIds = units.Select(x => x.RegId).ToList();
var type = search.Type;
if (type == null || type == StatUnitTypes.EnterpriseGroup)
{
var entGroup = _commonSvc.GetUnitsList <EnterpriseGroup>(false)
.Where(x => listIds.Contains(x.RegId))
.Include(x => x.EnterpriseUnits)
.ThenInclude(x => x.LegalUnits)
.ThenInclude(x => x.LocalUnits);
list.AddRange(entGroup);
list.AddRange(entGroup.SelectMany(x => x.EnterpriseUnits.Where(y => y.IsDeleted == false)));
list.AddRange(entGroup.SelectMany(x => x.EnterpriseUnits.Where(y => y.IsDeleted == false).SelectMany(y => y.LegalUnits.Where(z => z.IsDeleted == false))));
list.AddRange(entGroup.SelectMany(x => x.EnterpriseUnits.Where(y => y.IsDeleted == false).SelectMany(y => y.LegalUnits.Where(z => z.IsDeleted == false).SelectMany(z => z.LocalUnits.Where(l => l.IsDeleted == false)))));
}
if (type == null || type == StatUnitTypes.EnterpriseUnit)
{
var entUnit = _commonSvc.GetUnitsList <EnterpriseUnit>(false)
.Where(x => listIds.Contains(x.RegId))
.Include(x => x.LegalUnits)
.ThenInclude(x => x.LocalUnits)
.Include(x => x.EnterpriseGroup);
list.AddRange(entUnit.Where(x => x.EnterpriseGroup.IsDeleted == false).Select(x => x.EnterpriseGroup));
list.AddRange(entUnit);
list.AddRange(entUnit.SelectMany(x => x.LegalUnits.Where(y => y.IsDeleted == false)));
list.AddRange(entUnit.SelectMany(x => x.LegalUnits.Where(y => y.IsDeleted == false).SelectMany(y => y.LocalUnits.Where(z => z.IsDeleted == false))));
}
if (type == null || type == StatUnitTypes.LegalUnit)
{
var legalUnit = _commonSvc.GetUnitsList <LegalUnit>(false)
.Where(x => listIds.Contains(x.RegId))
.Include(x => x.EnterpriseUnit)
.ThenInclude(x => x.EnterpriseGroup)
.Include(x => x.LocalUnits);
list.AddRange(legalUnit.Where(x => x.EnterpriseUnit.IsDeleted == false).Select(x => x.EnterpriseUnit).Where(x => x.EnterpriseGroup.IsDeleted == false).Select(x => x.EnterpriseGroup));
list.AddRange(legalUnit.Where(x => x.EnterpriseUnit.IsDeleted == false).Select(x => x.EnterpriseUnit));
list.AddRange(legalUnit);
list.AddRange(legalUnit.SelectMany(x => x.LocalUnits.Where(y => y.IsDeleted == false)));
}
if (type == null || type == StatUnitTypes.LocalUnit)
{
var localUnit = _commonSvc.GetUnitsList <LocalUnit>(false)
.Where(x => listIds.Contains(x.RegId))
.Include(x => x.LegalUnit)
.ThenInclude(x => x.EnterpriseUnit)
.ThenInclude(x => x.EnterpriseGroup);
list.AddRange(localUnit.Where(x => x.LegalUnit.IsDeleted == false).Select(x => x.LegalUnit).Where(x => x.EnterpriseUnit.IsDeleted == false).Select(x => x.EnterpriseUnit).Where(x => x.EnterpriseGroup.IsDeleted == false).Select(x => x.EnterpriseGroup));
list.AddRange(localUnit.Where(x => x.LegalUnit.IsDeleted == false).Select(x => x.LegalUnit).Where(x => x.EnterpriseUnit.IsDeleted == false).Select(x => x.EnterpriseUnit));
list.AddRange(localUnit.Where(x => x.LegalUnit.IsDeleted == false).Select(x => x.LegalUnit));
list.AddRange(localUnit);
}
return(ToNodeVm(list, listIds));
}
public async Task <IActionResult> GetDeleted(SearchQueryM data) => Ok(await _searchService.Search(data, User.GetUserId(), true));
public async Task <IActionResult> GetAllPaged([FromQuery] SearchQueryM data) => Ok(await _svc.GetAllDataSources(data));
/// <summary>
/// Stat search method. units by code
/// </summary>
/// <param name = "type"> Type of static unit </param>
/// <param name = "code"> Code </param>
/// <param name = "isDeleted"> Delete flag </param>
/// <param name = "limit"> Display limitation </param>
/// <param name = "userId"> User Id </param>
/// <param name = "regId"> Registration Id </param>
/// <param name = "page"> Current page </param>
/// <returns> </returns>
public async Task <List <UnitLookupVm> > Search(StatUnitTypes type, string code, string userId, int regId, bool isDeleted, int limit = 5, int page = 1)
{
if (isDeleted)
{
var list = new List <UnitLookupVm>();
var root = new UnitSubmitM()
{
Id = regId,
Type = type
};
switch (type)
{
case StatUnitTypes.EnterpriseGroup:
list.AddRange(Common.ToUnitLookupVm(
await _commonSvc.GetUnitsList <EnterpriseUnit>(false)
.Where(v => v.EntGroupId == regId)
.Select(Common.UnitMapping)
.ToListAsync()
));
break;
case StatUnitTypes.EnterpriseUnit:
list.AddRange(Common.ToUnitLookupVm(
await _commonSvc.GetUnitsList <EnterpriseUnit>(false)
.Where(v => v.RegId == regId)
.Include(v => v.EnterpriseGroup)
.Select(v => v.EnterpriseGroup)
.Select(Common.UnitMapping)
.ToListAsync()
));
list.AddRange(Common.ToUnitLookupVm(
await _commonSvc.GetUnitsList <LegalUnit>(false)
.Where(v => v.EnterpriseUnitRegId == regId)
.Select(Common.UnitMapping)
.ToListAsync()
));
break;
case StatUnitTypes.LegalUnit:
list.AddRange(Common.ToUnitLookupVm(
await _commonSvc.GetUnitsList <LegalUnit>(false)
.Where(v => v.RegId == regId)
.Include(v => v.EnterpriseUnit)
.Select(v => v.EnterpriseUnit)
.Select(Common.UnitMapping)
.ToListAsync()
));
list.AddRange(Common.ToUnitLookupVm(
await _commonSvc.GetUnitsList <LocalUnit>(false)
.Where(v => v.LegalUnitId == regId)
.Select(Common.UnitMapping)
.ToListAsync()
));
break;
case StatUnitTypes.LocalUnit:
var linkedList = await _service.LinksList(root);
if (linkedList.Count > 0)
{
list.Add(new UnitLookupVm {
Id = linkedList[0].Source1.Id, Type = linkedList[0].Source1.Type, Code = linkedList[0].Source1.Code, Name = linkedList[0].Source1.Name
});
}
break;
}
return(list);
}
var statUnitTypes = new List <StatUnitTypes>();
switch (type)
{
case StatUnitTypes.LocalUnit:
statUnitTypes.Add(StatUnitTypes.LegalUnit);
break;
case StatUnitTypes.LegalUnit:
statUnitTypes.Add(StatUnitTypes.LocalUnit);
statUnitTypes.Add(StatUnitTypes.EnterpriseUnit);
break;
case StatUnitTypes.EnterpriseUnit:
statUnitTypes.Add(StatUnitTypes.LegalUnit);
statUnitTypes.Add(StatUnitTypes.EnterpriseGroup);
break;
case StatUnitTypes.EnterpriseGroup:
statUnitTypes.Add(StatUnitTypes.EnterpriseUnit);
break;
}
var filter = new SearchQueryM
{
Type = statUnitTypes,
StatId = code,
Page = page,
PageSize = limit
};
var searchResponse = await _elasticService.Search(filter, userId, isDeleted);
return(searchResponse.Result.Select(u => new UnitLookupVm {
Id = u.RegId, Code = u.StatId, Name = u.Name, Type = u.UnitType
}).ToList());
}
public async Task <SearchVm <ElasticStatUnit> > Search(SearchQueryM filter, string userId, bool isDeleted)
{
await Synchronize();
var mustQueries =
new List <Func <QueryContainerDescriptor <ElasticStatUnit>, QueryContainer> >
{
m => m.Term(p => p.Field(f => f.IsDeleted).Value(isDeleted))
};
var separators = new[] { ' ', '\t', '\r', '\n', ',', '.', '-' };
if (!string.IsNullOrWhiteSpace(filter.Name))
{
var nameFilterParts = filter.Name.ToLower().Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var nameFilter in nameFilterParts)
{
mustQueries.Add(m => m.Prefix(p => p.Field(f => f.Name).Value(nameFilter)));
}
}
if (filter.Type.Any())
{
mustQueries.Add(m => m.Terms(p => p.Field(f => f.UnitType).Terms(filter.Type)));
}
if (!string.IsNullOrWhiteSpace(filter.StatId))
{
mustQueries.Add(m => m.Terms(p => p.Field(f => f.StatId).Terms(filter.StatId)));
}
if (!string.IsNullOrWhiteSpace(filter.ExternalId))
{
mustQueries.Add(m => m.Terms(p => p.Field(f => f.ExternalId).Terms(filter.ExternalId)));
}
if (!string.IsNullOrWhiteSpace(filter.TaxRegId))
{
mustQueries.Add(m => m.Terms(p => p.Field(f => f.TaxRegId).Terms(filter.TaxRegId)));
}
if (!string.IsNullOrWhiteSpace(filter.Address))
{
string[] addressFilters = filter.Address.ToLower().Split(separators, StringSplitOptions.RemoveEmptyEntries);
foreach (var addressFilter in addressFilters)
{
mustQueries.Add(m => m
.Bool(b => b
.Should(s => s.Prefix(t => t.Field(f => f.AddressPart1).Value(addressFilter)) ||
s.Prefix(t => t.Field(f => f.AddressPart2).Value(addressFilter)) ||
s.Prefix(t => t.Field(f => f.AddressPart3).Value(addressFilter)))
)
);
}
}
var turnoverQueries = new List <Func <QueryContainerDescriptor <ElasticStatUnit>, QueryContainer> >();
if (filter.TurnoverFrom.HasValue)
{
double turnoverFrom = (double)filter.TurnoverFrom.Value;
turnoverQueries.Add(m => m.Range(p => p.Field(f => f.Turnover).GreaterThanOrEquals(turnoverFrom)));
}
if (filter.TurnoverTo.HasValue)
{
double turnoverTo = (double)filter.TurnoverTo.Value;
turnoverQueries.Add(m => m.Range(p => p.Field(f => f.Turnover).LessThanOrEquals(turnoverTo)));
}
var employeeQueries = new List <Func <QueryContainerDescriptor <ElasticStatUnit>, QueryContainer> >();
if (filter.EmployeesNumberFrom.HasValue)
{
int employeesNumberFrom = (int)filter.EmployeesNumberFrom.Value;
employeeQueries.Add(m => m.Range(p => p.Field(f => f.Employees).GreaterThanOrEquals(employeesNumberFrom)));
}
if (filter.EmployeesNumberTo.HasValue)
{
int employeesNumberTo = (int)filter.EmployeesNumberTo.Value;
employeeQueries.Add(m => m.Range(p => p.Field(f => f.Employees).LessThanOrEquals(employeesNumberTo)));
}
if (filter.Comparison == ComparisonEnum.And || turnoverQueries.Count == 0 || employeeQueries.Count == 0)
{
mustQueries.AddRange(turnoverQueries);
mustQueries.AddRange(employeeQueries);
}
else
{
mustQueries.Add(m => m.Bool(b => b.Should(s => s.Bool(b1 => b1.Must(turnoverQueries)), s => s.Bool(b2 => b2.Must(employeeQueries)))));
}
if (filter.LastChangeFrom.HasValue)
{
DateTime lastChangeFrom = filter.LastChangeFrom.Value.ToUniversalTime();
mustQueries.Add(m => m.DateRange(p => p.Field(f => f.StartPeriod).GreaterThanOrEquals(lastChangeFrom)));
}
if (filter.LastChangeTo.HasValue)
{
DateTime lastChangeTo = filter.LastChangeTo.Value.ToUniversalTime().AddHours(23).AddMinutes(59).AddSeconds(59);
mustQueries.Add(m => m.DateRange(p => p.Field(f => f.StartPeriod).LessThanOrEquals(lastChangeTo)));
}
if (filter.LastChangeFrom.HasValue || filter.LastChangeTo.HasValue)
{
mustQueries.Add(m => m.Bool(b => b.MustNot(mn => mn.Term(p => p.Field(f => f.ChangeReason).Value(ChangeReasons.Create)))));
}
if (filter.DataSourceClassificationId.HasValue)
{
int dataSourceClassificationId = filter.DataSourceClassificationId.Value;
mustQueries.Add(m => m.Term(p => p.Field(f => f.DataSourceClassificationId).Value(dataSourceClassificationId)));
}
if (!filter.IncludeLiquidated.HasValue || !filter.IncludeLiquidated.Value)
{
mustQueries.Add(m => !m.Exists(e => e.Field(f => f.LiqDate)));
}
if (filter.RegMainActivityId.HasValue)
{
var regMainActivityIds = new[] { filter.RegMainActivityId.Value };
mustQueries.Add(m => m.Terms(p => p.Field(f => f.ActivityCategoryIds).Terms(regMainActivityIds)));
}
if (filter.RegId.HasValue)
{
int id = filter.RegId.Value;
mustQueries.Add(m => m.Term(p => p.Field(f => f.RegId).Value(id)));
}
if (filter.SectorCodeId.HasValue)
{
int sectorCodeId = filter.SectorCodeId.Value;
mustQueries.Add(m => m.Term(p => p.Field(f => f.SectorCodeId).Value(sectorCodeId)));
}
if (filter.LegalFormId.HasValue)
{
int legalFormId = filter.LegalFormId.Value;
mustQueries.Add(m => m.Term(p => p.Field(f => f.LegalFormId).Value(legalFormId)));
}
if (filter.RegionId.HasValue)
{
int regionId = filter.RegionId.Value;
mustQueries.Add(m => m.Term(p => p.Field(f => f.RegionId).Value(regionId)));
}
Func <SearchDescriptor <ElasticStatUnit>, ISearchRequest> searchFunc;
if (filter.SortBy.HasValue)
{
searchFunc = s =>
s.Index(StatUnitSearchIndexName).From(0).Take(10000).Query(q => q.Bool(b => b.Must(mustQueries))).TerminateAfter(2000);
}
else
{
searchFunc = s =>
s.Index(StatUnitSearchIndexName).From((filter.Page - 1) * filter.PageSize).Take(filter.PageSize)
.Query(q => q.Bool(b => b.Must(mustQueries))).TerminateAfter(2000);
}
var searchResponse = await _elasticClient.SearchAsync(searchFunc);
if (!searchResponse.IsValid)
{
return(SearchVm <ElasticStatUnit> .Create(new List <ElasticStatUnit>(), 0));
}
//throw new Exception(searchResponse.DebugInformation);
List <ElasticStatUnit> units = searchResponse.Documents.ToList();
if (filter.SortBy.HasValue)
{
IOrderedEnumerable <ElasticStatUnit> sortQuery;
switch (filter.SortBy.Value)
{
case SortFields.Employees:
sortQuery = filter.SortRule == OrderRule.Asc ? units.OrderBy(u => u.Employees) : units.OrderByDescending(u => u.Employees);
break;
case SortFields.StatId:
sortQuery = filter.SortRule == OrderRule.Asc ? units.OrderBy(u => u.StatId) : units.OrderByDescending(u => u.StatId);
break;
case SortFields.Turnover:
sortQuery = filter.SortRule == OrderRule.Asc ? units.OrderBy(u => u.Turnover) : units.OrderByDescending(u => u.Turnover);
break;
default:
sortQuery = filter.SortRule == OrderRule.Asc ? units.OrderBy(u => u.Name) : units.OrderByDescending(u => u.Name);
break;
}
units = sortQuery.Skip((filter.Page - 1) * filter.PageSize).Take(filter.PageSize).ToList();
}
return(SearchVm <ElasticStatUnit> .Create(units, searchResponse.Total));
}
public async Task <IActionResult> Search([FromQuery] SearchQueryM query) => Ok(await _searchService.Search(query, User.GetUserId()));
public async Task <IActionResult> GetAll([FromQuery] SearchQueryM model) => Ok(await _sampleFramesService.GetAll(model, User.GetUserId()));