public async Task ThrowErrorIfNotBooking(int bookingId)
{
try
{
var options = GetFakeConnection();
using (var context = new LibraryContext(options))
{
await context.Database.OpenConnectionAsync();
context.Database.EnsureCreated();
var repository = new BookingRepository(context);
var bookRepository = new BookRepository(context);
var bookManager = new BookManager(bookRepository, repository);
var manager = new BookingManager(repository, bookManager);
await Assert.ThrowsAsync <InvalidOperationException>(
async() =>
{
await manager.TakeAsync(bookingId);
});
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> Edit(int id, [Bind("CustomerId,CustFirstName,CustLastName,CustAddress,CustCity,CustProv,CustPostal,CustCountry,CustHomePhone,CustBusPhone,CustEmail,Username,Password,ConfirmPassword,AgentId")] Customers customers)
{
id = BookingManager.GetUserId(User.Identity.Name);
if (id != customers.CustomerId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(customers);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomersExists(customers.CustomerId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index", "Bookings"));
}
ViewData["AgentId"] = new SelectList(_context.Agents, "AgentId", "AgentId", customers.AgentId);
return(View(customers));
}
public IHttpActionResult DeleteBooking([FromUri] int id)
{
BookingManager rm = new BookingManager();
rm.DeleteBooking(id);
return(Ok());
}
public void GetFullyOccupiedDates_FullyOccupiedDates_ListOfFour()
{
// Arange
DateTime startDate = DateTime.Today.AddDays(10);
DateTime endDate = DateTime.Today.AddDays(13);
var bookingRepo = new Mock <IRepository <Booking> >();
bookingRepo.Setup(b => b.GetAll());
var roomRepo = new Mock <IRepository <Room> >();
roomRepo.Setup(r => r.GetAll());
BookingManager mgr = new BookingManager(bookingRepo.Object, roomRepo.Object);
List <DateTime> fullyOccupiedDates = new List <DateTime>();
fullyOccupiedDates.Add(startDate);
fullyOccupiedDates.Add(startDate.AddDays(1));
fullyOccupiedDates.Add(startDate.AddDays(2));
fullyOccupiedDates.Add(startDate.AddDays(3));
// Act
var result = bookingManager.GetFullyOccupiedDates(startDate, endDate);
// Assert
Assert.Equal(fullyOccupiedDates, result);
}
public void resetCars()
{
var distanceManager = new Mock <IDistanceManager>();
var timeManager = new Mock <ITimeManager>();
var bookingManager = new BookingManager(distanceManager.Object, timeManager.Object);
bool flag = false;
BookCarRequestModel bookCarRequestModel = new BookCarRequestModel(1, "C1", new DestinationOrigin(1, 1, false), new DestinationOrigin(2, 2, false));
bookingManager.bookCar(bookCarRequestModel);
bookingManager.incrementTimeStamp();
bookingManager.reset();
BookingManager.lstCars.ForEach(c =>
{
if (c.isBooked == true)
{
flag = true;
}
});
Assert.True(flag == false);
}
public ActionResult AdminBookings()
{
List <AdminBookingList> allBookings = BookingManager.GetAdminBookingList();
return(View("~/Views/Booking/AdminBookings.cshtml", allBookings));
}
public void FindAvailableRoom_StartDateNotInTheFuture_ThrowsArgumentException()
{
BookingManager manager = CreateBookingManager();
DateTime date = DateTime.Today;
Assert.Catch <ArgumentException>(() => manager.FindAvailableRoom(date, date));
}
//update price on website
private void UpdatePrice(int addid)
{
manager = new BookingManager();
manager.CurrentType = (int)CurrentType;
manager.CurrentAddId = addid;
int price = manager.Roomprice();
string outputprice = price.ToString() + " kr";
//check discount
if (manager.CurrentType == 3)
{
DateTime arrivalDate = starteDate.SelectedDate;
DateTime departureDate = endDate.SelectedDate;
double totaldays = (departureDate - arrivalDate).TotalDays;
if (totaldays > 5)
{
double discount = price / 100 * 20;
price = price - (int)discount;
outputprice = price.ToString() + $" discount({discount}) kr";
}
}
Price.Text = outputprice;
}
public void YearToDisplay_YearIsPastMinYear_Returns2016()
{
BookingManager manager = CreateBookingManager();
var result = manager.YearToDisplay(2015);
Assert.AreEqual(2016, result);
}
public IEnumerable <BookingVM> GetAllBookings()
{
var mng = new BookingManager();
var bookings = BookingMapper.MapListOfBookings(mng.GetAllBookings());
return(bookings);
}
public IEnumerable <BookingVM> GetBookingFromDateRange(DateTime start, DateTime end, int roomId)
{
var mng = new BookingManager();
var bookings = BookingMapper.MapListOfBookings(mng.GetBookingInRange(start, end));
return(bookings.Where(b => b.RoomId == roomId));
}
public async Task ShowBookIsUnavailable()
{
try
{
var options = GetFakeConnection();
using (var context = new LibraryContext(options))
{
await context.Database.OpenConnectionAsync();
context.Database.EnsureCreated();
var repository = new BookRepository(context);
var bookingRepository = new BookingRepository(context);
var manager = new BookManager(repository, bookingRepository);
BookingManager bookingManager = new BookingManager(bookingRepository, manager);
var bookId = GenerateBookId(context, 1);
var bookingModel = GetBookingModel(context, bookId);
int bookingId = await bookingManager.ReserveAsync(bookingModel);
if (bookingId > 0)
{
var isAvailable = await manager.IsBookAvailableAsync(bookId);
Assert.False(isAvailable);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task NotReserveIfUnavailable()
{
try
{
var options = GetFakeConnection();
using (var context = new LibraryContext(options))
{
await context.Database.OpenConnectionAsync();
context.Database.EnsureCreated();
var model = GetBookingModel(context, 1);
var repository = new BookingRepository(context);
var bookRepository = new BookRepository(context);
var bookManager = new BookManager(bookRepository, repository);
var manager = new BookingManager(repository, bookManager);
int bookingId = await manager.ReserveAsync(model);
Assert.InRange <int>(bookingId, 1, 2);
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task ChangeBookingStatusSuccessfully()
{
try
{
var options = GetFakeConnection();
using (var context = new LibraryContext(options))
{
await context.Database.OpenConnectionAsync();
context.Database.EnsureCreated();
var repository = new BookingRepository(context);
var bookRepository = new BookRepository(context);
var bookManager = new BookManager(bookRepository, repository);
var manager = new BookingManager(repository, bookManager);
var booking = GetBookingModel(context, 1);
var bookingId = await manager.ReserveAsync(booking);
if (bookingId > 0)
{
await manager.TakeAsync(bookingId);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public void GetCities_Negative_Exception_CitiesReturned()
{
var _mockDataService = new Mock <SearchCityTypeService>();
_mockDataService.Setup(p => p.GetCities()).Throws <Exception>();
var _bookingManager = new BookingManager(_mockDataService.Object);
//var _responseExpected = new Acknowledgement<string>
//{
// code = 2,
// Set = null,
// Message = "Something Went Wrong in Server",
//};
//Act
try
{
var responseReturned = _bookingManager.GetCities();
Assert.IsFalse(true);
}
catch
{
Assert.IsTrue(true);
}
//Assert
}
public void YearToDisplay_YearIsOverMaxYear_Returns2017()
{
BookingManager manager = CreateBookingManager();
var result = manager.YearToDisplay(2018);
Assert.AreEqual(2017, result);
}
public void AddToBooking_Negative_RoomIdNotThere()
{
Book toBeBooked = new Book
{
RenterId = 2,
RoomId = 3,
Status = "alloted"
};
Acknowledgement <Book> bookAcknowledgement = new Acknowledgement <Book>();
bookAcknowledgement.code = 0;
bookAcknowledgement.Set = null;
bookAcknowledgement.Message = "fail";
//Arrange
var _mockDataService = new Mock <BookingService>();
_mockDataService.Setup(p => p.AddToBooking(toBeBooked)).Throws(new RoomIdNotThere());
var _bookingManager = new BookingManager(_mockDataService.Object);
try
{
var responseReturned = _bookingManager.AddToBooking(toBeBooked);
Assert.IsTrue(false);
}
catch
{
Assert.IsTrue(true);
}
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
if (!IsValid)
{
return;
}
if (txtNumberOfGuests.Text.Length == 0)
{
txtNumberOfGuests.Text = "1";
}
Booking booking = new Booking
{
ClientName = txtClientName.Text,
NumberOfGuests = Convert.ToInt32(txtNumberOfGuests.Text),
ArrivalDate = Convert.ToDateTime(txtArrivalDate.Text),
EmailAddress = txtEmailAddress.Text
};
try
{
BookingManager.PlaceBooking(booking);
}
catch (ValidationException ex)
{
Validators.Add(new ValidationError(ex.Message));
return;
}
divForm.Visible = false;
divSuccess.Visible = true;
}
public IActionResult Post(Booking booking)
{
try
{
if (!Request.Headers.ContainsKey("access_token"))
{
return(Unauthorized());
}
string token = Request.Headers["access_token"];
var authManager = new AuthorizationManager();
var tokenStatus = authManager.CheckToken(token);
if (tokenStatus == TokenStatusesEnum.Invalid)
{
return(Json(new { error = "Invalid token", error_description = "Given token is invalid" }));
}
else if (tokenStatus == TokenStatusesEnum.Expired)
{
return(Json(new { error = "Expired token", error_description = "Given token is expired. Please refresh it." }));
}
//var booking = JsonConvert.DeserializeObject<Booking>(bookingStr);
booking.InitId();
var savedBooking = new BookingManager().AddBooking(booking);
var bill = new BillingManager().AddBill(booking.DaysCount * 1500, "OOO Sberbank 91929393234923", savedBooking.Id);
savedBooking.Bill = bill;
return(Json(savedBooking));
}
catch (Exception e)
{
return(Json(new { error = "Internal server error", error_description = JsonConvert.SerializeObject(e, Formatting.Indented) }));
}
}
private long _insertBooking(BookingEmail bookingEmail, long clientId, long propertyId, string bookingNo)
{
long bookingId = 0;
try
{
Booking data = new Booking();
data.FromDate = Convert.ToDateTime(bookingEmail.FromDate);
data.FromHour = bookingEmail.FromHour;
data.MaximumPerson = bookingEmail.MaximumPerson;
data.PropertyId = Convert.ToInt32(propertyId);
data.ToDate = Convert.ToDateTime(bookingEmail.ToDate);
data.ToHour = bookingEmail.ToHour;
data.ClientId = clientId;
data.CreatedBy = bookingEmail.Email.Trim();
data.CreatedDate = DateTime.Now;
data.UpdateBy = bookingEmail.Email.Trim();
data.UpdateDate = DateTime.Now;
data.BookingNo = bookingNo;
bookingId = BookingManager.InsertBooking(data);
}
catch (Exception exception)
{
Console.WriteLine(exception);
throw;
}
return(bookingId);
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
if (!IsValid)
{
return;
}
if (txtNumberOfGuests.Text.Length == 0)
{
txtNumberOfGuests.Text = "1";
}
Booking booking = new Booking
{
ClientName = txtClientName.Text,
NumberOfGuests = Convert.ToInt32(txtNumberOfGuests.Text),
ArrivalDate = Convert.ToDateTime(txtArrivalDate.Text),
EmailAddress = txtEmailAddress.Text
};
BookingManager.PlaceBooking(booking);
divForm.Visible = false;
divSuccess.Visible = true;
}
public void GetSearchedRoomDetails_Negative_RoomsReturned()
{
var _mockDataService = new Mock <SearchCityTypeService>();
SearchCityType search = new SearchCityType
{
city = " ",
roomType = "234"
};
List <SearchedRoomData> gettingData = new List <SearchedRoomData>();
gettingData.Add(GetSearchedRoomData());
Acknowledgement <SearchedRoomData> _returnedData = new Acknowledgement <SearchedRoomData>
{
code = 3,
Set = null,
Message = "Invalid Input"
};
_mockDataService.Setup(p => p.GetSearchedRoomDetails(search)).Returns(gettingData);
var _bookingManager = new BookingManager(_mockDataService.Object);
//Act
var responseReturned = _bookingManager.GetSearchedRoomDetails(search);
//Assert.
Assert.ReferenceEquals(responseReturned, _returnedData);
}
void SetUpGame()
{
GameRandom = new System.Random();
RealDate = new Date();
RealDate.Day = 1;
RealDate.Month = 1;
RealDate.Year = 1;
FightManager = new FightManager();
ActivityManager = new ActivityManager();
CurrentLeagueFighterDatabase = new FighterDatabase();
TeamManager = new TeamManager();
BookingManager = new BookingManager();
PlayerManager = new PlayerManager();
CharacterDatabase = new CharacterDatabase();
WorldMethods.SetUpWorld();
GameObject.Find("FighterListContent").GetComponent <FighterListContent> ().SetUp(CurrentLeagueFighterDatabase.AllFighters);
GameObject.Find("TeamListContent").GetComponent <TeamListContent> ().SetUp(TeamManager.TeamsInLeague);
GameObject.Find("FightsPlannedListContent").GetComponent <FightPlanListContent> ().SetUp(BookingManager.Calendar);
CharacterDatabase.SetUpCharacterDatabase();
//Check whether the ID assignment has occurred properly
print("Total Characters: " + CharacterDatabase.AllCharacters.Count);
print("Highest ID: " + CharacterDatabase.UsedIDs + " (Should be the same as Total Characters)");
OpinionManager = new Opinion();
}
public void AddingToWishlist_Negative()
{
WishList wishReceived = new WishList();
wishReceived.WishListId = 1;
wishReceived.RenterId = 2;
wishReceived.RoomId = 4;
WishListDuplicate wishListDuplicate = new WishListDuplicate();
wishListDuplicate.WishListId = 1;
wishListDuplicate.RenterId = 2;
wishListDuplicate.RoomId = 4;
List <WishListDuplicate> returnedWishlist = new List <WishListDuplicate>();
returnedWishlist.Add(wishListDuplicate);
//Arrange
var _mockDataService = new Mock <BookingService>();
_mockDataService.Setup(p => p.AddingToWishList(wishReceived)).Throws <System.Exception>();
var _bookingManager = new BookingManager(_mockDataService.Object);
try
{
var responseReturned = _bookingManager.AddingToWishList(wishReceived);
Assert.IsTrue(false);
}
catch
{
Assert.IsTrue(true);
}
}
public void SetUp()
{
ExecuteScript("ClearTables.sql");
ExecuteScript("Services\\Bookings\\BookingManagerTests.sql");
_bookingManager = new BookingManager(_unitOfWork);
RunNonConflictingReservations();
}
public void DisplayWishList_Negative()
{
int renterId = 2;
Acknowledgement <Room> roomsAcknowledgement = new Acknowledgement <Room>();
roomsAcknowledgement.code = 0;
roomsAcknowledgement.Set = null;
roomsAcknowledgement.Message = "fail";
//Arrange
var _mockDataService = new Mock <BookingService>();
_mockDataService.Setup(p => p.DisplayWishList(renterId)).Throws <System.Exception>();
var _bookingManager = new BookingManager(_mockDataService.Object);
try
{
var responseReturned = _bookingManager.DisplayWishList(renterId);
Assert.IsTrue(false);
}
catch
{
Assert.IsTrue(true);
}
}
public IHttpActionResult GetAvaibleResources([FromBody] DatesDto dates)
{
BookingManager bm = new BookingManager();
bm.CheckAvaibleResources(dates.DateStart, dates.DateEnd);
return(Ok());
}
public void DeleteFromWishList_Negative()
{
int renterId = 2;
WishListDuplicate wishListDuplicateReceieved = new WishListDuplicate
{
RenterId = 2,
RoomId = 3
};
Acknowledgement <WishListDuplicate> wishlistAcknowledgement = new Acknowledgement <WishListDuplicate>();
wishlistAcknowledgement.code = 0;
wishlistAcknowledgement.Set = null;
wishlistAcknowledgement.Message = "fail";
//Arrange
var _mockDataService = new Mock <BookingService>();
_mockDataService.Setup(p => p.RemoveFromWishList(wishListDuplicateReceieved)).Throws <System.Exception>();
var _bookingManager = new BookingManager(_mockDataService.Object);
try
{
var responseReturned = _bookingManager.DeleteFromWishList(wishListDuplicateReceieved);
Assert.IsTrue(false);
}
catch
{
Assert.IsTrue(true);
}
}
// Constructor by Default
public BookingManagerTest()
{
time = new DateManager();
fbr = new FakeBookingRepository(time.DtStartParameter, time.DtEndParameter);
frr = new FakeRoomRepository();
bm = new BookingManager(fbr, frr);
}
public async void GenerateBookingReferenceAsync_ReferenceChangesBasedOnIdAndDateTimeCreated()
{
using (var mock = AutoMock.GetLoose())
{
Booking booking1 = new Booking
{
DateTimeCreated = DateTime.Now,
Id = 1
};
Booking booking2 = new Booking
{
DateTimeCreated = DateTime.Now.AddSeconds(0.5),
Id = 1
};
Booking booking3 = new Booking
{
DateTimeCreated = DateTime.Now,
Id = 3
};
BookingManager bookingManager = mock.Create <BookingManager>();
string ref1 = await bookingManager.GenerateBookingReferenceAsync(booking1);
string ref2 = await bookingManager.GenerateBookingReferenceAsync(booking2);
string ref3 = await bookingManager.GenerateBookingReferenceAsync(booking3);
Assert.True(ref1 != ref2);
Assert.True(ref1 != ref3);
Assert.True(ref2 != ref3);
}
}
