private async Task <bool> IsRightTimePosition(Reservation reservation)
{
var filter = new ReservationFilter
{
Day = reservation.Date.Date,
TableId = reservation.TableId
};
var allReservationOfDay = await reservationDbProvider.ReadModel(filter).ConfigureAwait(false);
if (allReservationOfDay.Count == 0)
{
filter.Day = filter.Day.Value.AddDays(-1);
allReservationOfDay = await reservationDbProvider.ReadModel(filter).ConfigureAwait(false);
}
var endRes = reservation.EndDate;
foreach (var currentRes in allReservationOfDay)
{
if (currentRes.TableId == reservation.TableId &&
!((currentRes.Date < reservation.Date && currentRes.EndDate < reservation.Date) ||
(currentRes.Date > reservation.Date && currentRes.EndDate > reservation.Date)))
{
return(false);
}
}
return(true);
}
public List <Reservation> GetReservationByName(ReservationFilter reservationFilter)
{
/*if (reservationFilter.Id != "" && reservationFilter.Id.Length == 24 || reservationFilter.CustomerId != "" && reservationFilter.CustomerId.Length == 24)
* {
* return _reservations.Find(reservation => reservation.Id == reservationFilter.Id || reservation.CustomerId == reservationFilter.CustomerId).ToList();
* }*/
if (reservationFilter.Id != "" && reservationFilter.Id.Length == 24)
{
return(_reservations.Find(reservation => reservation.Id == reservationFilter.Id).ToList());
}
else if (reservationFilter.CustomerId != "" && reservationFilter.CustomerId.Length == 24)
{
return(_reservations.Find(reservation => reservation.CustomerId == reservationFilter.CustomerId).ToList());
}
else if (!reservationFilter.StartDate.IsEmpty() && reservationFilter.EndDate.IsEmpty())
{
return(_reservations.Find(reservation => reservation.StartDate > reservationFilter.StartDate).ToList());
}
else if (reservationFilter.StartDate.IsEmpty() && !reservationFilter.EndDate.IsEmpty())
{
return(_reservations.Find(reservation => reservation.EndDate < reservationFilter.EndDate).ToList());
}
else if (!reservationFilter.StartDate.IsEmpty() && !reservationFilter.EndDate.IsEmpty())
{
return(_reservations.Find(reservation => reservation.StartDate > reservationFilter.StartDate && reservation.EndDate < reservationFilter.EndDate).ToList());
}
else
{
return(_reservations.Find(reservation => true).ToList());
}
}
public async Task <int> Count(ReservationFilter filter)
{
IQueryable <ReservationDAO> Reservations = DataContext.Reservation;
Reservations = DynamicFilter(Reservations, filter);
return(await Reservations.CountAsync());
}
public void Then_Sets_SearchTerm(
ManageReservationsFilterModel filterModel)
{
ReservationFilter result = filterModel;
result.SearchTerm.Should().Be(filterModel.SearchTerm);
result.PageNumber.Should().Be(filterModel.PageNumber);
result.PageSize.Should().Be(ManageReservationsFilterModel.PageSize);
result.SelectedEmployer.Should().Be(filterModel.SelectedEmployer);
result.SelectedCourse.Should().Be(filterModel.SelectedCourse);
result.SelectedStartDate.Should().Be(filterModel.SelectedStartDate);
}
private IQueryable <Reservation> SetFilter(IQueryable <Reservation> q, ReservationFilter f)
{
if (f == null)
{
return(q);
}
if (!String.IsNullOrEmpty(f.searchString))
{
q = q.Where(s =>
s.Details.Contains(f.searchString)
);
}
if (f.agencyID > 0)
{
q = q.Where(s => s.AgencyID == f.agencyID);
}
if (f.roomID > 0)
{
q = q.Where(s => s.RoomID == f.roomID);
}
if (f.checkInDate != DateTime.MinValue)
{
DateTime tmp = new DateTime(f.checkInDate.Year, f.checkInDate.Month, f.checkInDate.Day, 9, 0, 0);
q = q.Where(s => s.InitDate == tmp);
}
if (f.checkOutDate != DateTime.MinValue)
{
DateTime tmp = new DateTime(f.checkOutDate.Year, f.checkOutDate.Month, f.checkOutDate.Day, 8, 59, 59);
q = q.Where(s => s.EndDate == tmp);
}
if (f.InDate != DateTime.MinValue)
{
DateTime tmp = new DateTime(f.InDate.Year, f.InDate.Month, f.InDate.Day, 9, 0, 0);
q = q.Where(s => s.InitDate >= tmp);
}
if (f.OutDate != DateTime.MinValue)
{
DateTime tmp = new DateTime(f.OutDate.Year, f.OutDate.Month, f.OutDate.Day, 8, 59, 59);
q = q.Where(s => s.EndDate <= tmp);
}
if (f.checkInState != 0)
{
bool tmp = (f.checkInState == 1 ? true : false);
q = q.Where(s => s.CheckIn == tmp);
}
if (f.checkOutState != 0)
{
bool tmp = (f.checkOutState == 1 ? true : false);
q = q.Where(s => s.CheckOut == tmp);
}
return(q);
}
public async Task <ActionResult <int> > Count([FromBody] Reservation_ReservationFilterDTO Reservation_ReservationFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ReservationFilter ReservationFilter = ConvertFilterDTOToFilterEntity(Reservation_ReservationFilterDTO);
int count = await ReservationService.Count(ReservationFilter);
return(count);
}
public async Task <List <Reservation> > GetHandedOutReservations()
{
try
{
var entityList = _reservationRepository.GetAll();
var reservations = ReservationFilter.FilterByStatusId(entityList, 2);
return(reservations.ToList());
}
catch
{
return(null);
}
}
public async Task <List <Reservation> > GetReservationsByUserId(int userId)
{
try
{
var entityList = _reservationRepository.GetAll();
var reservations = ReservationFilter.FilterByUserId(entityList, userId);
return(reservations.ToList());
}
catch
{
return(null);
}
}
public async Task <List <Reservation> > GetHandedOutReservationsByCountOfDays(int count)
{
try
{
var entityList = _reservationRepository.GetAll();
var reservations = ReservationFilter.FilterByStatusIdAndCountOfDays(entityList, 2, count);
return(reservations.ToList());
}
catch
{
return(null);
}
}
public async Task <List <Reservation> > List(ReservationFilter filter)
{
if (filter == null)
{
return(new List <Reservation>());
}
IQueryable <ReservationDAO> ReservationDAOs = DataContext.Reservation;
ReservationDAOs = DynamicFilter(ReservationDAOs, filter);
ReservationDAOs = DynamicOrder(ReservationDAOs, filter);
List <Reservation> Reservations = await DynamicSelect(ReservationDAOs, filter);
return(Reservations);
}
public async Task <ProcessResult <int> > CountAsync(ReservationFilter filter)
{
IQueryable <Reservation> q = context.Reservations;
q = SetFilter(q, filter);
Func <Task <int> > action = async() =>
{
var countItems = await q.CountAsync();
return(countItems);
};
return(await Process.RunAsync(action));
}
public async Task <ActionResult <List <Reservation_ReservationDTO> > > List([FromBody] Reservation_ReservationFilterDTO Reservation_ReservationFilterDTO)
{
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
ReservationFilter ReservationFilter = ConvertFilterDTOToFilterEntity(Reservation_ReservationFilterDTO);
List <Reservation> Reservations = await ReservationService.List(ReservationFilter);
List <Reservation_ReservationDTO> Reservation_ReservationDTOs = Reservations
.Select(c => new Reservation_ReservationDTO(c)).ToList();
return(Reservation_ReservationDTOs);
}
public async Task <IEnumerable <Reservation> > GetReservations(ReservationFilter reservationsFilter)
{
string getReservationsQuery =
@"select
r.ID as ReservationId,
c.clientFirmID as ClientFirmId,
r.isActive as IsActiveReservation,
f.foodname as FoodName,
r.quantity as Quantity,
f.price*Quantity as PriceTotal,
f.imageURL as ItemImageUrl
from Reservation r
join Foods f on r.foodID = f.ID
join Clients c on c.ID =r.clientID
where f.cateringFirmID = @CateringFirmId and c.clientFirmID in @ClientFirmIds and reservationDate=@Date";
using (dbConn)
{
dbConn.Open();
if (dbConn.State != ConnectionState.Open)
{
throw new Exception("Nie udalos sie polaczyc z baza");
}
IEnumerable <ReservationDbResult> reservationsDb = dbConn.Query <ReservationDbResult>(getReservationsQuery, reservationsFilter);
IEnumerable <Reservation> reservations =
reservationsDb.GroupBy(
dbReservation => dbReservation.ReservationId,
(reservationid, groupedReservationsByReservationId) =>
new Reservation
{
ReservationId = reservationid,
ClientFirmId = groupedReservationsByReservationId.First().ClientFirmId,
IsActiveReservation = groupedReservationsByReservationId.First().IsActiveReservation,
ReservationItems = groupedReservationsByReservationId.
Select(reservationItemResult => new ReservationItem
{
ItemImageUrl = reservationItemResult.ItemImageUrl,
Name = reservationItemResult.FoodName,
PriceTotal = reservationItemResult.PriceTotal,
Quantity = reservationItemResult.Quantity
})
}
);
return(reservations);
}
}
private ReservationFilter ConvertFilterDTOToFilterEntity(Reservation_ReservationFilterDTO Reservation_ReservationFilterDTO)
{
ReservationFilter ReservationFilter = new ReservationFilter();
ReservationFilter.Selects = ReservationSelect.ALL;
ReservationFilter.Skip = Reservation_ReservationFilterDTO.Skip;
ReservationFilter.Take = Reservation_ReservationFilterDTO.Take;
ReservationFilter.OrderBy = Reservation_ReservationFilterDTO.OrderBy;
ReservationFilter.OrderType = Reservation_ReservationFilterDTO.OrderType;
ReservationFilter.Id = Reservation_ReservationFilterDTO.Id;
ReservationFilter.TableId = Reservation_ReservationFilterDTO.TableId;
ReservationFilter.Date = Reservation_ReservationFilterDTO.Date;
ReservationFilter.StatusId = Reservation_ReservationFilterDTO.StatusId;
return(ReservationFilter);
}
public async Task <IActionResult> Count(ReservationFilter filter)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _ReservationService.CountAsync(filter);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
return(Ok(result));
}
public async Task <IActionResult> Get(ReservationFilter filter)
{
var nlRes = await reservationsDbProvider.ReadModel(filter).ConfigureAwait(false);
var res = nlRes.ToList();
if (filter.Day.HasValue)
{
filter.Day = filter.Day.Value.Date.AddDays(-1);
var preDayRes = await reservationsDbProvider.ReadModel(filter).ConfigureAwait(false);
var withAndInNextDay = preDayRes.Where(r => r.Date + r.Duration > filter.Day);
res.AddRange(withAndInNextDay);
}
return(Ok(res));
}
public IActionResult Index(int?pageNumber, ReservationFilter reservationFilter)
{
try
{
ViewData["CurrentSort"] = reservationFilter.SortOrder;
ViewData["CheckInDateSortParm"] = String.IsNullOrEmpty(reservationFilter.SortOrder) ? "CheckInDate" : "";
ViewData["CheckOutDateSortParm"] = reservationFilter.SortOrder == "CheckOutDate" ? "CheckOutDate" : "CheckOutDate";
reservationFilter.Take = 5;
pageNumber ??= 1;
reservationFilter.Skip = (pageNumber.Value - 1) * reservationFilter.Take;
var(reservations, count) = reservationService.ReadReservations(reservationFilter);
return(View(PaginatedList <ReservationViewModel> .Create(reservations, count, pageNumber.Value, reservationFilter.Take)));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <IActionResult> Delete(Guid id)
{
var filter = new ReservationFilter
{
Id = id,
Amount = 1
};
var result = await reservationsDbProvider.Delete(filter).ConfigureAwait(false);
if (!result)
{
return(NotFound());
}
var historyRecord = new HistoryRecord(ActionTypes.DeleteReservation, id, DateTime.Now);
await historyDbProvider.WriteModel(historyRecord).ConfigureAwait(false);
return(Ok());
}
public async Task <List <Reservation> > GetHandedOutReservationsByAuthorName(string lastName)
{
if (string.IsNullOrEmpty(lastName))
{
return(null);
}
try
{
var entityList = _reservationRepository.GetAll();
var reservations = ReservationFilter.FilterByStatusIdAndAuthorName(entityList, 2, lastName);
return(reservations.ToList());
}
catch
{
return(null);
}
}
public async Task <bool> ValidateId(Reservation Reservation)
{
ReservationFilter ReservationFilter = new ReservationFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Reservation.Id
},
Selects = ReservationSelect.Id
};
int count = await UOW.ReservationRepository.Count(ReservationFilter);
if (count == 0)
{
Reservation.AddError(nameof(ReservationValidator), nameof(Reservation.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <List <Reservation> > List(ReservationFilter ReservationFilter)
{
try
{
List <Reservation> Reservations = await UOW.ReservationRepository.List(ReservationFilter);
return(Reservations);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(ReservationService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
public (IEnumerable <Reservation>, int) ReadReservations(ReservationFilter filter)
{
var query = context.Reservations.Include(r => r.Guest).Take(filter.Take).Skip(filter.Skip);
switch (filter.SortOrder)
{
case "CheckInDate":
query = query.OrderBy(r => r.CheckInDate);
break;
case "CheckOutDate":
query = query.OrderBy(r => r.CheckOutDate);
break;
default:
query = query.OrderBy(r => r.Id);
break;
}
var reservations = query.ToList();
return(reservations, reservations.Count);
}
public async Task <int> Count(ReservationFilter ReservationFilter)
{
try
{
int result = await UOW.ReservationRepository.Count(ReservationFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(ReservationService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
public async Task <ActionResult> GetReservationByName(ReservationFilter reservation)
{
Request.Headers.TryGetValue("Authorization", out var token);
if (StringValues.IsNullOrEmpty(token))
{
return(Unauthorized());
}
_client.DefaultRequestHeaders.Add("Authorization", token.FirstOrDefault());
string json = JsonConvert.SerializeObject(reservation);
StringContent httpContent = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PostAsync(_reservationsServiceUrl + "reservationByName", httpContent);
if (response.StatusCode == HttpStatusCode.OK)
{
return(Ok(response.Content.ReadAsStringAsync().Result));
}
else
{
return(StatusCode((int)response.StatusCode));
}
}
public async Task OnGetAsync(string sortOrder, string vehicleType, string currentVehicleType, int?pageNumber)
{
ReservationFilter filter = new ReservationFilter();
CurrentSort = sortOrder;
PickUpSort = string.IsNullOrEmpty(sortOrder) ? "pickup_desc" : "";
DropOffSort = sortOrder == "DropOff" ? "dropoff_desc" : "DropOff";
AddressSort = sortOrder == "Address" ? "address_desc" : "Address";
VehicleModelSort = sortOrder == "VehicleModel" ? "vehiclemodel_desc" : "VehicleModel";
StateSort = sortOrder == "State" ? "state_desc" : "State";
CarSort = sortOrder == "Car" ? "car_desc" : "Car";
if (vehicleType != null)
{
pageNumber = 0;
}
else
{
if (string.IsNullOrEmpty(vehicleType))
{
vehicleType = currentVehicleType;
}
}
VehicleType = vehicleType;
filter.PageNumber = pageNumber ?? 0;
filter.VehicleType = vehicleType;
switch (sortOrder)
{
case "pickup_desc":
filter.reservationOrder = ReservationFilter.ReservationOrder.PickUpDescending;
break;
case "dropoff_desc":
filter.reservationOrder = ReservationFilter.ReservationOrder.DropOffDescending;
break;
case "DropOff":
filter.reservationOrder = ReservationFilter.ReservationOrder.DropOffAscending;
break;
case "address_desc":
filter.reservationOrder = ReservationFilter.ReservationOrder.AddressDescending;
break;
case "Address":
filter.reservationOrder = ReservationFilter.ReservationOrder.AddressAscending;
break;
case "VehicleModel":
filter.reservationOrder = ReservationFilter.ReservationOrder.VehicleModelAscending;
break;
case "vehiclemodel_desc":
filter.reservationOrder = ReservationFilter.ReservationOrder.VehicleModelDescending;
break;
case "State":
filter.reservationOrder = ReservationFilter.ReservationOrder.StateAscending;
break;
case "state_desc":
filter.reservationOrder = ReservationFilter.ReservationOrder.StateDescending;
break;
case "Car":
filter.reservationOrder = ReservationFilter.ReservationOrder.CarAscending;
break;
case "car_desc":
filter.reservationOrder = ReservationFilter.ReservationOrder.CarDescending;
break;
default:
filter.reservationOrder = ReservationFilter.ReservationOrder.PickUpAscending;
break;
}
_logger.LogInformation(LoggingEvents.ListItems, "List Reservation for Admin");
Reservation = await _reservationService.GetReservations(filter);
}
public async Task <IEnumerable <Reservation> > GetReservationsAsync(ReservationFilter reservationsFilter)
{
return(await _reservationsRepository.GetReservations(reservationsFilter));
}
public async Task <PagedResult <ReservationIndexHeader> > GetReservations(ReservationFilter filter)
{
if (filter == null)
{
filter = new ReservationFilter();
}
if (filter?.PageSize < 0)
{
filter.PageSize = null;
}
if (filter?.PageNumber < 0)
{
filter.PageNumber = null;
}
IQueryable <Reservation> reservations = _dbContext.Reservations
.Include(c => c.VehicleModel)
.Include(c => c.Car)
.Include(c => c.Address)
.Include(c => c.User);
if (!string.IsNullOrEmpty(filter?.VehicleType))
{
reservations = reservations.Where(r => r.VehicleModel.VehicleType.Contains(filter.VehicleType));
}
switch (filter.reservationOrder)
{
case ReservationFilter.ReservationOrder.AddressAscending:
reservations = reservations.OrderBy(r => r.Address.ZipCode).OrderBy(r => r.Address.City).OrderBy(r => r.Address.StreetAddress);
break;
case ReservationFilter.ReservationOrder.AddressDescending:
reservations = reservations.OrderByDescending(r => r.Address.ZipCode).OrderByDescending(r => r.Address.City).OrderByDescending(r => r.Address.StreetAddress);
break;
case ReservationFilter.ReservationOrder.PickUpAscending:
reservations = reservations.OrderBy(r => r.PickUpTime);
break;
case ReservationFilter.ReservationOrder.PickUpDescending:
reservations = reservations.OrderByDescending(r => r.PickUpTime);
break;
case ReservationFilter.ReservationOrder.DropOffAscending:
reservations = reservations.OrderBy(r => r.DropOffTime);
break;
case ReservationFilter.ReservationOrder.DropOffDescending:
reservations = reservations.OrderByDescending(r => r.DropOffTime);
break;
case ReservationFilter.ReservationOrder.VehicleModelAscending:
reservations = reservations.OrderBy(r => r.VehicleModel.VehicleType);
break;
case ReservationFilter.ReservationOrder.VehicleModelDescending:
reservations = reservations.OrderByDescending(r => r.VehicleModel.VehicleType);
break;
case ReservationFilter.ReservationOrder.StateAscending:
reservations = reservations.OrderBy(r => r.State);
break;
case ReservationFilter.ReservationOrder.StateDescending:
reservations = reservations.OrderByDescending(r => r.State);
break;
case ReservationFilter.ReservationOrder.CarAscending:
reservations = reservations.OrderBy(r => r.Car.PlateNumber);
break;
case ReservationFilter.ReservationOrder.CarDescending:
reservations = reservations.OrderByDescending(r => r.Car.PlateNumber);
break;
default:
break;
}
int?Total = null;
if (((filter?.PageSize) ?? 0) != 0)
{
filter.PageNumber = filter.PageNumber ?? 0;
Total = reservations.Count();
reservations = reservations.Skip(filter.PageNumber.Value * filter.PageSize.Value).Take(filter.PageSize.Value);
}
var results = await reservations.Select(ReservationIndexHeaderSelector).ToListAsync();
return(new PagedResult <ReservationIndexHeader>
{
Total = Total,
PageNumber = filter?.PageNumber,
PageSize = filter?.PageSize,
Results = results
});
}
private async Task <List <Reservation> > DynamicSelect(IQueryable <ReservationDAO> query, ReservationFilter filter)
{
List <Reservation> Reservations = await query.Select(q => new Reservation()
{
Id = filter.Selects.Contains(ReservationSelect.Id) ? q.Id : default(long),
TableId = filter.Selects.Contains(ReservationSelect.Table) ? q.TableId : default(long),
Date = filter.Selects.Contains(ReservationSelect.Date) ? q.Date : default(DateTime),
StatusId = filter.Selects.Contains(ReservationSelect.Status) ? q.StatusId : default(long),
Table = filter.Selects.Contains(ReservationSelect.Table) && q.Table != null ? new Table
{
Id = q.Table.Id,
Code = q.Table.Code,
} : null,
}).AsNoTracking().ToListAsync();
return(Reservations);
}
private IQueryable <ReservationDAO> DynamicOrder(IQueryable <ReservationDAO> query, ReservationFilter filter)
{
switch (filter.OrderType)
{
case OrderType.ASC:
switch (filter.OrderBy)
{
case ReservationOrder.Id:
query = query.OrderBy(q => q.Id);
break;
case ReservationOrder.Table:
query = query.OrderBy(q => q.TableId);
break;
case ReservationOrder.Date:
query = query.OrderBy(q => q.Date);
break;
case ReservationOrder.Status:
query = query.OrderBy(q => q.StatusId);
break;
}
break;
case OrderType.DESC:
switch (filter.OrderBy)
{
case ReservationOrder.Id:
query = query.OrderByDescending(q => q.Id);
break;
case ReservationOrder.Table:
query = query.OrderByDescending(q => q.TableId);
break;
case ReservationOrder.Date:
query = query.OrderByDescending(q => q.Date);
break;
case ReservationOrder.Status:
query = query.OrderByDescending(q => q.StatusId);
break;
}
break;
}
query = query.Skip(filter.Skip).Take(filter.Take);
return(query);
}
private IQueryable <ReservationDAO> DynamicFilter(IQueryable <ReservationDAO> query, ReservationFilter filter)
{
if (filter == null)
{
return(query.Where(q => false));
}
if (filter.Id != null)
{
query = query.Where(q => q.Id, filter.Id);
}
if (filter.TableId != null)
{
query = query.Where(q => q.TableId, filter.TableId);
}
if (filter.Date != null)
{
query = query.Where(q => q.Date, filter.Date);
}
if (filter.StatusId != null)
{
query = query.Where(q => q.StatusId, filter.StatusId);
}
return(query);
}
