/// <summary>
/// Search product by CategoryId
/// </summary>
public void SearchAsync_WithCateogoryId_ShouldSuccess()
{
var expected = new PaginationResponse <List <ProductModel> >(
new List <ProductModel>()
{
mapper.Map <ProductModel>(products.First())
},
1,
10
);
var searchInput = new SearchModel <ProductSearchModel>()
{
Data = new ProductSearchModel()
{
CategoryIds = new int[] { 2 }
}
};
var actual = productService.SearchAsync(1, searchInput).Result;
var actualJson = JsonConvert.SerializeObject(actual);
var expectJson = JsonConvert.SerializeObject(expected);
Assert.AreEqual(expectJson, actualJson);
}
/// <summary>
/// Получить отфильтрованный список слайдов
/// </summary>
/// <param name="request">фильтр</param>
/// <returns></returns>
public PaginationResponse <SliderEditModel> GetFilteredSlides(PaginationRequest <BaseFilter> request)
{
using (var db = new DataContext())
{
var query = db.Sliders.AsNoTracking()
.OrderByDescending(x => x.DateCreate) as IQueryable <Slider>;
var model = new PaginationResponse <SliderEditModel> {
Count = query.Count()
};
if (request.Skip.HasValue)
{
query = query.Skip(request.Skip.Value);
}
if (request.Take.HasValue)
{
query = query.Take(request.Take.Value);
}
model.Items = query.Select(x => new SliderEditModel
{
Id = x.Id,
DateCreate = x.DateCreate,
PhotoUrl = x.PhotoUrl,
IsActive = x.IsActive
}).ToList();
return(model);
}
}
public async Task <PaginationResponse <T> > GetAdditionalDataAsStringAsync(string otherType, string otherId)
{
Items = new PaginationResponse <T>();
var uri = new Uri(string.Format(
Constants.RestUrl + _type + "?" + otherType + "=" + otherId + "&" + _auth, string.Empty));
try
{
var response = await _client.GetAsync(uri);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
Items = JsonConvert.DeserializeObject <PaginationResponse <T> >(content);
}
}
catch (Exception ex)
{
Debug.WriteLine(@" ERROR {0}", ex.Message);
}
return(Items);
}
public void SearchAsync_WithInputProductCode_ShouldSuccess()
{
var expected = new PaginationResponse <List <ProductModel> >(
new List <ProductModel>()
{
mapper.Map <ProductModel>(products.Last())
},
1,
10
);
var searchInput = new SearchModel <ProductSearchModel>()
{
Data = new ProductSearchModel()
{
Name = "ASUS001"
}
};
var actual = productService.SearchAsync(1, searchInput).Result;
var actualJson = JsonConvert.SerializeObject(actual);
var expectJson = JsonConvert.SerializeObject(expected);
Assert.AreEqual(expectJson, actualJson);
}
public async Task <PaginationResponse <TModel> > GetListAsync()
{
var res = new PaginationResponse <TModel>();
try
{
res = await _restService.GetAllDataAsync();
}
catch (UnauthorizedAccessException e)
{
if (!_firstAuthFail)
{
return(res);
}
_firstAuthFail = !_firstAuthFail;
if (await RegenerateLoginToken())
{
res = await GetListAsync();
}
}
catch (Exception e)
{
Debug.WriteLine(@" ERROR {0}", e.Message);
}
return(res);
}
public IActionResult GetAssetList(
[FromQuery] string continuation,
[FromQuery] int take)
{
// until ASP.NET Core 2.1 data annotations on arguments do not work
if (take <= 0)
{
ModelState.AddModelError(nameof(take), "Must be greater than zero");
}
// kinda specific knowledge but there is no
// another way to ensure continuation token
if (!string.IsNullOrEmpty(continuation))
{
try
{
JsonConvert.DeserializeObject <TableContinuationToken>(CommonUtils.HexToString(continuation));
}
catch
{
ModelState.AddModelError(nameof(continuation), "Invalid continuation token");
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ToBlockchainErrorResponse()));
}
return(Ok(PaginationResponse.From(null,
Constants.Assets.Values.Select(v => v.ToAssetContract()).ToArray())));
}
/// <summary>
/// Получить список заказов
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public PaginationResponse <OrderAdmin.OrderHeaderModel> GetFilteredOrders(PaginationRequest <BaseFilter> request)
{
using (var db = new DataContext())
{
var query = db.OrderHeaders.AsNoTracking().Include(x => x.User.UserAddress)
.Where(x => !x.IsDelete.HasValue && x.Status != (int)EnumStatusOrder.Cart)
.OrderByDescending(x => x.DateCreate) as IQueryable <OrderHeader>;
//if (!string.IsNullOrEmpty(request.Filter.Term))
// query = query.Where(x => x.Code.ToLower().Contains(request.Filter.Term.ToLower()));
var model = new PaginationResponse <OrderAdmin.OrderHeaderModel> {
Count = query.Count()
};
query = request.Load(query);
model.Items = query.ToList().Select(x => new OrderAdmin.OrderHeaderModel
{
Id = x.Id,
DateCreate = x.DateCreate,
UserName = $"{x.User?.FirstName} {x.User?.LastName}",
StatusName = EnumService.GetEnumDescription((EnumStatusOrder)x.Status),
Amount = x.Amount
}).ToList();
return(model);
}
}
public async Task <PaginationResponse <ArticleViewModel> > QueryByPageAsync(ArticlePaginationParameter parameters)
{
var predicate = PredicateBuilder.New <Article>(true);
if (parameters.IsDraft.HasValue)
{
predicate.And(x => x.IsDraft == parameters.IsDraft);
}
var result = new PaginationResponse <ArticleViewModel> {
PageIndex = parameters.PageIndex, PageSize = parameters.PageSize
};
// TODO: 这里用扩展方法封装一下
var futureTotal = _context.Article.DeferredCount(predicate).FutureValue();
var futureList = _context.Article.Where(predicate)
.Select(x => new { x.Alias, x.CommentCount, x.Title, x.CreatedAt, x.Id, x.IsDraft, x.Digest, x.ViewCount, CategoryAlias = x.CategoryNavigation.Alias })
.OrderByDescending(x => x.CreatedAt)
.Skip(parameters.PageSize * parameters.PageIndex)
.Take(parameters.PageSize)
.Future();
result.Total = await futureTotal.ValueAsync();
result.List = _mapper.Map <IEnumerable <ArticleViewModel> >(await futureList.ToListAsync());
result.PageIndex = parameters.PageIndex;
result.PageSize = parameters.PageSize;
foreach (var i in result.List)
{
i.Path = GetArticleRoutePath(i);
}
return(result);
}
public async Task <IActionResult> Get(
[FromQuery] string continuation,
[FromQuery] int take)
{
// until ASP.NET Core 2.1 data annotations on arguments do not work
if (take <= 0)
{
ModelState.AddModelError(nameof(take), "Must be greater than zero");
}
// kinda specific knowledge but there is no
// another way to ensure continuation token
if (!string.IsNullOrEmpty(continuation))
{
try
{
JsonConvert.DeserializeObject <TableContinuationToken>(Utils.HexToString(continuation));
}
catch
{
ModelState.AddModelError(nameof(continuation), "Invalid continuation token");
}
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ToBlockchainErrorResponse()));
}
var result = await _blockchainService.GetBalancesAsync(continuation, take);
return(Ok(PaginationResponse.From(
result.continuation,
result.items.Select(b => b.ToWalletContract()).ToArray())));
}
public async Task <Result> List([FromQuery] AdminPartnerApplyListRequest request)
{
var page = request.Page;
var limit = request.Limit;
if (page <= 0)
{
page = 1;
}
if (limit <= 0)
{
limit = 10;
}
var queryable = _partnerApplyRepository.Query();
if (request.PartnerRole != null)
{
queryable = queryable.Where(e => e.PartnerRole == request.PartnerRole);
}
var totalRows = await queryable.CountAsync();
var partnerApplys = await queryable.OrderByDescending(e => e.Id).Skip((page - 1) * limit).Take(limit).ToListAsync();
var pagination = new PaginationResponse(page, totalRows, _mapper.Map <List <AdminPartnerApplyListResponse> >(partnerApplys));
return(Result.Ok(pagination));
}
public async Task <IActionResult> GetAsync(string sensorId, int skip = -1, int limit = -1)
{
IList <Blob> results;
if (string.IsNullOrEmpty(sensorId))
{
var sensors = await this.m_sensors.GetAsync(this.CurrentUser.ID).ConfigureAwait(false);
var data = await this.m_blobs.GetRangeAsync(sensors.ToList(), skip, limit).ConfigureAwait(false);
results = data.ToList();
}
else
{
var data = await this.m_blobs.GetAsync(sensorId, skip, limit).ConfigureAwait(false);
results = data.ToList();
}
var response = new PaginationResponse <Blob> {
Data = new PaginationResult <Blob> {
Count = results.Count,
Limit = limit,
Skip = skip,
Values = results
}
};
return(this.Ok(response));
}
/// <summary>
/// Получить список городов
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public PaginationResponse <DictionaryModel> GetFilteredCities(PaginationRequest <BaseFilter> request)
{
using (var db = new DataContext())
{
var query = db.Cities.AsNoTracking()
.OrderByDescending(x => x.Id) as IQueryable <City>;
if (!string.IsNullOrEmpty(request.Filter.Term))
{
query = query.Where(x => x.Name.ToLower().Contains(request.Filter.Term.ToLower()));
}
var model = new PaginationResponse <DictionaryModel> {
Count = query.Count()
};
query = request.Load(query);
model.Items = query.Select(x => new DictionaryModel
{
Id = x.Id,
Name = x.Name
}).ToList();
return(model);
}
}
/// <summary>
/// Получить список брендов для постранички
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public PaginationResponse <BlogModel> GetFilteredBlogs(PaginationRequest <BaseFilter> request)
{
using (var db = new DataContext())
{
var query = db.Blogs.AsNoTracking().Where(x => !x.IsDelete.HasValue)
.OrderByDescending(x => x.DateCreate).AsQueryable();
if (!string.IsNullOrEmpty(request.Filter.Term))
{
query = query.Where(x => x.Title.Contains(request.Filter.Term));
}
var model = new PaginationResponse <BlogModel> {
Count = query.Count()
};
query = request.Load(query);
model.Items = query.Select(x => new BlogModel
{
Id = x.Id,
DateCreate = x.DateCreate,
Title = x.Title,
KeyUrl = x.KeyUrl,
IsActive = x.IsActive,
PhotoUrl = x.PhotoUrl
}).ToList();
return(model);
}
}
public async Task <IActionResult> GetBalances([FromQuery, Required] int take, [FromQuery] string continuation)
{
if (take < 1)
{
return(BadRequest(ErrorResponse.Create("Invalid parameter").AddModelError("take", "Must be positive non zero integer")));
}
if (!string.IsNullOrEmpty(continuation))
{
try
{
JsonConvert.DeserializeObject <TableContinuationToken>(Utils.HexToString(continuation));
}
catch (JsonReaderException)
{
return(BadRequest(ErrorResponse.Create("Invalid parameter").AddModelError("continuation", "Must be valid continuation token")));
}
}
var padedResult = await _balanceService.GetBalances(take, continuation);
return(Ok(PaginationResponse.From(padedResult.Continuation, padedResult.Items.Select(p => new WalletBalanceContract
{
Address = p.Address,
Balance = MoneyConversionHelper.SatoshiToContract(p.BalanceSatoshi),
AssetId = Constants.Assets.BitcoinGold.AssetId,
Block = p.UpdatedAtBlockHeight
}).ToList().AsReadOnly())));
}
public async Task GivenListMembersHandler_WhenCallHandle_ShouldReturn()
{
// assign
var query = new ListMembersQuery
{
MemberName = "jack",
Pagination = new PaginationRequest
{
PageSize = 1,
PageNumber = 23
}
};
var result = new PaginationResponse <Member>
{
TotalPageNumber = 100,
Data = new List <Member>()
};
_memberService.ListMembers(query).Returns(result);
// act
var response = await _listMembersHandler.Handle(query, CancellationToken.None);
// assert
response.ShouldNotBeNull();
response.ShouldBe(result);
}
public static async Task <PaginationResponse <T> > GetHelper <T>(this IHttpService httpService, string url,
PaginationRequest request, string name)
{
string newURL = "";
if (url.Contains("?"))
{
newURL = $"{url}&page={request.Page}&quantityPerPage={request.QuantityPerPage}&name={name}";
}
else
{
newURL = $"{url}?page={request.Page}&quantityPerPage={request.QuantityPerPage}&name={name}";
}
var httpResponse = await httpService.Get <T>(newURL);
var totalAmountPages = int.Parse(httpResponse.HttpResponseMessage.Headers.GetValues("pagesQuantity").FirstOrDefault());
var paginatedResponse = new PaginationResponse <T>
{
Response = httpResponse.Response,
TotalAmountPages = totalAmountPages
};
return(paginatedResponse);
}
public async Task GivenAccountService_WhenCallListAccount_ShouldReturnAccounts()
{
// assign
var request = new ListAccountsQuery
{
AccountStatusId = AccountStatusIds.Active,
AccountNumber = "ZIP0111111111",
Pagination = new PaginationRequest
{
PageSize = 100,
PageNumber = 2
}
};
var response = new PaginationResponse <Account>
{
TotalPageNumber = 10,
Data = new List <Account>()
};
_accountDataAccessor.ListAll(request.Pagination, request.AccountStatusId, request.AccountNumber)
.Returns(response);
// act
var actualResponse = await _accountService.ListAccounts(request);
// assert
actualResponse.ShouldBe(response);
}
public async Task <ApiResponse> GetStockHistory(Pagination request = null)
{
try
{
request = request ?? new Pagination
{
page = request.page,
rowsPerPage = request.rowsPerPage
};
var stocks = dbContext.stocks
.Where(r => !r.deleted)
.OrderBy(r => r.lastUpdate);
var count = await stocks.CountAsync();
var pagination = new PaginationResponse
{
page = request.page,
pageCount = (int)Math.Ceiling(count * 1.0 / request.rowsPerPage),
rowCount = count,
rowsPerPage = request.rowsPerPage
};
var response = await stocks
.Skip(request.rowsPerPage *(request.page - 1))
.Take(request.rowsPerPage)
.ToListAsync();
return(pagination.CreateResponse(response));
}
catch (Exception e)
{
return((e.InnerException).Message.CreateResponse());
}
}
public async Task <Result> List([FromQuery] AdminGoodsOptionQueryRequest request)
{
var page = request.Page;
var limit = request.Limit;
if (page <= 0)
{
page = 1;
}
if (limit <= 0)
{
limit = 10;
}
var queryable = _goodsOptionRepository.Query();
if (!string.IsNullOrEmpty(request.Name))
{
queryable = queryable.Where(e => e.Name.Contains(request.Name));
}
var totalRows = await queryable.CountAsync();
var goodsOptions = await queryable.OrderByDescending(e => e.Id).Skip((page - 1) * limit).Take(limit).ToListAsync();
var pagination = new PaginationResponse(page, totalRows, _mapper.Map <List <AdminGoodsOptionResponse> >(goodsOptions));
return(Result.Ok(pagination));
}
public async Task <ApiResponse> GetCompanyList(Pagination request = null)
{
try
{
request = request ?? new Pagination
{
page = request.page,
rowsPerPage = request.rowsPerPage
};
var company = dbContext.companies
.Where(r => !r.deleted);
var count = await company.CountAsync();
var pagination = new PaginationResponse
{
page = request.page,
pageCount = (int)Math.Ceiling(count * 1.0 / request.rowsPerPage),
rowCount = count,
rowsPerPage = request.rowsPerPage
};
var response = await company
.Skip(request.rowsPerPage *(request.page - 1))
.Take(request.rowsPerPage)
.ToListAsync();
return(pagination.CreateResponse(response));
}
catch (Exception e)
{
return((e.InnerException).Message.CreateResponse());
}
}
private void PrintUsersDataTable(PaginationResponse <UserDto> paginated)
{
var headers = new List <string>()
{
"#", "Nombre", "Email", "TenantId", "TenantCode", "RoleCode", "Role", "Ult. Mod"
};
var data = new List <List <string> >();
foreach (var userDto in paginated.Data)
{
data.Add(new List <string>()
{
userDto.Id.ToString(),
userDto.Name,
userDto.Email,
userDto.Tenant.Id.ToString(),
userDto.Tenant.Code,
userDto.Role.Code,
userDto.Role.Name,
userDto.UpdatedAt.ToString("dd/MM/yyyy HH:mm:ss")
});
}
_commandUtil.PrintTable(headers, data);
var pages = "> " + paginated.CurrentPage +
" [P: 1 - " + paginated.LastPage +
"] [R: " + paginated.From + " - " + paginated.To + "]";
_commandUtil.PrintInfo(pages);
}
public async Task GivenMemberService_WhenCallListMember_ShouldReturnMembers()
{
// assign
var request = new ListMembersQuery
{
MemberName = "ja",
Pagination = new PaginationRequest
{
PageSize = 100,
PageNumber = 2
}
};
var response = new PaginationResponse <Member>
{
TotalPageNumber = 10,
Data = new List <Member>()
};
_memberDataAccessor.ListAll(request.Pagination, request.MemberName)
.Returns(response);
// act
var actualResponse = await _memberService.ListMembers(request);
// assert
actualResponse.ShouldBe(response);
}
public async Task <IActionResult> GetBalances([FromQuery] int take, [FromQuery] string continuation)
{
if (take < 1)
{
throw new ValidationApiException($"{nameof(take)} must be positive non zero integer");
}
if (!string.IsNullOrEmpty(continuation))
{
try
{
JsonConvert.DeserializeObject <TableContinuationToken>(Utils.HexToString(continuation));
}
catch (JsonReaderException)
{
throw new ValidationApiException($"{nameof(continuation)} must be valid continuation token");
}
}
var padedResult = await _balanceService.GetBalancesAsync(take, continuation);
return(Ok(PaginationResponse.From(padedResult.Continuation, padedResult.Items.Select(p =>
new WalletBalanceContract
{
Address = p.Address,
Balance = p.Balance.ToString(CultureInfo.InvariantCulture),
AssetId = p.AssetId,
Block = p.UpdatedAtBlockHeight
}).ToList().AsReadOnly())));
}
public async Task <IActionResult> ListRecipesV2(PaginationRequest paginationRequest)
{
var documentCursor = await schemaObjectsRepository.FindAsync(
Builders <BsonDocument> .Filter.Eq(
"@type",
"Recipe"
),
new FindOptions <BsonDocument, BsonDocument>
{
Limit = paginationRequest.Limit
}
)
.ConfigureAwait(false);
var documents = await documentCursor
.ToListAsync()
.ConfigureAwait(false);
var formattedDocs = documents.Select(d => HandleId(d)).ToArray();
var response = new PaginationResponse <BsonDocument>
{
Items = formattedDocs
};
return(Content(response.ToJson(), MediaTypeNames.Application.Json));
}
public async Task GivenListAccountsHandler_WhenCallHandle_ShouldReturn()
{
// assign
var query = new ListAccountsQuery
{
AccountStatusId = AccountStatusIds.Active,
AccountNumber = "123213",
Pagination = new PaginationRequest
{
PageSize = 1,
PageNumber = 23
}
};
var result = new PaginationResponse <Account>
{
TotalPageNumber = 100,
Data = new List <Account>()
};
_accountService.ListAccounts(query).Returns(result);
// act
var response = await _listAccountsHandler.Handle(query, CancellationToken.None);
// assert
response.ShouldNotBeNull();
response.ShouldBe(result);
}
/// <summary>
/// Получить список постов блога
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public PaginationResponse <BlogModel> GetBlogPostList(PaginationRequest request)
{
try
{
using (var db = new DataContext())
{
var query = db.Blogs.AsNoTracking().Where(x => x.IsActive && !x.IsDelete.HasValue)
.OrderByDescending(x => x.DateCreate).AsQueryable();
var model = new PaginationResponse <BlogModel>
{
Count = query.Count()
};
query = request.Load(query);
model.Items = query.Select(x => new BlogModel
{
Id = x.Id,
Title = x.Title,
PreviewContent = x.PreviewContent,
PhotoUrl = x.PhotoUrl,
KeyUrl = x.KeyUrl
}).ToList();
return(model);
}
}
catch (Exception ex)
{
return(new PaginationResponse <BlogModel>(EnumResponseStatus.Exception, ex.Message));
}
}
public async Task <IActionResult> GetBalances([FromQuery] int take, [FromQuery] string continuation)
{
if (take <= 0)
{
ModelState.AddModelError(nameof(take), "Must be greater than zero");
}
ModelState.IsValidContinuationToken(continuation);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ToErrorResponce()));
}
var padedResult = await _balanceService.GetBalances(take, continuation);
return(Ok(PaginationResponse.From(padedResult.Continuation, padedResult.Items.Select(p => new WalletBalanceContract
{
Address = p.Address,
Balance = MoneyConversionHelper.SatoshiToContract(p.BalanceSatoshi),
AssetId = Constants.Assets.LiteCoin.AssetId,
Block = p.UpdatedAtBlockHeight
}).ToList().AsReadOnly())));
}
public PaginationResponse <CategoryVM> GetDataWithPagination(PaginationRequest request)
{
SearchPaginationRequest <CategoryVM> nrequest = new SearchPaginationRequest <CategoryVM>(request);
PaginationResponse <CategoryVM> data = CategoryRepository.GetDataPaginated(nrequest);
return(data);
}
public PaginationResponse <TicketStatusVM> GetDataWithPagination(PaginationRequest request)
{
SearchPaginationRequest <TicketStatusVM> nrequest = new SearchPaginationRequest <TicketStatusVM>(request);
PaginationResponse <TicketStatusVM> data = TicketStatusRepository.GetDataPaginated(nrequest);
return(data);
}
public async Task <IActionResult> Get(PaginationRequest request)
{
IQueryable <ProductListDto> products = await Mediator.Send(new GetProductsQuery());
PaginationResponse response = products.ApplyPagination(request);
return(Ok(response));
}
