public async Task <ActionResult <sous_categorie> > GETAll()
{
var x = new GetAllQuery <Sous_Categorie>();
var result = await _mediator.Send(x);
return(Ok(result));
}
public Task <IEnumerable <UserAreaMicroSummary> > ExecuteAsync(GetAllQuery <UserAreaMicroSummary> query, IExecutionContext executionContext)
{
var areas = _userAreaRepository.GetAll().OrderBy(u => u.Name);
var results = Mapper.Map <IEnumerable <UserAreaMicroSummary> >(areas);
return(Task.FromResult(results));
}
public IActionResult GetOne([FromQuery] GetAllQuery query)
{
var handleType = typeof(IQueryHandler <,>).MakeGenericType(query.GetType(), typeof(List <DemoModel>));
dynamic QueryHandler = _context.Resolve(handleType);
return(new JsonResult(QueryHandler.execute((dynamic)query)));
}
public IEnumerable <WebDirectoryRoute> Execute(GetAllQuery <WebDirectoryRoute> query, IExecutionContext executionContext)
{
var allWebDirectories = Query().ToList();
var activeWebRoutes = Map(allWebDirectories);
return(activeWebRoutes);
}
public async Task <IActionResult> GetAll(CancellationToken cancellationToken = default)
{
var request = new GetAllQuery();
var result = await this.mediator.Send(request, cancellationToken);
return(result.ToActionResult());
}
public IEnumerable <PageTemplateMicroSummary> Execute(GetAllQuery <PageTemplateMicroSummary> query, IExecutionContext executionContext)
{
var dbResults = Query().ToList();
var results = Map(dbResults);
return(results);
}
public async Task <ActionResult <Vote> > GETAll()
{
var x = new GetAllQuery <Vote>();
var result = await _mediator.Send(x);
return(Ok(result));
}
public async Task <PagedList <T> > Handle(GetAllQuery <T> message)
{
var query = _db.Set <T>().AsNoTracking();
if (message.Where != null)
{
query = query.Where(message.Where);
}
int count = 0;
if (message.PageOption != null)
{
count = await query.CountAsync();
query = message.PageOption.Ascending
? query.OrderBy(message.PageOption.OrderBy)
: query.OrderByDescending(message.PageOption.OrderBy);
query = query
.Skip((message.PageOption.Page - 1) * message.PageOption.PageSize)
.Take(message.PageOption.PageSize);
}
if (message.Include != null)
{
query = query.Include(message.Include);
}
var entities = await query.ToListAsync();
return(new PagedList <T>(entities, message.PageOption?.Page ?? 0, message.PageOption?.PageSize ?? 0, count));
}
public async Task <IEnumerable <PageRoute> > ExecuteAsync(GetAllQuery <PageRoute> query, IExecutionContext executionContext)
{
return(await _pageCache.GetOrAddAsync(() =>
{
return GetAllPageRoutesAsync(query, executionContext);
}));
}
public IEnumerable <PageRoute> Execute(GetAllQuery <PageRoute> query, IExecutionContext executionContext)
{
return(_pageCache.GetOrAdd(() =>
{
return GetAllPageRoutes(query, executionContext);
}));
}
public async Task <ActionResult <Demande_information> > GETAll()
{
var x = new GetAllQuery <Demande_information>();
var result = await _mediator.Send(x);
return(Ok(result));
}
public async ValueTask <IEnumerable <Awesome> > GetAllAsync([FromQuery] GetAllQuery query, CancellationToken cancellationToken)
{
_logger.LogInformation("get all awesomes");
var entities = await _mediator.Send(query, cancellationToken);
return(entities);
}
public async Task <IEnumerable <PageTemplateMicroSummary> > ExecuteAsync(GetAllQuery <PageTemplateMicroSummary> query, IExecutionContext executionContext)
{
var dbResults = await Query().ToListAsync();
var results = Map(dbResults);
return(results);
}
public async Task <IEnumerable <WebDirectoryRoute> > ExecuteAsync(GetAllQuery <WebDirectoryRoute> query, IExecutionContext executionContext)
{
var allWebDirectories = await Query().ToListAsync();
var activeWebRoutes = Map(allWebDirectories);
return(activeWebRoutes);
}
public async Task Handle_ReturnTwoRecords_WhenRun()
{
var query = new GetAllQuery();
var handler = new GetAllQuery.GetAllQueryHandler(_configConstants, _mapper, _unitOfWork);
var result = await handler.Handle(query, CancellationToken.None);
result.TenderList.Count().ShouldBe(2);
}
public async Task <ICollection <PropertyDto> > Handle(GetAllQuery request, CancellationToken cancellationToken)
{
var properties = await _context.Properties
.ProjectTo <PropertyDto>(_mapper.ConfigurationProvider)
.ToListAsync(cancellationToken);
return(properties);
}
public async Task Handle_ReturnCorrectVM()
{
var query = new GetAllQuery();
var handler = new GetAllQuery.GetAllQueryHandler(_configConstants, _mapper, _unitOfWork);
var result = await handler.Handle(query, CancellationToken.None);
result.ShouldBeOfType <TenderVM>();
}
public IEnumerable <ActiveLocale> Execute(GetAllQuery <ActiveLocale> query, IExecutionContext executionContext)
{
var results = _cache.GetOrAdd(() =>
{
return(GetAllLocales().ToArray());
});
return(results);
}
public async Task <IEnumerable <PageModuleTypeSummary> > ExecuteAsync(GetAllQuery <PageModuleTypeSummary> query, IExecutionContext executionContext)
{
return(await _moduleCache.GetOrAddAsync(() =>
{
var results = Query().ToArrayAsync();
return results;
}));
}
public async Task <IEnumerable <RewriteRuleSummary> > ExecuteAsync(GetAllQuery <RewriteRuleSummary> query, IExecutionContext executionContext)
{
var rules = await _cache.GetOrAddAsync(() =>
{
return(Query().ToArrayAsync());
});
return(rules);
}
public IEnumerable <RewriteRuleSummary> Execute(GetAllQuery <RewriteRuleSummary> query, IExecutionContext executionContext)
{
var rules = _cache.GetOrAdd(() =>
{
return(Query().ToArray());
});
return(rules);
}
public Task <IEnumerable <IPermission> > ExecuteAsync(GetAllQuery <IPermission> query, IExecutionContext executionContext)
{
var permissions = _permissionRepository
.GetAll()
.OrderBy(p => GetPrimaryOrdering(p))
.AsEnumerable();
return(Task.FromResult(permissions));
}
public IEnumerable <PageModuleTypeSummary> Execute(GetAllQuery <PageModuleTypeSummary> query, IExecutionContext executionContext)
{
return(_moduleCache.GetOrAdd(() =>
{
var results = Query().ToArray();
return results;
}));
}
public async Task <IEnumerable <ActiveLocale> > ExecuteAsync(GetAllQuery <ActiveLocale> query, IExecutionContext executionContext)
{
var results = await _cache.GetOrAddAsync(new Func <Task <ActiveLocale[]> >(async() =>
{
return(await GetAllLocales().ToArrayAsync());
}));
return(results);
}
public async Task <IImmutableList <Awesome> > Handle(GetAllQuery query, CancellationToken cancellationToken)
{
var queryable = _readableAwesomeDbContext.Awesomes;
queryable = _sieveProcessor.Apply(query, queryable);
var entities = await queryable.ToListAsync(cancellationToken);
return(entities.ToImmutableList());
}
public IEnumerable <ICustomEntityRoutingRule> Execute(GetAllQuery <ICustomEntityRoutingRule> query, IExecutionContext executionContext)
{
var duplicateRule = _customEntityRoutingRules.GroupBy(r => r.RouteFormat).FirstOrDefault(g => g.Count() > 1);
if (duplicateRule != null)
{
throw new ApplicationException("Multiple handlers cannot exist using the same RouteFormat. Duplicate: " + duplicateRule.Key);
}
return(_customEntityRoutingRules);
}
public async Task <IActionResult> Get([FromQuery] GetAllQuery request)
{
var currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
request.CurrentUserId = currentUserId;
var userPagination = await Mediator.Send(request);
Response.AddPagination(userPagination.CurrentPage, userPagination.ItemsPerPage, userPagination.TotalItems, userPagination.TotalPages);
return(Ok(userPagination.Users));
}
public IEnumerable <PageGroupSummary> Execute(GetAllQuery <PageGroupSummary> query, IExecutionContext executionContext)
{
var results = _dbContext
.PageGroups
.AsNoTracking()
.Where(g => !g.IsDeleted)
.OrderBy(m => m.GroupName)
.ProjectTo <PageGroupSummary>()
.ToList();
return(results);
}
private PageRoute[] GetAllPageRoutes(GetAllQuery <PageRoute> query, IExecutionContext executionContext)
{
// Queries
var dbPages = QueryPages().ToList();
var dbPageVersions = QueryPageVersions().ToList();
var webDirectories = _queryExecutor.GetAll <WebDirectoryRoute>(executionContext).ToDictionary(d => d.WebDirectoryId);
var templates = GetPageTemplates().ToDictionary(t => t.PageTemplateId);
var routes = Map(dbPages, dbPageVersions, webDirectories, templates, executionContext);
return(routes.ToArray());
}
public List <DemoModel> execute(GetAllQuery query)
{
//repo.getall
return(new List <DemoModel>
{
new DemoModel {
Id = 0, Name = "Matt"
},
new DemoModel {
Id = 1, Name = "Yang"
}
});
}