public void Configuration(IAppBuilder app)
{
ConfigureAuth(app);
Initer.Init(@"Server=ADWA;Database=Hotel;Trusted_Connection=true");
var clientData = new ClientData("test", "test", "test", "test");
var client = new Client { ClientData = clientData };
var repo = new ClientRepository();
repo.Save(client);
var features = new List<Feature>();
features.Add(Feature.Bathroom);
var room = new Room { Quality = RoomQuality.Average, Features = features, Type = RoomType.HotelRoom };
room.SetCapacity(5);
var roomRepo = new RoomRepository();
roomRepo.Save(room);
var features2 = new List<Feature>();
features2.Add(Feature.Bathroom);
features2.Add(Feature.Tv);
var room2 = new Room { Quality = RoomQuality.Good, Features = features2, Type = RoomType.HotelRoom };
room2.SetCapacity(2);
roomRepo.Save(room2);
var duration = new DayDuration(DateTime.Now, DateTime.Now.AddDays(1));
var reservation = new Reservation(client, room, duration);
var reservationRepo = new ReservationRepository();
reservationRepo.Save(reservation);
}
public void OnBookingTableReservationWithValidValue_ReturnSuccess()
{
var bookingDetail = new BookingDetail()
{
BookingId = Guid.NewGuid(),
BookingDate = new DateTime(2015, 08, 29),
CheckInTime = new TimeSpan(13, 30, 00),
TableId = 1,
CustomerDetail = new Person()
{
FirstName = "Balachandar",
MobileNumber = "903-426-7303"
}
};
var reservationRepository = new ReservationRepository();
var result = reservationRepository.BookTableReservation(bookingDetail);
Assert.IsTrue(result);
}
public async Task ShouldThrowExceptionWhenReservationIsPaid()
{
//Arrange
var context = new iReceptionDbContext(DbOptions);
var paidReservation = new Reservation
{
IsPaid = true
};
var repository = new ReservationRepository(context);
await context.Reservations.AddAsync(paidReservation);
await context.SaveChangesAsync();
//Act
var expectedExceptionMessage = "Reservation is already paid";
//Assert
var actualException = await Assert.ThrowsAsync <InvalidOperationException>
(async() => await repository.PayAsync(1));
actualException.Message.Should().BeEquivalentTo(expectedExceptionMessage);
}
public void Get_All_Returns_All_Reservations()
{
// Arrange
ReservationRepository repo = new ReservationRepository();
Book newBook1 = new Book()
{
Id = 1
};
Book newBook2 = new Book()
{
Id = 2
};
repo.Borrow(newBook1);
repo.Borrow(newBook2);
// Act
IEnumerable <Reservation> reservations = repo.GetAll();
// Asert
Assert.Equal(2, reservations.ToArray().Length);
}
public void ButtonResCancelClick(IReservationForm ResFormView, string inKod)
{
try
{
if (ReservationRepository.getInstance().reservationExists(inKod))
{
Reservation res = ReservationRepository.getInstance().getReservationByCode(inKod);
RemoveReservation(inKod);
EventRepository.getInstance().AddTickets(res.TicketAmount, res.ResEvent.Name);
List <Event> list = EventController.getInstance().GetEventList();
EventController.getInstance().NotifyObservers(list);
MessageBox.Show("Rezervacija " + inKod + " je otkazana!");
}
}
catch (ReservationDoesntExist ex)
{
MessageBox.Show("Rezervacija s upidanim kodom ne postoji!");
}
}
static public void Publish(FlightSchedule updatedSchedule)
{
var connString = Environment.GetEnvironmentVariable("TravelCompanion", EnvironmentVariableTarget.Process);
var flightsRepository = new FlightRepository(connString);
var reservationsRepository = new ReservationRepository(connString);
Flight updatedFlight = flightsRepository.GetFlight(updatedSchedule.Flight.FlightId);
var reservations = reservationsRepository.FindBy(
r => r.DepartureFlight.FlightScheduleID == updatedSchedule.FlightScheduleId);
var travelers = from r in reservations
select r.TravelerId;
var notification = new ToastNotificationTextAndImage
{
TargetClientDevices = travelers.ToList(),
TextHeading = string.Format("Flight {0} Was Rescheduled", updatedFlight.FlightNumber),
TextBodyWrap = string.Format("Flight {0} was rescheduled for {1}", updatedFlight.FlightNumber, updatedSchedule.ActualDeparture)
};
WNSManager.DispatchNotification(notification);
}
public override async Task UpdateWithNoIdShouldReturnExceptionAsync()
{
int id = 1000;
var options = new DbContextOptionsBuilder <Project15Context>()
.UseInMemoryDatabase("db_reservation_test_updateByWrongId_Exception").Options;
// arrange (use the context directly - we assume that works)
using (var db = new Project15Context(options));
// assert (for assert, once again use the context directly for verify.)
using (var db = new Project15Context(options))
{
var repo = new ReservationRepository(db);
Reservation reservation = await repo.GetByIdAsync(id);
Assert.Null(reservation);
await Assert.ThrowsAsync <ArgumentException>(() => repo.UpdateAsync(reservation, id));
}
}
public ManageController(
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
ILogger <ManageController> logger,
UrlEncoder urlEncoder,
IServiceProvider serviceProvider,
IHttpContextAccessor httpContextAccessor,
ApplicationDbContext context,
IHostingEnvironment hostingEnvironment)
{
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_logger = logger;
_urlEncoder = urlEncoder;
this._httpContextAccessor = httpContextAccessor;
_serviceProvider = serviceProvider;
_context = context;
this.rr = new ReservationRepository(context);
_hostingEnvironment = hostingEnvironment;
}
private void btnCreateReservation_Click_1(object sender, EventArgs e)
{
int creator;
try
{
Reservation rez = new Reservation();
rez.CustomerID = Convert.ToInt32(lblcustomer.Text);
rez.TableID = Convert.ToInt32(lbltable.Text);
rez.ReservationDate = dtmPickDate.Value;
creator = Convert.ToInt32(lblStaffid.Text);
rez.CreatorID = creator;
ReservationRepository rp = new ReservationRepository();
rp.Add(rez);
}
catch
{
MessageBox.Show("Lütfen Bilglileri Doğru ve Düzgün Giriniz!");
}
Order order = new Order();
order.TableID = Convert.ToInt32(lbltable.Text);
order.CustomerID = Convert.ToInt32(lblcustomer.Text);
creator = Convert.ToInt32(lblStaffid.Text);
order.OrderTakerStaffID = creator;
order.FoodStatusID = 1002;
order.PaymentStatusID = 3;
order.CreatorID = creator;
OrderRepository op = new OrderRepository();
op.Add(order);
try
{
}
catch
{
MessageBox.Show("Hata!");
}
}
public void CancelReservation(string confirmationCode)
{
using (IReservationRepository reservationRepository = new ReservationRepository(ConnectionName))
{
var existingReservation = reservationRepository.FindBy(r => r.ConfirmationCode == confirmationCode).SingleOrDefault();
if (existingReservation == null)
{
throw new FaultException("Reservation not found");
}
// Canceling a reservation is logical, not physical
// meaning the trips are marked as canceled, instead of
// being deleted from the database
existingReservation.DepartureFlight.Status = FlightStatus.Canceled;
if (existingReservation.ReturnFlight != null)
{
existingReservation.ReturnFlight.Status = FlightStatus.Canceled;
}
reservationRepository.Save();
}
}
public void Delete_Removes_Correct_Reservation()
{
// Arrange
LibraryContextMock mockContext = new LibraryContextMock();
ReservationRepository repo = new ReservationRepository(mockContext);
BookRepository bookRepo = new BookRepository(mockContext);
Book newBook = new Book()
{
title = "New title",
author = "New author",
isbn = "22222",
publishDate = "2001"
};
Reservation newReservation1 = new Reservation()
{
id = 0, book = newBook
};
Reservation newReservation2 = new Reservation()
{
id = 1, book = newBook
};
Reservation newReservation3 = new Reservation()
{
id = 2, book = newBook
};
bookRepo.Add(newBook);
repo.Add(newReservation1);
repo.Add(newReservation2);
repo.Add(newReservation3);
// Act
repo.Remove(1);
IEnumerable <Reservation> Reservations = repo.GetAll();
// Asert
Assert.Equal(new Reservation[] { newReservation1, newReservation3 }, Reservations.ToArray());
}
public async Task ShouldAddNewReservation()
{
//Arrange
var context = new iReceptionDbContext(DbOptions);
var roomToReturn = new Room
{
PricePerDay = 10
};
await context.Rooms.AddAsync(roomToReturn);
await context.SaveChangesAsync();
var repository = new ReservationRepository(context);
var convertedDto = new Reservation
{
StartDate = new DateTime(2020, 7, 23),
EndDate = new DateTime(2020, 7, 30),
RoomId = 1,
ClientId = 1,
};
//Act
var actual = await repository.AddAsync(convertedDto);
var actualObject = await context.Reservations.OrderByDescending(r => r.Id).FirstOrDefaultAsync();
var expected = 1;
var expectedBalance =
(convertedDto.EndDate - convertedDto.StartDate).Days * roomToReturn.PricePerDay;
//Assert
Assert.Equal(expected, actual);
Assert.Equal(expectedBalance, actualObject.Balance);
Assert.False(actualObject.IsPaid);
Assert.False(actualObject.Active);
Assert.False(actualObject.IsDeleted);
}
public void Borrow_Return_Borrow_Inserts_New_Reservations()
{
// Arrange
ReservationRepository repo = new ReservationRepository();
Book newBook = new Book()
{
Id = 0
};
// Act
repo.Borrow(newBook);
repo.Return(newBook);
repo.Borrow(newBook);
IEnumerable <Reservation> reservations = repo.GetAll();
// Asert
Assert.Equal(0, reservations.ToArray()[0].BookId);
Assert.NotEqual(null, reservations.ToArray()[0].StartDate);
Assert.NotEqual(null, reservations.ToArray()[0].EndDate);
Assert.Equal(0, reservations.ToArray()[1].BookId);
Assert.NotEqual(null, reservations.ToArray()[1].StartDate);
Assert.Equal(null, reservations.ToArray()[1].EndDate);
}
public ActionResult Edit(ReservationsEditViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
ReservationRepository repository = new ReservationRepository();
Reservation reservation = new Reservation();
reservation.ID = model.ID;
reservation.UserId = model.UserId;
reservation.RestaurantId = model.RestaurantId;
reservation.PeopleCount = model.PeopleCount;
reservation.ReservationTime = model.ReservationTime;
reservation.Comment = model.Comment;
repository.Save(reservation);
return(RedirectToAction("Index"));
}
/// <summary>
/// Override of <see cref="LoadAllAsync"/> to use <see cref="ReservationRepository"/> instead for including navigation properties
/// </summary>
/// <returns></returns>
protected override async Task LoadAllAsync()
{
// Create factory, and get the instance
RepositoryFactory <ReservationRepository, Reservation> reservationFactory = RepositoryFactory <ReservationRepository, Reservation> .GetInstance();
// Create repository with the factory
ReservationRepository reservationRepository = reservationFactory.Create();
// Get all reservations
IEnumerable <Reservation> reservations = await reservationRepository.GetAllAsync();
// Replace collection
Items.ReplaceWith(reservations);
// Create factory, and get the instance
RepositoryFactory <RepositoryBase <Court>, Court> courtFactory = RepositoryFactory <RepositoryBase <Court>, Court> .GetInstance();
// Create repository with the factory
RepositoryBase <Court> courtRepository = courtFactory.Create();
// Get all reservations
IEnumerable <Court> courts = await courtRepository.GetAllAsync();
// Replace collection
Courts.ReplaceWith(courts);
// Create factory, and get the instance
RepositoryFactory <RepositoryBase <Member>, Member> memberFactory = RepositoryFactory <RepositoryBase <Member>, Member> .GetInstance();
// Create repository with the factory
RepositoryBase <Member> memberRepository = memberFactory.Create();
// Get all reservations
IEnumerable <Member> members = await memberRepository.GetAllAsync();
// Replace collection
Members.ReplaceWith(members);
}
public static async Task GetReservations_converts_raw_items_to_reservations()
{
var mockDatabaseProvider = new Mock <IDatabaseProvider>(MockBehavior.Strict);
SetupMockRepository(
mockDatabaseProvider,
new YearMonth(2020, 8),
CreateRawItem(
"2020-08",
KeyValuePair.Create("02", new List <string> {
"User1", "User2"
}),
KeyValuePair.Create("13", new List <string> {
"User1"
})));
SetupMockRepository(
mockDatabaseProvider,
new YearMonth(2020, 9),
CreateRawItem(
"2020-09", KeyValuePair.Create("02", new List <string> {
"User1"
})));
var reservationRepository = new ReservationRepository(
Mock.Of <ILogger <ReservationRepository> >(), mockDatabaseProvider.Object);
var result = await reservationRepository.GetReservations(1.August(2020), 30.September(2020));
Assert.NotNull(result);
Assert.Equal(4, result.Count);
CheckReservation(result, "User1", 2.August(2020));
CheckReservation(result, "User2", 2.August(2020));
CheckReservation(result, "User1", 13.August(2020));
CheckReservation(result, "User1", 2.September(2020));
}
public JsonResult AddStandingTeeTime(BookStandingTeeTimeReservationVM objBoookstanding)
{
string message = string.Empty;
bool status = false;
try
{
if (objBoookstanding != null)
{
string[] reserve = objBoookstanding.RequestedTime.Split(',');
int hours = int.Parse(reserve[0]);
int minutes = int.Parse(reserve[1]);
if (reserve[2] == "PM" && hours != 12)
{
hours += 12;
}
var timeTee = hours.ToString() + ":" + minutes.ToString();
objBoookstanding.RequestedTime = timeTee;
var response = new ReservationRepository().AddStandingReservation(objBoookstanding);
if (response)
{
status = response;
message = "Successfully added";
return(Json(new { status = status, message = message }, JsonRequestBehavior.AllowGet));
}
}
}
catch (Exception ex)
{
status = false; message = ex.Message.ToString();
return(Json(new { status = status, message = message }, JsonRequestBehavior.AllowGet));
}
return(Json(new { status = status, message = message }, JsonRequestBehavior.AllowGet));
}
public void UoW_with_Default_Context_Saves_To_and_Retrieves_from_Database()
{
var uow = new UnitOfWork(); //defaults to BAEntities context
var cRep = new CustomerRepository(uow);
var rRep = new ReservationRepository(uow);
var customer = cRep.GetById(20);
var newNotes = DateTime.Now.ToString();
customer.Notes = newNotes;
var resCount = rRep.GetReservationsForCustomer(20).Count;
var newRes = new Reservation
{
Customer = customer, TripID = 3, ReservationDate = new DateTime(2010, 10, 10)
};
customer.Reservations.Add(newRes);
uow.Save();
uow = new UnitOfWork();
cRep = new CustomerRepository(uow);
rRep = new ReservationRepository(uow);
customer = cRep.GetById(20);
Assert.IsTrue(customer.Notes == newNotes);
Assert.IsTrue(rRep.GetReservationsForCustomer(20).Count == resCount + 1);
}
public void Update_updates_Correct_Reservation()
{
// Arrange
LibraryContextMock mockContext = new LibraryContextMock();
ReservationRepository repo = new ReservationRepository(mockContext);
BookRepository bookRepo = new BookRepository(mockContext);
Book newBook = new Book()
{
title = "New title",
author = "New author",
isbn = "22222",
publishDate = "2001"
};
Reservation oldReservation = new Reservation()
{
book = newBook,
startDate = new System.DateTime(2016, 1, 1, 1, 0, 0),
endDate = new System.DateTime(2016, 1, 1, 2, 0, 0),
};
Reservation newReservation = new Reservation()
{
book = newBook,
startDate = new System.DateTime(2016, 1, 1, 3, 0, 0),
endDate = new System.DateTime(2016, 1, 1, 4, 0, 0),
};
bookRepo.Add(newBook);
repo.Add(oldReservation);
// Act
repo.Update(newReservation, 0);
IEnumerable <Reservation> Reservations = repo.GetAll();
// Asert
Assert.Equal(new Reservation[] { newReservation }, Reservations.ToArray());
}
public Response <Car> FetchAvailableCarsForResv(int UserID, DateTime startingDate, DateTime endTime)
{
try
{
Response <Car> res = new Response <Car>();
if (DateValidation.CheckIfValid(startingDate, endTime)) // check the dates if they are valid (more detail in the function definition)
{
using (var repo = new ReservationRepository())
{
res.Data = repo.FetchAvailableCarsForResv(UserID, startingDate, endTime);
if (res.Data.Count > 0)
{
res.Message = "Rezervasyon için uygun olan arabaların listesi";
res.isSuccess = true;
}
else
{
res.Message = "Rezervasyona uygun araçları getirirken bir hata ile karşılaşıldı";
res.isSuccess = false;
}
return(res);
}
}
else
{
res.Message = "Geçersiz rezervasyon tarihleri !";
res.isSuccess = false;
}
return(res);
}
catch (Exception ex)
{
throw new Exception("An error occured in FetchAvailableCarsForResv() in SpiceApp.BusinessLayer.CarBusiness", ex);
}
}
public Response <Reservation> CancelReservation(int ReservationID)
{
try
{
Response <Reservation> res = new Response <Reservation>();
using (var repo = new ReservationRepository())
{
res.isSuccess = repo.DeleteById(ReservationID);
if (res.isSuccess)
{
res.Message = "Rezervasyon başarıyla iptal edildi";
}
else
{
res.Message = "Rezervasyon iptal edilirken bir sorun ile karşılaşıldı";
}
}
return(res);
} catch (Exception ex)
{
throw new Exception("An error occured in CancelReservation() func. in SpiceApp.BusinessLayer.ReservationBusiness", ex);
}
}
public void ButtonResOKClick(IReservationForm ResFormView, string inKod)
{
try
{
if (ReservationRepository.getInstance().reservationExists(inKod))
{
Reservation res = ReservationRepository.getInstance().getReservationByCode(inKod);
RemoveReservation(inKod);
DateTime time = DateTime.Now;
string str = time.ToString();
byte[] buffer = new byte[str.Length];
int i = 0;
foreach (char c in str.ToCharArray())
{
buffer[i] = (byte)c;
i++;
}
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
string md5string = BitConverter.ToString(md5.ComputeHash(buffer)).Replace("-", "");
BillController.getInstance().AddNewBill(md5string, res.TicketAmount, time, res.ResEvent);
Bill bill = BillRepository.getInstance().getBillByCode(md5string);
AddNewPaidReservation(res, bill);
MessageBox.Show("Uspješna kupovina!\n\nRačun:\n\nŠifra: " + bill.Code + "\nDogađaj: " + bill.PaidEvent.Name + "\nKoličina: " + bill.TicketAmount.ToString());
}
}
catch (ReservationDoesntExist ex)
{
MessageBox.Show("Rezervacija s upidanim kodom ne postoji!");
}
}
public void OneTimeSetUp()
{
_adminEditReservationPage = new AdminEditReservationPage(Driver);
_reservationRepository = new ReservationRepository();
}
public ReservationsHandler(ReservationRepository repository)
{
_repository = repository;
}
public SaveChanges(ReservationRepository reservationRepository)
{
_reservationRepository = reservationRepository;
}
public ReservationsController(ReservationRepository repo)
{
_res = repo;
}
public GraphQLController(ReservationRepository reservationRepository)
{
this.reservationRepository = reservationRepository;
}
public void DeleteAllCreatedReservations(int expectedId)
{
var reservationRepository = new ReservationRepository();
reservationRepository.DeleteAllReservationsFromUserId(expectedId);
}
public ReservationsController()
{
this._reservationRepo = new ReservationRepository();
}
public HomeController(ApplicationDbContext context, UserManager <ApplicationUser> userManager)
{
_context = context;
this.rr = new ReservationRepository(context);
_userManager = userManager;
}
public ReservationsController()
{
db = new RentCDb();
reservationRepository = new ReservationRepository();
}
public ManageReservation()
{
reservationRepository = new ReservationRepository(new DBVRContext());
}
