public PagedResponse<ProductTagDoc> SearchByPrefixKeyword(PagedRequest<ProductTagSearchRequest> request)
{
QueryContainer filter = null;
var query = new QueryBuilder()
.AndPrefixMatch("name_NA", request.Data.Keyword).Build();
var result = Client.SetPageNum(request.PageNumber).SetPageSize(request.PageSize).SearchResponse(query, filter);
return Client.WrapResult(result);
}
public PagedResponse<ProductDoc> SearchByKeyword(PagedRequest<ProductSearchRequest> request)
{
//QueryContainer filter = null;
var matchFields = new string[] { "name^20", "description^5", "instruction" };
//var categoryLevelMatch = request.Data.FilterCategoryLevel.HasValue ? request.Data.FilterCategoryLevel == 1 ? "categoryLevel1" : request.Data.FilterCategoryLevel == 2 ? "categoryLevel2" : "categoryLevel3" : "categoryLevel3";
var categoryLevelMatch = "categoryLevel3";
var query = new QueryBuilder()
.AndMultiMatch(matchFields, request.Data.Keyword)
.Build();
var filterBuilder = new QueryBuilder();
foreach (var c in request.Data.CategoryName)
{
filterBuilder = filterBuilder.OrMatch(categoryLevelMatch, request.Data.CategoryName);
}
foreach (var bname in request.Data.BrandName)
{
filterBuilder = filterBuilder.OrMatch("brandName", bname);
}
foreach (var t in request.Data.Tag)
{
filterBuilder = filterBuilder.OrMatch("tags", t);
}
var filter = filterBuilder.Build();
//var query = new QueryBuilder()
// .OrMultiMatch(matchFields, request.Data.Keyword)
// //.AndMatch("brandName", request.Data.BrandName)
// .AndMatch(categoryLevelMatch, request.Data.CategoryName)
// .Build();
AggregationContainerDescriptor<ProductDoc> categoryAgg = null;
if (request.Data.NeedAggregation)
{
categoryAgg = new AggregationContainerDescriptor<ProductDoc>()
.Terms("agg_brand", f => f.Field("brandName"))
.Terms("agg_category_level_3", f => f.Field("categoryLevel3"))
.Terms("agg_tag", f => f.Field("tags"));
}
//switch (request.Data.FilterCategoryLevel)
//{
// case 1:
// categoryAgg.Terms("agg_category_level_1", f => f.Field("categoryLevel1"));
// break;
// case 2:
// categoryAgg.Terms("agg_category_level_2", f => f.Field("categoryLevel2"));
// break;
// default:
// case 3:
// categoryAgg.Terms("agg_category_level_3", f => f.Field("categoryLevel3"));
// break;
//}
var result = Client.SetPageNum(request.PageNumber).SetPageSize(request.PageSize).SearchResponse(query, filter, a => categoryAgg);
return Client.WrapResult(result);
}
public void GetRetailShopByKeyword()
{
var request = new PagedRequest<RetailShopSearchRequest>
{
Data = new RetailShopSearchRequest { Keyword = "東京" },
PageNumber = 2,
PageSize = 10
};
var result = helper.SearchByKeyword(request);
}
public void GetProductByKeyword()
{
var request = new PagedRequest<ProductSearchRequest>
{
Data = new ProductSearchRequest { Keyword = "肤质 祛痘", BrandName = new List<string> { "露适她株式会社","B by E corporation" }, CategoryName = new List<string> { "洁面", "基础化妆品" } },//, CategoryName = "基础化妆类", FilterCategoryLevel = 2
PageNumber = 1,
PageSize = 10,
};
var result = helper.SearchByKeyword(request);
}
public void GetPrefixProductTagByKeyword()
{
var request = new PagedRequest<ProductTagSearchRequest>
{
Data = new ProductTagSearchRequest { Keyword = "肉" },
PageNumber = 1,
PageSize = 10
};
var result = helper.SearchByPrefixKeyword(request);
}
public void Foo()
{
var util = Utils.GetDirect<PersonUtil>();
Utils.Init(null, new ContextResolver());
var request = new PagedRequest()
{
ItemsPerPage = 10,
PageToDeliver = 1
};
var result = util.GetBasePagedResultAsync(request, null, null, p => p.Firstname.Contains("Peter")).Result;
Assert.IsNotNull(result);
}
public async Task<ProductSearchResponse> ProductSearch(PagedRequest<ProductSearchRequest> request)
{
return await Task.Run(() =>
{
_productHelper = new ProductHelper();
var searchResult = _productHelper.SearchByKeyword(request);
var result = new ProductSearchResponse();
if (request.Data.NeedAggregation)
{
foreach (var agg in searchResult.Aggregation.Aggregations)
{
foreach (KeyedBucket item in ((BucketAggregate)agg.Value).Items)
{
switch (agg.Key)
{
case "agg_brand":
result.BrandList.Add(item.Key);
break;
case "agg_category_level_3":
result.CategoryList.Add(item.Key);
break;
case "agg_tag":
result.TagList.Add(item.Key);
break;
}
}
}
}
foreach (var product in searchResult.Data)
{
result.Products.Add(product.ToSimpleModel());
}
var userName = User.Identity.IsAuthenticated ? User.Identity.Name : Const.UnAuthorizedUserId;
Task.Run(async () =>
{
var helper = new SearchHistoryIndexHelper();
await helper.IndexDoc(new Search.IndexManager.Documents.SearchHistoryDoc
{
Keyword = request.Data.Keyword,
UserName = userName,
SearchType = Search.IndexManager.Documents.SearchType.product
});
});
return result;
});
}
public PagedResponse<RetailShopDoc> SearchByKeyword(PagedRequest<RetailShopSearchRequest> request)
{
QueryContainer filter = null;
if (request.Data.RetailerId.HasValue && request.Data.RetailerId.Value != 0)
{
filter = new FilterBuilder().AndTerm("retailerId", request.Data.RetailerId).Build();
}
var matchFields = new string[] { "address", "name", "displayName" };
var query = new QueryBuilder()
.OrMultiMatch(matchFields, request.Data.Keyword)
.Build();
var cityAgg = new AggregationContainerDescriptor<RetailShopDoc>().Terms("agg_city", f => f.Field("cityId"));
var result = Client.SetPageNum(request.PageNumber).SetPageSize(request.PageSize).SearchResponse(query, filter, a => cityAgg);
return Client.WrapResult(result);
}
public async Task <ActionResult <PagedResponse <RoleModel> > > List([FromQuery] PagedRequest <RoleModel> request)
{
return(Ok(await _mediator.Send(request)));
}
public async Task <PagedResult <InstallingPayRollSupportInProgress> > GetPayRollSupportInProgress([FromUri] PagedRequest <string> request)
{
return(await service.GetPayRollSupportInProgress(request));
}
public async static Task <PagedResponse <TModel> > CreatePaginatedResultAsync <T, TModel>(this IQueryable <T> query, PagedRequest request, IMapper mapper)
where T : BaseEntity where TModel : class
{
query = query.ApplyFilters(request);
var count = await query.CountAsync();
query = query.Paginate(request);
var projectedResult = query.ProjectTo <TModel>(mapper.ConfigurationProvider);
projectedResult = projectedResult.Sort(request);
var listResult = await projectedResult.ToListAsync();
return(new PagedResponse <TModel>()
{
Data = listResult,
PageIndex = request.PageIndex,
PageSize = request.PageSize,
Total = count
});
}
public async Task <PagedResult <ClaimsPaid> > GetPaidClaims([FromUri] PagedRequest <string> request)
{
return(await service.GetPaidClaims(request));
}
public JsonResult TermEmployeesSearch(string sidx, string sord, int page, int rows, bool _search, string searchField, string searchOper, string searchString)
{
var sortBy = Person.SortFieldName(sidx);
var request = new PagedRequest {
Page = page, PageSize = rows, SortField = sortBy, SortDirection = sord, PageIndex = page - 1
};
SaveCookie(CookieNames.GridPageSize, rows.ToString(CultureInfo.InvariantCulture));
Expression <Func <NewFire, bool> > whereClause = null;
if (_search)
{
switch (searchField)
{
case "Department":
whereClause = p => p.DeptDescr.Contains(searchString);
break;
case "Name":
whereClause = p => (p.LastName.Contains(searchString) || p.FirstName.Contains(searchString));
break;
case "Job":
whereClause = p => p.JobDescr.Contains(searchString);
break;
case "Status":
whereClause = p => p.Active != string.IsNullOrWhiteSpace(searchString) && !searchString.Contains("false");
break;
}
}
var dataController = new NewFires();
var results = dataController.Search(request, whereClause);
if (results.Failed)
{
return(null);
}
request.ResetPages(page, rows, results.RowsReturned);
// colNames: ['Status', 'Name', 'BadgeNumber', 'Department', 'Job', 'Facility', 'LastUpdated'],
var jsonData = new
{
total = request.TotalPages,
page = request.Page,
records = results.RowsReturned,
rows = (
from emp in results.Entity
select new
{
i = emp.PersonID,
cell = new[]
{
emp.Active.ToString(CultureInfo.InvariantCulture),
string.IsNullOrWhiteSpace(emp.MiddleName)
? string.Format("{0}, {1}", emp.LastName, emp.FirstName)
: string.Format("{0}, {1} {2}", emp.LastName, emp.FirstName,
emp.MiddleName),
emp.BadgeNumber,
emp.DeptDescr,
emp.JobDescr,
emp.Facility,
emp.LastUpdated.HasValue ? emp.LastUpdated.Value.ToString("d") : "",
emp.LastUpdateMask.ToString(CultureInfo.InvariantCulture),
emp.PersonID.ToString(CultureInfo.InvariantCulture)
}
}).ToArray()
};
return(Json(jsonData));
}
public Task <Library.Models.Pagination.PagedResult <LabelList> > List(User roadieUser, PagedRequest request,
bool?doRandomize = false)
{
var sw = new Stopwatch();
sw.Start();
if (!string.IsNullOrEmpty(request.Sort))
{
request.Sort = request.Sort.Replace("createdDate", "createdDateTime");
request.Sort = request.Sort.Replace("lastUpdated", "lastUpdatedDateTime");
}
var normalizedFilterValue = !string.IsNullOrEmpty(request.FilterValue)
? request.FilterValue.ToAlphanumericName()
: null;
var result = from l in DbContext.Labels
where request.FilterValue.Length == 0 || request.FilterValue.Length > 0 && (
l.Name != null && l.Name.Contains(request.FilterValue) ||
l.AlternateNames != null && l.AlternateNames.Contains(request.FilterValue) ||
l.AlternateNames != null && l.AlternateNames.Contains(normalizedFilterValue)
)
select new LabelList
{
DatabaseId = l.Id,
Id = l.RoadieId,
Label = new DataToken
{
Text = l.Name,
Value = l.RoadieId.ToString()
},
SortName = l.SortName,
CreatedDate = l.CreatedDate,
LastUpdated = l.LastUpdated,
ArtistCount = l.ArtistCount,
ReleaseCount = l.ReleaseCount,
TrackCount = l.TrackCount,
Thumbnail = MakeLabelThumbnailImage(l.RoadieId)
};
LabelList[] rows = null;
var rowCount = result.Count();
if (doRandomize ?? false)
{
var randomLimit = roadieUser?.RandomReleaseLimit ?? 100;
request.Limit = request.LimitValue > randomLimit ? randomLimit : request.LimitValue;
var sql = "SELECT l.Id FROM `label` l ORDER BY RAND() LIMIT {0}";
rows = (from rdn in DbContext.Labels.FromSql(sql, randomLimit)
join rs in result on rdn.Id equals rs.DatabaseId
select rs)
.Take(request.LimitValue)
.ToArray();
}
else
{
var sortBy = string.IsNullOrEmpty(request.Sort)
? request.OrderValue(new Dictionary <string, string> {
{ "SortName", "ASC" }, { "Label.Text", "ASC" }
})
: request.OrderValue();
rows = result.OrderBy(sortBy).Skip(request.SkipValue).Take(request.LimitValue).ToArray();
}
sw.Stop();
return(Task.FromResult(new Library.Models.Pagination.PagedResult <LabelList>
{
TotalCount = rowCount,
CurrentPage = request.PageValue,
TotalPages = (int)Math.Ceiling((double)rowCount / request.LimitValue),
OperationTime = sw.ElapsedMilliseconds,
Rows = rows
}));
}
public async Task <PaginatedResult <PostCardDto> > GetMainPageMyPosts(PagedRequest pagedRequest, string userName)
{
var mainPage = await repository.GetMainPageMyPosts(pagedRequest, userName);
return(mainPage);
}
public Task <PagedResponse <TEntity> > ToPageAsync(PagedRequest request)
{
return(GetAll().ToPageAsync(request));
}
public PagedResponse <TEntity> ToPage(PagedRequest request)
{
return(GetAll().ToPage(request));
}
public async Task <ActionResult <PagedList <ProductAnnouncementShortInfoView> > > ProductAnnouncementsShortInfo([FromQuery] PagedRequest request) => Result(await SendAsync(new GetProductAnnouncementsShortInfoQuery(request)));
public async Task <PagedResult <LaunchingIncomplete> > Incomplete([FromUri] PagedRequest <string> request)
{
return(await service.Incomplete(request));
}
public async Task <PagedResult <LaunchingCompleted> > Completed([FromUri] PagedRequest <string> request)
{
return(await service.Completed(request));
}
public async static Task <PaginatedResult <TDto> > CreatePaginatedResultAsync <TEntity, TDto>(this IQueryable <TEntity> query, PagedRequest pagedRequest, IMapper mapper)
where TEntity : BaseEntity
where TDto : class
{
query = query.ApplyFilters(pagedRequest);
var total = await query.CountAsync();
query = query.Paginate(pagedRequest);
var projectionResult = query.ProjectTo <TDto>(mapper.ConfigurationProvider);
projectionResult = projectionResult.Sort(pagedRequest);
var listResult = await projectionResult.ToListAsync();
return(new PaginatedResult <TDto>()
{
Items = listResult,
PageSize = pagedRequest.PageSize,
PageIndex = pagedRequest.PageIndex,
Total = total
});
}
protected QueryPagedBase(PagedRequest paged)
{
Paged = paged;
}
public async Task <ApiPagedResponse <IssueDetailsDto> > GetAllIssuesAsync([FromQuery] PagedRequest request)
{
return(await _issueService.GetAllIssuesAsync(request));
}
public async Task <PaginatedResult <PostGridRowDto> > GetPage(PagedRequest pagedRequest)
{
var pagedPosts = await repository.GetPagedData <Post, PostGridRowDto>(pagedRequest);
return(pagedPosts);
}
public JsonResult EmployeeListSearch(string sidx, string sord, int page = 0, int rows = 1, bool _search = false, string searchField = null, string searchOper = null, string searchString = null)
{
var sortBy = Person.SortFieldName(sidx);
var request = new PagedRequest {
Page = page, PageSize = rows, SortField = sortBy, SortDirection = sord, PageIndex = page - 1
};
SaveCookie(CookieNames.GridPageSize, rows.ToString(CultureInfo.InvariantCulture));
Expression <Func <Person, bool> > whereClause = null;
if (_search)
{
switch (searchField)
{
case "Name":
whereClause = p => (p.LastName.Contains(searchString) || p.FirstName.Contains(searchString));
break;
case "Department":
whereClause = p => p.DeptDescr.Contains(searchString);
break;
case "Position":
whereClause = p => p.JobDescr.Contains(searchString);
break;
case "Job":
whereClause = p => p.JobDescr.Contains(searchString);
break;
case "Facility":
whereClause = p => p.Facility.Contains(searchString);
break;
}
}
var dataController = new People();
var results = dataController.Search(request, whereClause);
if (results.Failed)
{
return(null);
}
request.ResetPages(page, rows, results.RowsReturned);
// colNames: ['Status', 'Name', 'BadgeNumber', 'Department', 'Job', 'Facility', 'LastUpdated'],
var jsonData = new
{
total = request.TotalPages,
page = request.Page,
records = results.RowsReturned,
rows = (
from emp in results.Entity
select new
{
i = emp.PersonID,
cell = new[]
{
emp.Active.ToString(CultureInfo.InvariantCulture),
emp.DisplayName,
string.IsNullOrWhiteSpace(emp.BadgeNumber) ? "" : emp.BadgeNumber,
emp.DeptDescr,
emp.JobDescr,
emp.Facility,
emp.LastUpdated.ToString("d"),
emp.LastUpdateMask.ToString(CultureInfo.InvariantCulture),
emp.PersonID.ToString(CultureInfo.InvariantCulture)
}
}).ToArray()
};
return(Json(jsonData));
}
public async Task <PaginatedResult <PostCardDto> > GetMainPageHome(PagedRequest pagedRequest)
{
var mainPage = await repository.GetPagedData <Post, PostCardDto>(pagedRequest);
return(mainPage);
}
public ServicePagedResponse <Link> SearchLinks(PagedRequest <SearchLinksFilter> request)
{
var result = _repo.Search(request);
return(new ServicePagedResponse <Link>(result, request.PageNumber));
}
public ActionResult List(PagedRequest request)
{
return(_buyerRepo.GetBuyers(request));
}
private static IQueryable <T> Paginate <T>(this IQueryable <T> query, PagedRequest request)
{
var entities = query.Skip((request.PageIndex) * request.PageSize).Take(request.PageSize);
return(entities);
}
public async Task <PaginatedResult <JobDTO> > GetPagedData(PagedRequest pagedRequest, IMapper mapper)
{
return(await _dbContext.Set <Job>().CreatePaginatedResultAsync <Job, JobDTO>(pagedRequest, mapper));
}
public void PageRequestNoFilters()
{
var r = new PagedRequest();
Assert.NotNull(r.FilterSql());
}
public PagedResponse <ReporteDocumentoIngresadoResponse> GetReportesDocumentosIngresados(PagedRequest request)
{
var query = _context.Query <Modelo.vw_listado_reportes_digitalizados>();
query = query.OrderByDescending(x => DateTime.Parse(x.fecha_registro));
var page = query.PagedResponse <Modelo.vw_listado_reportes_digitalizados, ReporteDocumentoIngresadoResponse>(request, _mapper);
return(page);
}
public async Task <ApiPagedResponse <MilestoneDetailsDto> > GetAllMilestones([FromQuery] PagedRequest request)
{
return(await _mileStoneService.GetAllMilestonesPaged(request));
}
public async Task <PagedResult <IssuedQuote> > GetIssuedQoutes([FromUri] PagedRequest <string> request)
{
return(await service.GetIssuedQoutes(request));
}
public Task <Library.Models.Pagination.PagedResult <CollectionList> > List(User roadieUser, PagedRequest request,
bool?doRandomize = false, Guid?releaseId = null, Guid?artistId = null)
{
var sw = new Stopwatch();
sw.Start();
IQueryable <data.Collection> collections = null;
if (artistId.HasValue)
{
collections = (from cr in DbContext.CollectionReleases
join c in DbContext.Collections on cr.CollectionId equals c.Id
join r in DbContext.Releases on cr.ReleaseId equals r.Id
join a in DbContext.Artists on r.ArtistId equals a.Id
where a.RoadieId == artistId
select c).Distinct();
}
else if (releaseId.HasValue)
{
collections = (from cr in DbContext.CollectionReleases
join c in DbContext.Collections on cr.CollectionId equals c.Id
join r in DbContext.Releases on cr.ReleaseId equals r.Id
where r.RoadieId == releaseId
select c).Distinct();
}
else
{
collections = DbContext.Collections;
}
var result = from c in collections
let collectionCount = (from crc in DbContext.CollectionReleases
where crc.CollectionId == c.Id
select crc.Id).Count()
where request.FilterValue.Length == 0 ||
request.FilterValue.Length > 0 && c.Name.Contains(request.Filter)
where request.FilterToStatusValue == Statuses.Ok || c.Status == request.FilterToStatusValue
select new CollectionList
{
DatabaseId = c.Id,
Collection = new DataToken
{
Text = c.Name,
Value = c.RoadieId.ToString()
},
Id = c.RoadieId,
CollectionCount = c.CollectionCount,
CollectionType = (c.CollectionType ?? CollectionType.Unknown).ToString(),
CollectionFoundCount = collectionCount,
CreatedDate = c.CreatedDate,
IsLocked = c.IsLocked,
LastUpdated = c.LastUpdated,
Thumbnail = ImageHelper.MakeCollectionThumbnailImage(Configuration, HttpContext, c.RoadieId)
};
var sortBy = string.IsNullOrEmpty(request.Sort)
? request.OrderValue(new Dictionary <string, string> {
{ "Collection.Text", "ASC" }
})
: request.OrderValue();
var rowCount = result.Count();
var rows = result
.OrderBy(sortBy)
.Skip(request.SkipValue)
.Take(request.LimitValue)
.ToArray();
if (request.FilterToStatusValue == Statuses.Incomplete)
{
rows = rows.OrderByDescending(x => x.PercentComplete).ThenBy(x => x.SortName).ToArray();
}
sw.Stop();
return(Task.FromResult(new Library.Models.Pagination.PagedResult <CollectionList>
{
TotalCount = rowCount,
CurrentPage = request.PageValue,
TotalPages = (int)Math.Ceiling((double)rowCount / request.LimitValue),
OperationTime = sw.ElapsedMilliseconds,
Rows = rows
}));
}
public static async Task <IPage <T> > ToPageAsync <T>(this IQueryable <T> source, PagedRequest request)
{
if (source == null)
{
throw new ArgumentNullException(
$"You cannot pageinate on a null object reference. The parameter source should be initialized.",
nameof(source));
}
if (request == null)
{
throw new ArgumentNullException(
$"You need to initialize a paging request before paging on a list. The parameter request should be initialized.",
nameof(request));
}
if (request.Page == 0)
{
if (!String.IsNullOrEmpty(request.OrderBy))
{
if (request.Order == OrderType.Asc)
{
source = source.OrderBy(request.OrderBy);
}
else
{
source = source.OrderBy(request.OrderBy + " descending");
}
}
return(new Page <T>(await source.ToListAsync(), 0, 0, 0));
}
if (String.IsNullOrEmpty(request.OrderBy))
{
throw new InvalidOperationException(
$"In order to use paging extensions you need to supply an OrderBy parameter.");
}
if (request.Order == OrderType.Asc)
{
source = source.OrderBy(request.OrderBy);
}
else
{
source = source.OrderBy(request.OrderBy + " descending");
}
int skip = (request.Page - 1) * request.PageSize;
int take = request.PageSize;
int totalItemCount = await source.CountAsync();
return(new Page <T>(await source.Skip(skip).Take(take).ToListAsync(), request.Page, request.PageSize, totalItemCount));
}
public async Task <PaginatedResult <JobDTO> > GetPagedData(PagedRequest pagedRequest, IMapper mapper, int UserId)
{
var result = _dbContext.Set <Job>().Where(x => x.UserId == UserId).CreatePaginatedResultAsync <Job, JobDTO>(pagedRequest, mapper, UserId);
return(await result);
}
public async Task <PagedResult <InstallingSchemeInstalled> > GetSchemeInstalled([FromUri] PagedRequest <string> request)
{
return(await service.GetSchemeInstalled(request));
}
