public async Task CallAction_CreateQuery() { var hypermediaObjectRegister = CreateHypermediaObjectRegister(); var sirenClient = new SirenHttpHypermediaClient <EntryPointHco>(ApiEntryPoint, hypermediaObjectRegister); var apiRoot = await sirenClient.EnterAsync(); var customersRoot = await apiRoot.NavigateAsync(l => l.Customers); var query = new CustomersQuery { Filter = new CustomerFilter { MinAge = 22 }, SortBy = new SortOptions { PropertyName = "Age", SortType = "Ascending" }, Pagination = new Pagination { PageOffset = 2, PageSize = 3 } }; var resultResource = await customersRoot.CreateQuery.ExecuteAsync(query); var queryResultPage = await resultResource.ResultLocation.ResolveAsync(); }
public async Task CallAction_CreateQuery() { var apiRoot = await this.Resolver.ResolveLinkAsync <EntryPointHco>(ApiEntryPoint); var customersRoot = await apiRoot.NavigateAsync(l => l.Customers); var query = new CustomersQuery { Filter = new CustomerFilter { MinAge = 22 }, SortBy = new SortOptions { PropertyName = "Age", SortType = "Ascending" }, Pagination = new Pagination { PageOffset = 2, PageSize = 3 } }; var resultResource = await customersRoot.ResultObject.CreateQuery.ExecuteAsync(query, this.Resolver); var queryResultPage = await resultResource.ResultLocation.ResolveAsync(); Assert.IsNotNull(queryResultPage); }
public async Task <IEnumerable <CustomerServiceResult> > GetCustomersAsync(CustomersQuery qp) { try { // Here I list the query result from cache if they exist, but now the data can vary according to the category ID, page and amount of // items per page. I have to compose a cache to avoid returning wrong data. string cacheKey = GetCacheKeyForCustomersQuery(qp); var entities = await _cache.GetOrCreateAsync(cacheKey, (entry) => { entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(1); return(_customersRepository.ListPaginationAsync(qp)); }); var models = entities != null && entities.Any() ? _mapper.Map(entities, new List <CustomerServiceResult>()) : new List <CustomerServiceResult>(); return(models); } catch (Exception ex) { _logger?.LogError(ex.ToString()); throw; } }
public string PageQuery([FromBody] CustomersQuery query) { Thread.Sleep(1000); var list = CustomersService.PagerQuery(query); return(Util.Helpers.Json.ToJson(list)); }
public async Task <IEnumerable <Customer> > ListPaginationAsync(CustomersQuery query) { // AsNoTracking tells EF Core it doesn't need to track changes on listed entities. Disabling entity // tracking makes the code a little faster IQueryable <Customer> queryable = _customers .AsNoTracking(); if (!string.IsNullOrEmpty(query.Search)) { queryable = queryable.Where(p => (p.FirstName + " " + p.LastName + " " + p.Address + " " + p.PhoneNumber + " " + p.Email).ToLower().Contains(query.Search.ToLower())); } // Here I apply a simple calculation to skip a given number of items, according to the current page and amount of items per page, // and them I return only the amount of desired items. The methods "Skip" and "Take" do the trick here. if (query.Limit.HasValue && query.Offset.HasValue) { queryable = queryable.Skip(query.Offset.Value) .Take(query.Limit.Value); } return(await queryable.ToListAsync()); }
public int Customers_GetCount(string serializedQuery) { CustomersQuery query = CustomersQuery.SerializeHelper.FromXml( serializedQuery, typeof(CustomersQuery), AllKnownTypes) as CustomersQuery; return(query.ExecuteScalar <int>()); }
public async Task <List <Customer> > Handle(CustomersQuery request, CancellationToken cancellationToken) { var customers = request.IsActive == null ? await _repository.GetCustomersAsync() : await _repository.GetCustomersAsync(c => c.IsActive == (bool)request.IsActive); return(customers); }
public async Task <IEnumerable <Contact> > GetContactsAsync(Guid id) { var query = new CustomersQuery { FilterIds = id.Collect() }; return((await _queryInvoker.Execute <CustomersQuery, Customer>(query)).SingleOrDefault()?.Contacts); }
public async Task <Customer> GetAsync(Guid id) { var query = new CustomersQuery { FilterIds = id.Collect() }; return((await _queryInvoker.Execute <CustomersQuery, Customer>(query)).SingleOrDefault()); }
public async Task ShouldReturnCustomerListForValidCountry(IQueryHandler <CustomersQuery, Customer[]> queryHandler) { var query = new CustomersQuery { Country = "Germany" }; var result = await queryHandler.HandleAsync(query); result.ShouldNotBeEmpty(); }
public async Task <IActionResult> All([FromQuery] CustomersQuery query) { var model = await _mediator.Send(query); return(new ObjectResult(model) { StatusCode = (int)HttpStatusCode.OK }); }
public async Task ShouldReturnEmptyListForUnknownCountry(IQueryHandler <CustomersQuery, Customer[]> queryHandler) { var query = new CustomersQuery { Country = "Fantasyland" }; var result = await queryHandler.HandleAsync(query); result.ShouldBeEmpty(); }
public async Task ShouldGetCustomersFromGermany(IQueryExecutor queryExecutor) { var query = new CustomersQuery { Country = "Germany" }; var result = await queryExecutor.ExecuteAsync(query); Assert.Equal(11, result.Length); }
public CustomersCollection Customers_LoadByDynamic(string serializedQuery) { CustomersQuery query = CustomersQuery.SerializeHelper.FromXml( serializedQuery, typeof(CustomersQuery), AllKnownTypes) as CustomersQuery; CustomersCollection coll = new CustomersCollection(); coll.es.IsLazyLoadDisabled = true; coll.Load(query); return(coll); }
private string GetCacheKeyForCustomersQuery(CustomersQuery query) { string key = CacheKeys.CustomersList.ToString(); if (!string.IsNullOrEmpty(query.Search)) { key = string.Concat(key, "_", query.Search); } key = string.Concat(key, "_", query.Limit, "_", query.Offset); return(key); }
public Task <PaginatedList <CustomersQueryDto> > Handle(CustomersQuery request, CancellationToken cancellationToken) { return(_unitOfWork.CustomerRepository.GetAll() .Select(x => new CustomersQueryDto() { Id = x.Id, Name = x.PersonalInfo.Name, Surname = x.PersonalInfo.Surname, Email = x.PersonalInfo.Email, Nationality = x.PersonalInfo.Nationality, PhoneNumber = x.PersonalInfo.PhoneNumber }) .AsPaginatedList(request.GetPagingElements())); }
public CustomersProxyStub Customers_QueryForEntity(string serializedQuery) { CustomersQuery query = CustomersQuery.SerializeHelper.FromXml( serializedQuery, typeof(CustomersQuery), AllKnownTypes) as CustomersQuery; Customers obj = new Customers(); if (obj.Load(query)) { return(obj); } return(null); }
public CustomersCollectionProxyStub Customers_QueryForCollection(string serializedQuery) { CustomersQuery query = CustomersQuery.SerializeHelper.FromXml( serializedQuery, typeof(CustomersQuery), AllKnownTypes) as CustomersQuery; CustomersCollection coll = new CustomersCollection(); if (coll.Load(query)) { return(coll); } return(null); }
public async Task <IActionResult> GetCustomers([FromQuery] CustomersQuery customersQuery) { if (customersQuery == null) { return(BadRequest()); } var result = await _mediator.Send(customersQuery); if (customersQuery.Invalid) { return(new BadRequestObjectResult(result)); } return(new OkObjectResult(result)); }
public async Task QueryInvokerShouldResolveQueryHandler() { var customers = Bogus.CustomerFaker.Generate(3); _dbContext.AddRange(customers); _dbContext.SaveChanges(); var queryInvoker = Root.Container.GetInstance <IQueryInvoker>(); var query = new CustomersQuery { FilterIds = customers[0].Id.Collect() }; var response = await queryInvoker.Execute <CustomersQuery, Customer>(query); Assert.That(response.Count, Is.EqualTo(1)); Assert.That(response[0], Is.EqualTo(customers[0])); query = new CustomersQuery { FilterNameLike = customers[0].Name }; response = await queryInvoker.Execute <CustomersQuery, Customer>(query); Assert.That(response.Count, Is.EqualTo(1)); Assert.That(response[0], Is.EqualTo(customers[0])); query = new CustomersQuery { FilterIds = new[] { customers[0].Id, customers[1].Id } }; response = await queryInvoker.Execute <CustomersQuery, Customer>(query); Assert.That(response.Count, Is.EqualTo(2)); Assert.That(response, Is.EquivalentTo(new[] { customers[0], customers[1] })); response = await queryInvoker.Execute <CustomersQuery, Customer>(new CustomersQuery()); Assert.That(response.Count, Is.EqualTo(customers.Count)); Assert.That(response, Is.EquivalentTo(customers)); }
public async Task <IEnumerable <Customer> > GetAsync([FromQuery] string nameLike, [FromQuery] CustomerType?typeExact, [FromQuery] string countryExact, [FromQuery] string provinceExact, [FromQuery] string cityExact, int?take, int?skip, string orderBy, string orderMode) //ToDo:4 optionally include archived? { var query = new CustomersQuery { Take = take, Skip = skip, OrderBy = orderBy, OrderMode = orderMode, FilterNameLike = nameLike, FilterCustomerTypeExact = typeExact, FilterCountryExact = countryExact, FilterProvinceExact = provinceExact, FilterCityExact = cityExact }; //ToDo:2 query.AsLazy(); ?? return(await _queryInvoker.Execute <CustomersQuery, Customer>(query)); }
public async Task <PaginatedList <CustomersQueryDto> > GetCustomers([FromQuery] CustomersQuery query) => await Mediator.Send(query);
public IActionResult GetCustomers(CustomersQuery customersQuery) { var result = _processor.Get(customersQuery); return(Ok(new { result.Items, result.Total })); }
//[Authorize(Roles = "user")] public async Task <IEnumerable <CustomerDto> > Customers([FromQuery] CustomersQuery customersQuery) { return(await _mediator.Send(customersQuery)); }
public async Task ShouldReturnEmptyListForUnknownCountry(IQueryHandler<CustomersQuery, Customer[]> queryHandler) { var query = new CustomersQuery { Country = "Fantasyland" }; var result = await queryHandler.HandleAsync(query); result.ShouldBeEmpty(); }
public async Task ShouldReturnCustomerListForValidCountry(IQueryHandler<CustomersQuery, Customer[]> queryHandler) { var query = new CustomersQuery { Country = "Germany" }; var result = await queryHandler.HandleAsync(query); result.ShouldNotBeEmpty(); }
public PagedResult <CustomerItem> Handle(CustomersQuery query) { return(_archContext.Customers.GetPagedResult <Domain.Entities.Customer, CustomerItem>(_mapper, query.Paging)); }
public Task <IEnumerable <CustomerDto> > Handle(CustomersQuery request, CancellationToken cancellationToken) { var customers = _customerDomain.GetAll(); return(Task.FromResult(customers.MapTo <IEnumerable <CustomerDto> >())); }