public async Task <IActionResult> GetTicketsAsync(TicketSearchRequest req)
{
StringValues jwtToken;
try
{
Request.Headers.TryGetValue(Constants.JWTTokenHeader, out jwtToken);
}
catch
{
// Forbidden
return(Forbid(Constants.UnauthorizedRequest));
}
TicketDAO ticketDAO = new TicketDAO(Constants.SQLConnection);
TicketService ticketService = new TicketService(ticketDAO);
AuthorizationService authorizationService = new AuthorizationService();
UserDAO userDAO = new UserDAO(Constants.SQLConnection);
SessionService sessionService = new SessionService(userDAO, authorizationService);
AuthorizationManager authorizationManager = new AuthorizationManager(authorizationService, sessionService);
TicketManager ticketManager = new TicketManager(ticketService, authorizationManager);
Result <List <TicketRecord> > tickets = await ticketManager.GetTicketsAsync(jwtToken, req.filterParams);
return(Ok(tickets));
}
public Task SaveLastSearchAsync(TicketSearchRequest request, string userId)
{
var searchEntity = _mapper.Map <TicketSearchEntity>(request);
searchEntity.UserId = userId;
return(_historyRepository.SaveLastSearchAsync(searchEntity));
}
public async Task <IActionResult> SearchTickets(TicketSearchRequest request)
{
await PublishSearchQueryLogMessage(request);
SearchResult <TicketInfo> result = await _ticketService.Search(request, GetUserId());
return(Ok(result));
}
public async Task <SearchResult <TicketInfo> > Search(TicketSearchRequest request, string userId)
{
if (!string.IsNullOrEmpty(userId))
{
await _historyService.SaveLastSearchAsync(request, userId);
}
return(await _ticketRepository.SearchAsync(request));
}
private Task PublishSearchQueryLogMessage(TicketSearchRequest request)
{
return(_bus.PublishAsync(new SearchQueryLogMessage
{
UserId = GetUserId(),
SearchCriterium = request.Name,
FilterInfo = JsonConvert.SerializeObject(request, new JsonSerializerSettings
{
DefaultValueHandling = DefaultValueHandling.Ignore
})
}));
}
public List <Data.Model.Ticket> Get(TicketSearchRequest req)
{
var query = _context.Tickets.AsQueryable();
if (req.ScheduleID.HasValue)
{
query = query.Where(t => t.ScheduleID == req.ScheduleID);
}
var list = query.ToList();
return(_mapper.Map <List <Data.Model.Ticket> >(list));
}
public List <Data.Model.Ticket> Get([FromQuery] TicketSearchRequest req)
{
return(_service.Get(req));
}
public async Task <Tuple <List <TicketViewModel>, int> > Search(TicketSearchRequest data)
{
return(await(_dbContext as Model.PunnelContext).msp_Ticket_Search(data));
}
public async Task<SearchResult<TicketInfo>> SearchAsync(TicketSearchRequest request)
{
var result = await _client.SearchAsync<TicketInfo>(descriptor => descriptor
.Index(nameof(TicketInfo).ToLowerInvariant())
.Type(nameof(TicketInfo))
.Query(BuildQuery)
.From(request.Offset)
.Size(request.Limit));
return new SearchResult<TicketInfo>
{
Items = result.Documents,
Total = (int)result.Total
};
QueryContainer BuildQuery(QueryContainerDescriptor<TicketInfo> q)
{
var queries = new List<QueryContainer>();
if (request.DateFrom != null)
{
queries.Add(q.DateRange(d => d
.Field(t => t.Date)
.GreaterThanOrEquals(request.DateFrom.Value)));
}
if (request.DateTo != null)
{
queries.Add(q.DateRange(d => d
.Field(t => t.Date)
.LessThan(request.DateTo.Value.AddDays(1))));
}
if (request.MinPrice != null)
{
queries.Add(q.Range(d => d
.Field(t => t.Price)
.GreaterThanOrEquals((double)request.MinPrice.Value)));
}
if (request.MaxPrice != null)
{
queries.Add(q.Range(d => d
.Field(t => t.Price)
.LessThanOrEquals((double)request.MaxPrice.Value)));
}
if (request.Category != null)
{
queries.Add(q.Match(d => d
.Field(t => t.Category)
.Query(request.Category)));
}
if (request.City != null)
{
queries.Add(q.Match(d => d
.Field(t => t.City)
.Query(request.City)));
}
if (request.Name != null)
{
queries.Add(q.Fuzzy(d => d
.Field(t => t.Name)
.Value(request.Name.ToLowerInvariant())
.Fuzziness(Fuzziness.Auto)
.Transpositions()
));
}
if (queries.Count > 0)
{
return q.Bool(b => b.Must(queries.ToArray()));
}
return q.MatchAll();
}
}
