private static void CreateOffersAndReservations()
{
CarModel car1 = GlobalConfig.CarModelConection
.Filter(model => model.Brand == "automobil 1")[0];
CarModel car2 = GlobalConfig.CarModelConection
.Filter(model => model.Brand == "automobil 2")[0];
CarModel car3 = GlobalConfig.CarModelConection
.Filter(model => model.Brand == "automobil 3")[0];
DateTime from1 = new DateTime(2019, 4, 1);
DateTime to1 = new DateTime(2019, 4, 30);
OfferModel offer1 = new OfferModel(car1.ID, from1, to1, 200);
DateTime from2 = new DateTime(2019, 6, 1);
DateTime to2 = new DateTime(2019, 6, 30);
OfferModel offer2 = new OfferModel(car2.ID, from2, to2, 200);
DateTime from3 = new DateTime(2019, 7, 1);
DateTime to3 = new DateTime(2019, 7, 31);
OfferModel offer3 = new OfferModel(car3.ID, from3, to3, 200);
OfferModel[] offers = new OfferModel[]
{
offer1,
offer2,
offer3
};
UserModel user1 = GlobalConfig.UserModelConnection.GetByUsername("Korisnik1");
UserModel user2 = GlobalConfig.UserModelConnection.GetByUsername("Korisnik2");
UserModel user3 = GlobalConfig.UserModelConnection.GetByUsername("Korisnik3");
DateTime resv1From = new DateTime(2019, 4, 5);
DateTime resv1To = new DateTime(2019, 4, 10);
ReservationModel reservation1 = new ReservationModel(user1.ID, car1.ID, resv1From, resv1To, 200);
DateTime resv2From = new DateTime(2019, 6, 5);
DateTime resv2To = new DateTime(2019, 6, 10);
ReservationModel reservation2 = new ReservationModel(user2.ID, car2.ID, resv2From, resv2To, 200);
ReservationModel[] reservations = new ReservationModel[]
{
reservation1,
reservation2
};
foreach (OfferModel offer in offers)
{
GlobalConfig.OfferModelConection.Create(offer);
}
foreach (ReservationModel reservation in reservations)
{
GlobalConfig.ReservationModelConection.Create(reservation);
}
}
public ActionResult AddReservation(ReservationModel model)
{
if (model.CheckIn < DateTime.Now.AddDays(-1) || model.CheckIn > model.CheckOut)
{
return(Json("Hata"));
}
_reservationService.Add(model);
return(Json("Başarılı"));
}
public JsonResult Calculator(ReservationModel model)
{
if (model.CheckIn < DateTime.Now.AddDays(-1) || model.CheckIn > model.CheckOut)
{
return(Json(new ReservationModel()));
}
model.TotalPrice = _reservationService.Calc(model);
return(Json(model));
}
public int Delete(ReservationModel model)
{
string sqlDelete = "DELETE FROM Reservation WHERE Id = @Id";
using (_connection)
{
return(_connection.Execute(sqlDelete, model));
}
}
public void UpdateReservation(ReservationModel model)
{
using (HotelContext ctx = new HotelContext())
{
var reservationToEdit = ctx.Reservations.FirstOrDefault(x => x.Id == model.Id);
reservationToEdit.Status = (ReservationStatus)Enum.Parse(typeof(ReservationStatus), model.Status);
ctx.SaveChanges();
}
}
private List <ReservationModel> PopulateReservationsList(BGO.ResortsService.ReservationHistoryItem[] reservations, BGO.ResortsService.ReservationHistoryType enmResType)
{
List <ReservationModel> reservationList = new List <ReservationModel>();
if (enmResType == BGO.ResortsService.ReservationHistoryType.Past)
{
for (int x = 0; x <= reservations.Length - 1; x++)
{
ReservationModel rsdtl = new ReservationModel();
rsdtl.ReservationNumber = reservations[x]._ReservationNumber;
rsdtl.NumberOfAdults = reservations[x]._NumberOfAdults;
rsdtl.NumberOfNights = Convert.ToInt32(reservations[x]._NumberOfNights);
rsdtl.AmountDue = reservations[x]._AmountDue;
rsdtl.PolicyPrice = reservations[x]._PolicyPrice;
rsdtl.AS400UnitType = reservations[x]._AS400UnitType;
rsdtl.ProjectStay = Convert.ToInt32(reservations[x]._ProjectStay);
rsdtl.ReservationType = reservations[x]._ReservationType;
rsdtl.ResortNo = Convert.ToInt32(reservations[x]._ProjectStay);
rsdtl.ResortName = getResortName(rsdtl.ProjectStay, rsdtl.ReservationType);
rsdtl.CheckInDate = NumericToDate(reservations[x]._CheckInDate, "yyMMdd");
rsdtl.CheckOutDate = CalcCheckOutDate(rsdtl.NumberOfNights, rsdtl.CheckInDate);
rsdtl.VillaType = getVillaDescription(rsdtl.ProjectStay, rsdtl.AS400UnitType);
rsdtl.ReservationType = ReservationType(reservations[x]._ReservationType, reservations[x]._ExchangeCode);
rsdtl.Points = convertPoints(reservations[x]._Points, reservations[x]._ReservationType);
rsdtl.PPPStatus = PolicyStatus(reservations[x]._PolicyStatus, reservations[x]._EligibleDate, "Future", reservations[x]._ReservationNumber, reservations[x]._ExchangeCode, reservations[x]._ReservationType);
reservationList.Add(rsdtl);
}
}
else
{
for (int x = reservations.Length - 1; x >= 0; x--)
{
ReservationModel rsdtl = new ReservationModel();
rsdtl.ReservationNumber = reservations[x]._ReservationNumber;
rsdtl.NumberOfAdults = reservations[x]._NumberOfAdults;
rsdtl.NumberOfNights = Convert.ToInt32(reservations[x]._NumberOfNights);
rsdtl.AmountDue = reservations[x]._AmountDue;
rsdtl.PolicyPrice = reservations[x]._PolicyPrice;
rsdtl.AS400UnitType = reservations[x]._AS400UnitType;
rsdtl.ProjectStay = Convert.ToInt32(reservations[x]._ProjectStay);
rsdtl.ReservationType = reservations[x]._ReservationType;
rsdtl.ResortNo = Convert.ToInt32(reservations[x]._ProjectStay);
rsdtl.ResortName = getResortName(rsdtl.ProjectStay, rsdtl.ReservationType);
rsdtl.CheckInDate = NumericToDate(reservations[x]._CheckInDate, "yyMMdd");
rsdtl.CheckOutDate = CalcCheckOutDate(rsdtl.NumberOfNights, rsdtl.CheckInDate);
rsdtl.VillaType = getVillaDescription(rsdtl.ProjectStay, rsdtl.AS400UnitType);
rsdtl.ReservationType = ReservationType(reservations[x]._ReservationType, reservations[x]._ExchangeCode);
rsdtl.Points = convertPoints(reservations[x]._Points, reservations[x]._ReservationType);
rsdtl.PPPStatus = PolicyStatus(reservations[x]._PolicyStatus, reservations[x]._EligibleDate, "Future", reservations[x]._ReservationNumber, reservations[x]._ExchangeCode, reservations[x]._ReservationType);
reservationList.Add(rsdtl);
}
}
return(reservationList);
}
public ReservationModel GetIndexReservationMonolithic()
{
List <Services> serviceList = _context.Services.ToList();
ReservationModel reservationModel = new ReservationModel();
reservationModel.Reservations = _context.Reservations.Where(elem => elem.IdUser == 1 && elem.Date >= DateTime.Today).Include(r => r.IdEmployeeNavigation)
.Include(r => r.IdServiceNavigation);
return(reservationModel);
}
public async Task <ReservationModel> DeleteReservation(int id, [ScopedService] LibraryDbContext context)
{
ReservationModel reservationModel = await context.Reservations.FindAsync(id);
context.Reservations.Remove(reservationModel);
await context.SaveChangesAsync();
return(reservationModel);
}
public IActionResult Reserve(ReservationModel model)
{
if (model.FormOption == "DELETE" && model.ReservationId != null)
{
_reservationService.Delete(model.ReservationId);
TempData["message"] = new AlertMessage {
CssClass = "alert-success", Id = string.Empty, Title = "Reservering verwijderd", Message = "Uw Reservering is succesvol verwijderd!"
};
return(Reserve());
}
if (!ModelState.IsValid)
{
return(Reserve());
}
if (model.FormOption == null)
{
_reservationService.Create(new Reservation
{
ArriveDate = model.ArriveDate,
DepartureDate = model.DepartureDate,
EmailAddress = model.EmailAddress,
PhoneNumber = model.PhoneNumber,
UserId = User.FindFirstValue(ClaimTypes.UserData)
});
TempData["message"] = new AlertMessage {
CssClass = "alert-success", Id = string.Empty, Title = "Reservering gemaakt", Message = "Uw Reservering is succesvol aangemaakt!"
};
}
else
{
var reservationToUpdate = _reservationService.Get(model.ReservationId);
// Reservation does not exists return view
if (reservationToUpdate == null)
{
return(Reserve());
}
reservationToUpdate.EmailAddress = model.EmailAddress;
reservationToUpdate.PhoneNumber = model.PhoneNumber;
reservationToUpdate.ArriveDate = model.ArriveDate;
reservationToUpdate.DepartureDate = model.DepartureDate;
// Update reservation
_reservationService.Update(reservationToUpdate);
TempData["message"] = new AlertMessage {
CssClass = "alert-success", Id = string.Empty, Title = "Reservering bijgewerkt.", Message = "Uw reservering is succesvol bijgewerkt!"
};
}
return(Reserve());
}
public async Task ConfirmedReservation(IDialogContext context, IAwaitable <bool> argument)
{
bool isCorrect = await argument;
if (isCorrect)
{
//Bắt đầu đẩy lên CSDL thông tin khách hàng và thông tin phiếu đặt phòng
using (CustomerService customerService = new CustomerService())
{
//CustomerService customerService = new CustomerService();
CustomerModel model = new CustomerModel();
model.GetDataFromCustomer(this.customer);
int savedCustomer = await customerService.GetIDCustomerByPassport(model.PassportNumber);
if (savedCustomer == 0)
{
//customerService = new CustomerService();
this.reservation.CustomerID = customerService.CreateCustomerReturnID(model);
}
else
{
this.reservation.CustomerID = await customerService.GetIDCustomerByPassport(model.PassportNumber);
}
//this.reservation.CustomerID = savedCustomer;
ReservationModel reservationModel = new ReservationModel();
reservationModel.GetDataFromReservation(this.reservation);
//using (RoomService roomService = new RoomService())
//{
// foreach (int id in ls)
// {
// rooms.Add(roomService.GetRoomFromID(id));
// }
//}
//this.reservation.Price = (room.Price * (((reservation.CheckOutDateTime - reservation.CheckInDateTime).Days)));
using (ReservationService reservationService = new ReservationService())
{
//reservationModel.Customer = model;
//reservationModel.Room = this.room;
ReservationAndRooms2 reservationAndRooms = new ReservationAndRooms2
{
ReservationViewModel = reservationModel,
Rooms = ls
};
ReservationModel savedreservationModel = reservationService.CreateReservationAndRooms2(reservationAndRooms);
await context.PostAsync("Đơn đặt phòng đã được lưu. Vui lòng mang theo giấy CMND của quý khách và các hành khách đi cùng đến khách sạn để làm thủ tục nhận phòng.\n\nCảm ơn quý khách đã chọn Khách Sạn Mai Sơn.");
// context.Done(true);
}
}
}
else
{
var reservationDialog = new FormDialog <Reservation>(this.reservation, Reservation.BuildOrderForm, FormOptions.PromptInStart);
context.Call(reservationDialog, this.ResumeAfterReservationDialog);
}
}
//TODO Currently Working
private void PendingReservationListItemSelect(ReservationModel model)
{
try {
// instanceResort = Utilities.getResortInfo(Convert.ToInt32(lblResortNo.Text));
} catch (Exception ex) {
instanceResort = new ResortInfo();
}
Session["instanceResort"] = instanceResort;
}
public ViewResult CreateNewReservation()
{
ReservationModel res = new ReservationModel()
{
AllCustomers = new SelectList(_firmarepos.GetAllCustomers(), "CustomerID", "CustomerID"),
AllCars = new SelectList(_firmarepos.GetAllCars(), "CarID", "CarID")
};
return(View(res));
}
public HttpResponseMessage ReserveCar(HttpRequestMessage request, [FromBody] ReservationModel model)
{
return(GetHttpResponse(request, () => {
HttpResponseMessage response = null;
string user = User.Identity.Name;
Reservation reservation = _RentalService.MakeReservation(user, model.CarId, model.PickupDate, model.ReturnDate);
response = request.CreateResponse <Reservation>(HttpStatusCode.OK, reservation);
return response;
}));
}
/// <summary>
/// Adds new reservation
/// </summary>
private void AddNewReservation()
{
//Create a New Resrvation Model
ReservationModel reservationModel = this.CreateReservationModel();
//Create new IReservation object
IReservation reservation = this.CreateReservation(reservationModel);
//add new reservation ReservationService
_reservationService.AddReservation(reservation);
}
private void SelectReservedItem(object sender, DataGridViewCellEventArgs e)
{
int row = e.RowIndex; //which row did i click on in the list
if (row > -1) //-1 for clicking column names
{
List <ReservationModel> borrow = (List <ReservationModel>)reservedDataGridView.DataSource;
selectedReservedItem = borrow.ElementAt <ReservationModel>(row);
}
}
public IActionResult AddReservation()
{
var model = new ReservationModel
{
SportEvents = _sportEventManager.GetAllEventsWithoutReservation()
};
return(View(model));
}
public ReservationModel ConfirmAvailability(ReservationModel reservationModel, Credential userCredential)
{
foreach (var vacancy in reservationModel.Vacancies)
{
vacancy.Available = true;
//vacancy.ConfirmedVacancyPrice = vacancy.VacancyPrice;
}
return(reservationModel);
}
public static void SetDateOccurrences(CreateEventModel model, ReservationModel reservation)
{
var beginDate = model.EventDate;
var isWeekly = model.EventRepeatModel.RepeatOption == EventRepeatOptions.Weekly;
var isMonthly = model.EventRepeatModel.RepeatOption == EventRepeatOptions.Monthly;
var currentWeek = isWeekly
? GetNextDayOccurence(model.EventDate, DayOfWeek.Monday)
.AddDays((model.EventRepeatModel.RepeatInterval - 1) * 7)
: model.EventDate.AddMonths(model.EventRepeatModel.RepeatInterval);
var lastUpdated = DateTime.MinValue;
var quitDate = model.EventRepeatModel.ExitStrategy == ExitStrategy.FIXED_DATE
? model.EventRepeatModel.ExitDate
: beginDate.AddYears(1);
while (currentWeek < quitDate)
{
var selectedDays = SelectedDays(model.EventRepeatModel.DaysOfTheWeek);
/*
* If its weekly, get next week's monday and add the repeat interval to get next date.
* If its monthly just add one month.
*/
if (isWeekly && currentWeek < lastUpdated.AddDays(model.EventRepeatModel.RepeatInterval * 7 - 7))
{
currentWeek = currentWeek.AddDays(7);
continue;
}
if (isMonthly && currentWeek < lastUpdated.AddMonths(1))
{
currentWeek = currentWeek.AddMonths(1);
continue;
}
foreach (var day in selectedDays)
{
var nextOccurence = GetNextDayOccurence(currentWeek, day);
reservation.EventDates.Add(new EventOccurenceModel
{
Occurence = nextOccurence.AddHours(model.BeginHour.Hour).AddMinutes(model.BeginHour.Minute),
Reservation = reservation,
DurationMinutes = (model.EndHour - model.BeginHour).TotalMinutes
});
currentWeek = nextOccurence;
lastUpdated = nextOccurence;
}
}
}
public async Task <(ReservationModel Reservation, bool IsSuccess, string ErrorMessage)> CreateReservationAsync(ReservationRequest request)
{
var show = await Context.Shows.Include(x => x.Movie).Include(x => x.Multiplex).ThenInclude(x => x.City).FirstOrDefaultAsync(x => x.Id == request.ShowId);
if (show == null)
{
return(null, false, "Invalid show");
}
if (!request.MovieName.Equals(show.Movie.Name, StringComparison.OrdinalIgnoreCase))
{
return(null, false, "Invalid movie request for show");
}
if (!request.CityName.Equals(show.Multiplex.City.Name, StringComparison.OrdinalIgnoreCase))
{
return(null, false, "Invalid multiplex city request for show");
}
if (!request.MultiplexName.Equals(show.Multiplex.Name, StringComparison.OrdinalIgnoreCase))
{
return(null, false, "Invalid multiplex request for show");
}
if (request.NoOfTickets > show.AvailableSeats)
{
return(null, false, "The no of requested sheats are not available to book");
}
if ((request.ShowDate != show.ShowDate) && (request.ShowDate <= DateTime.UtcNow.AddDays(-1)))
{
return(null, false, "Incorrect show date");
}
var reservation = new Reservation
{
MaxSeatPerBooking = 5,
BookingDate = DateTime.UtcNow,
NumberOfSeatBooked = request.NoOfTickets,
ShowId = show.Id,
PriceOfBooking = show.PricePerSeat * request.NoOfTickets,
UserId = request.UserId
};
await AddAsync(reservation);
show.AvailableSeats = show.AvailableSeats - request.NoOfTickets;
Context.Shows.Update(show);
ReservationModel model = GetReservationModel(reservation);
return(model, true, null);
}
public void GetReservationsFormAInput(ReservationModel Reservation)
{
if (FlightReservationsServices.GetInstance.FlightExists(Reservation))
{
Views.GetInstance.DisplayMatchingFlights(Reservation, FlightReservationsServices.GetInstance.GetMatchingFlights(Reservation));
}
else
{
Views.GetInstance.DisplayReservationMenu();
}
}
/// <summary>
/// Obsluga przycisku edycji
/// </summary>
/// <param name="sender">Obiekt wywołujący zdarzenie</param>
/// <param name="e">Obiekt zawierający parametry zdarzenia</param>
private void Edit_Click(object sender, RoutedEventArgs e)
{
MainWindow window = (MainWindow)Application.Current.MainWindow;
UserControl uc = new Forms.Reservations();
ReservationModel model = ReservationDao.LoadById((long)(sender as Button).Tag);
model.Mode = "update";
uc.DataContext = model;
window.GridMain.Children.Clear();
window.GridMain.Children.Add(uc);
}
public async Task <ActionResult> PostAsync([FromBody] ReservationModel value)
{
if (await _reservationService.CreateAsync(value, int.Parse(User.Identity.Name)))
{
return(Ok());
}
else
{
return(BadRequest(new { message = "Wrong data or room reserved." }));
}
}
public ReservationModel UpdateOneReservation(ReservationModel reservation)
{
if (_dbReservationRepository.UpdateOne(reservation))
{
return(reservation);
}
else
{
return(null);
}
}
public IActionResult Post([FromBody] ReservationModel reservation)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_cafeDbContext.Reservations.Add(reservation);
_cafeDbContext.SaveChanges();
return(StatusCode(StatusCodes.Status201Created));
}
public ReservationSummaryView(ReservationModel reservation, bool loadReservationData)
{
InitializeComponent();
FillPickerStatus();
BindingContext = new ReservationSummaryViewModel(this, reservation, loadReservationData);
entValue.TextChanged += (s, e) => { if (string.IsNullOrWhiteSpace(entValue.Text))
{
entValue.Text = "0";
}
};
}
private void PopulateView(ReservationModel reservation)
{
CustomerModel customer = customersDataSource.Find(model => model.ID == reservation.UserID);
CarModel car = carsDataSource.Find(model => model.ID == reservation.CarID);
view.Car = car;
view.User = customer;
view.From = reservation.From;
view.To = reservation.To;
view.Price = reservation.Price;
}
public async Task <IActionResult> Create([Bind("Id,FirstName,LastName,Date,Time,SeatNumber,Details")] ReservationModel reservationModel)
{
if (ModelState.IsValid)
{
_context.Add(reservationModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(reservationModel));
}
public async Task <IActionResult> ReserveByRoomType(int roomTypeId, ReservationModel model)
{
var reservation = await _reservationService.CreateReservation(
roomTypeId, model.Start, model.End, model.Name, model.Email, model.Message, model.PhoneCountry,
model.Phone, model.NumberOfGuests);
return(Ok(new
{
reservationId = reservation.Id
}));
}
public int Insert(ReservationModel model)
{
string sqlInsert = "INSERT INTO Reservation (Id, DateOfBooking, BeginningDate," +
" EndDate, CarId, CustomerId, DistanceDriven, EmployeeId) Values (@Id," +
" @DateOfBooking, @BeginningDate, @EndDate, @CarId, @CustomerId, @DistanceDriven, @EmployeeId)";
using (_connection)
{
return(_connection.Execute(sqlInsert, model));
}
}
public async Task UpdateReservation(ReservationModel reservationModel)
{
var reservationEntity = await _dataContext.RoomReservations
.FirstOrDefaultAsync(r =>
(r.RoomReservationId == reservationModel.RoomReservationId) &&
!(reservationModel.Status == r.StatusId)
);
if (reservationEntity == null)
{
throw new BookingException();
}
var userEntity = await _dataContext.Users
.FirstOrDefaultAsync(u => u.UserId == reservationEntity.UserId);
if (userEntity == null || reservationEntity.UserId != userEntity.UserId)
{
throw new UserNotFoundException();
}
reservationEntity.StatusId = reservationModel.Status;
if (reservationModel.Status == (int)ReservationStatusEnum.Confirmed)
{
var elapsedMinutes = (reservationModel.Confirmed - reservationModel.Created).TotalMinutes;
if (elapsedMinutes > _maxElapsedMinutes)
{
throw new TimeoutException();
}
reservationEntity.MoveInTime = reservationModel.MoveInTime;
reservationEntity.TotalCost = reservationModel.TotalCost;
if (reservationModel.Services?.Count > 0)
{
foreach (ServiceModel service in reservationModel.Services)
{
var reservationService = new DataLayer.Entities.ReservationService
{
ReservationId = (int)reservationModel.RoomReservationId,
HotelServiceId = service.HotelServiceId
};
await _dataContext.ReservationServices.AddAsync(reservationService);
}
}
}
_dataContext.RoomReservations.Update(reservationEntity);
_dataContext.SaveChanges();
}
public ReservationModel UpdateReservation(ReservationModel reservation)
{
throw new NotImplementedException();
}
