public async Task <List <DomainReservation> > QueryReservations(QueryReservationCommand cmd)
{
var query = new ReservationQuery();
if (cmd.UserId.HasValue)
{
query.ForOwner(await _users.FindById(cmd.UserId.Value));
}
if (cmd.ResourceId.HasValue)
{
query.ForResource(await _resources.FindById(cmd.ResourceId.Value));
}
query.CollideWith(
cmd.StartTime.GetValueOrDefault(Instant.FromUnixTimeMilliseconds(0)),
cmd.EndTime.GetValueOrDefault(Instant.MaxValue)
);
if (cmd.StatusList != null && cmd.StatusList.Length > 0)
{
query.WithStatuses((await _statuses.All()).Where(st => cmd.StatusList.Contains(st.Status)));
}
return((await _reservations.Query(query))
.Select(r => _mapper.Map <DomainReservation>(r))
.ToList());
}
public Task <List <Reservation> > Execute(ReservationQuery query)
{
return(ctx.Reservations
.Include(x => x.Vendor)
.Include(x => x.Expense)
.Where(x => query.Id == null || x.Id == query.Id)
.ToListAsync());
}
public async Task <List <Reservation> > GetAllReturnsAsync(ReservationQuery query)
{
var bson = query.name != null?BsonDocument.Parse(query.name) : new BsonDocument();
return(await _context.Reservations
.Find(ReturnsCar())
.SortBy(res => res.DateTo)
.ToListAsync());
}
public async Task <IActionResult> GetAll(int rid)
{
await Db.Connection.OpenAsync();
var query = new ReservationQuery(Db);
var result = await query.GetAll(rid);
return(new OkObjectResult(result));
}
private async Task <ICollection <Reservation> > GetCollisionsFor(Resource resource, Instant start, Instant end)
{
var statuses = await _statuses.All();
statuses.RemoveAll(s => s.Status == DomainReservationStatus.Denied);
var query = new ReservationQuery()
.ForResource(resource)
.WithStatuses(statuses)
.CollideWith(start, end);
return(await _reservations.Query(query));
}
public async Task <IActionResult> GetOneReservation(int id)
{
await Db.Connection.OpenAsync();
var query = new ReservationQuery(Db);
var result = await query.GetOneReservation(id);
if (result is null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(result));
}
public async Task <IHttpActionResult> GetReservation([FromUri] ReservationQuery query)
{
var result = await ItineraryReservationRepository.GetByQuery(query);
var items = new List <ReservationViewModel>();
foreach (var reservation in result.Items)
{
items.Add(BuildViewModel(reservation));
}
return(Ok(new { result.TotalItem, items }));
}
public async Task QueryOnlyReturnsForTheSpecifiedUser()
{
using var data = await TestData.Init(Fixture, MockTime);
var query = new ReservationQuery()
.ForOwner(await Fixture.Users.FindById(1));
var onlyUser1Query = await Fixture.Reservations.Query(query);
Assert.Collection(onlyUser1Query,
r => Assert.Equal(r, data.Reservation1),
r => Assert.Equal(r, data.Reservation2)
);
Fixture.Database.Ctx.RemoveRange(data.Reservation1, data.Reservation2, data.Reservation3);
}
public async Task QueryReturnsForAllUsers()
{
using var data = await TestData.Init(Fixture, MockTime);
var query = new ReservationQuery();
var onlyUser1Query = await Fixture.Reservations.Query(query);
Assert.Collection(onlyUser1Query,
r => Assert.Equal(r, data.Reservation1),
r => Assert.Equal(r, data.Reservation2),
r => Assert.Equal(r, data.Reservation3)
);
Fixture.Database.Ctx.RemoveRange(data.Reservation1, data.Reservation2, data.Reservation3);
}
public async Task QueryFiltersBasedOnStatus4()
{
Assert.Empty(Fixture.Reservations.All().Result);
using var data = await TestData.Init(Fixture, MockTime);
var query = new ReservationQuery()
.WithStatuses(new[]
{
await Fixture.ReservationStatuses.ById(4),
});
var result = await Fixture.Reservations.Query(query);
Assert.Empty(result);
}
public IActionResult Get([FromQuery] ReservationQuery query)
{
try
{
return(Ok(getReservations.Execute(query)));
}
catch (Exception e)
{
return(StatusCode(500, new
{
Errors = new List <string> {
e.Message
}
}));
}
}
public async Task <QueryResult <ItineraryReservation> > GetByQuery(ReservationQuery query, bool isInclude = true)
{
var queryable = _context.ItineraryReservations.AsQueryable();
var result = new QueryResult <ItineraryReservation>
{
TotalItem = await queryable.CountAsync()
};
if (query != null)
{
// Apply filtering
// Apply ordering
queryable = query.IsSortAscending ? queryable.OrderBy(x => x.ReservationDate) : queryable.OrderByDescending(x => x.ReservationDate);
// Apply paging
var page = query.Page;
var size = query.PageSize;
if (page <= 0)
{
page = 1;
}
if (size <= 0)
{
size = 5;
}
queryable = queryable.Skip((page - 1) * size).Take(size);
}
if (isInclude)
{
queryable = queryable.Include(x => x.Agent)
.Include(x => x.Passenger)
.Include(x => x.TravelClass)
.Include(x => x.TicketType)
.Include(x => x.ReservationStatus);
}
result.Items = await queryable.ToListAsync();
return(result);
}
public async Task QueryReturnsInsideOfRange(double startHours, double endHours)
{
// *---- current reservation ----*
// * ---- overlap ------*
Assert.Empty(Fixture.Reservations.All().Result);
using var data = await TestData.Init(Fixture, MockTime);
var query = new ReservationQuery()
.CollideWith(
MockTime.GetCurrentInstant().Plus(Duration.FromHours(startHours)),
MockTime.GetCurrentInstant().Plus(Duration.FromHours(endHours))
);
var result = await Fixture.Reservations.Query(query);
Assert.Contains(result, r => r.Equals(data.Reservation1));
}
public async Task QueryFiltersBasedOnStatus1and2and4()
{
Assert.Empty(Fixture.Reservations.All().Result);
using var data = await TestData.Init(Fixture, MockTime);
var query = new ReservationQuery()
.WithStatuses(new[]
{
await Fixture.ReservationStatuses.ById(1),
await Fixture.ReservationStatuses.ById(2),
await Fixture.ReservationStatuses.ById(4),
});
var result = await Fixture.Reservations.Query(query);
Assert.Collection(result,
r => Assert.Equal(data.Reservation1, r),
r => Assert.Equal(data.Reservation2, r)
);
}
public async Task QueryReturnsOverlapOfRange(int startHours, int endHours)
{
// *---- current reservation ----*
// * ----------------------- overlap ------*
Assert.Empty(Fixture.Reservations.All().Result);
using var data = await TestData.Init(Fixture, MockTime);
var query = new ReservationQuery()
.CollideWith(
MockTime.GetCurrentInstant().Plus(Duration.FromHours(startHours)),
MockTime.GetCurrentInstant().Plus(Duration.FromHours(endHours))
);
var result = await Fixture.Reservations.Query(query);
Assert.Collection(result,
r => Assert.Equal(data.Reservation1, r),
r => Assert.Equal(data.Reservation2, r),
r => Assert.Equal(data.Reservation3, r)
);
}
public async Task <ActionResult <List <Reservation> > > GetAsync([FromQuery] ReservationQuery query)
{
return(await _reservationRepository.GetAllReservationsAsync(query));
}
public PagedResponse <ReservationDto> Execute(ReservationQuery request)
{
var query = Context.Reservations
.Include(u => u.User)
.Include(rs => rs.ReservationSeats)
.ThenInclude(s => s.Seat)
.ThenInclude(h => h.Hall)
.Include(p => p.Projection)
.ThenInclude(m => m.Movie)
.AsQueryable();
query = query.Where(x => x.IsDeleted == false);
query = query.Where(x => x.Projection.DateEnd > DateTime.Now);
if (request.StartTime != null)
{
query = query.Where(x => x.Projection.DateBegin > request.StartTime);
}
if (request.ProjectionId != 0)
{
query = query.Where(x => x.ProjectionId == request.ProjectionId);
}
if (request.HallId != 0)
{
query = query.Where(x => x.ReservationSeats.Any(s => s.Seat.HallId == request.HallId));
}
if (request.UserId != 0)
{
query = query.Where(x => x.UserId == request.UserId);
}
if (request.Username != null)
{
query = query.Where(x => x.User.Username.ToLower().Contains(request.Username.ToLower()));
}
if (request.MovieId != 0)
{
query = query.Where(x => x.Projection.MovieId == request.MovieId);
}
var totalCount = query.Count();
query = query.Skip((request.PageNumber - 1) * request.PerPage).Take(request.PerPage);
var pagesCount = (int)Math.Ceiling((double)totalCount / request.PerPage);
return(new PagedResponse <ReservationDto>
{
CurrentPage = request.PageNumber,
PagesCount = pagesCount,
TotalCount = totalCount,
Data = query.Select(x => new ReservationDto
{
Id = x.Id,
ProjectionId = x.ProjectionId,
MovieId = x.Projection.MovieId,
UserId = x.UserId,
Username = x.User.Username,
HallId = x.Projection.HallId,
MovieName = x.Projection.Movie.Title,
SeatsInfo = x.ReservationSeats.Select(s => new ReservationSeatDto
{
SeatId = s.Seat.Id,
SeatNumber = s.Seat.Number,
SeatBroken = s.Seat.IsBroken,
SeatHallId = s.Seat.HallId,
SeatName = s.Seat.Name
}),
ProjectionBegin = x.Projection.DateBegin,
ProjectionEnd = x.Projection.DateEnd
})
});
}
public Task <List <Reservation> > Query(ReservationQuery query)
{
return(query.RunQuery(_ctx).ToListAsync());
}
