public async Task <IActionResult> ReserveCar(PostModel model)
{
DateTime DateStart = DateTime.Parse(model.DateStart);
DateTime DateReturn = DateTime.Parse(model.DateReturn);
CarBooking CB = new CarBooking();
List <Location> Locations = _context.Locations.ToList();
List <CarBooking> CarBookings = await _context.CarBookings.ToListAsync();
List <Car> Cars = await _context.Cars.ToListAsync();
Car Car1 = Cars.Find(item => item.Id == model.CarId);
//List<Rating> rl = _context.Rating.ToList();
var Company = await _context.RentCompanies.FindAsync(model.RCId);
CB.PassportNum = model.PassportNumber;
CB.Username = model.Username;
CB.ReserveStart = DateStart;
CB.ReserveEnd = DateReturn;
CB.TotalPrice = Double.Parse(model.TotalPrice);
CB.Car = Car1;
CB.Location = Locations.Find(item => item.Location1 == model.Location);
Company.CarBookings = new List <CarBooking>();
Company.CarBookings.Add(CB);
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> Edit(int id, [Bind("BookingID,StartDate,FinishDate,DaysTaken,UserID,CarID,TotalPrice")] CarBooking carBooking)
{
if (id != carBooking.BookingID)
{
return(NotFound());
}
if (_userManager.GetUserId(User) != carBooking.UserID && !User.IsInRole("Admin"))
{
return(new RedirectResult("/Identity/Account/AccessDenied"));
}
if (ModelState.IsValid)
{
try
{
carBooking.BookingConfirmed = true;
_context.Update(carBooking);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CarBookingExists(carBooking.BookingID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CarID"] = carBooking.CarID;
return(View(carBooking));
}
public async void BookingControllerTests_AddAndRemoveBooking()
{
var carBooking = new CarBooking
{
BookerName = "Mathias " + Guid.NewGuid(),
BookingStartDate = DateTime.Now,
BookingEndDate = DateTime.Now.AddDays(1),
BookerId = "1234",
};
var addResult = await _carTimesController.AddBookingAsync(carBooking);
var allBookings = _carTimesController.GetAllBookings();
var carBookingId = allBookings.FirstOrDefault(x => x.BookerName == carBooking.BookerName).ID;
var removeResult = await _carTimesController.RemoveBookingAsync(carBookingId);
var updatedAllBookings = _carTimesController.GetAllBookings();
var oldBookingWhichShouldBeNull = updatedAllBookings.FirstOrDefault(x => x.BookerName == carBooking.BookerName);
IEnumerable <CarBooking> bookings = _carTimesController.GetAllBookings();
var hasBooking = bookings.ToList().Exists(x => x.BookingStartDate == carBooking.BookingStartDate);
Assert.True(addResult);
Assert.True(carBookingId >= 0);
Assert.True(removeResult);
Assert.True(oldBookingWhichShouldBeNull == null);
}
public async Task BookingApi_RemoveABooking_DidBookAndRemoveItAgain()
{
var bookingApi = Container.Resolve <IBookingApi>();
var carBooking = new CarBooking()
{
BookerName = "Gabriella" + Guid.NewGuid(),
BookingStartDate = DateTime.Now,
BookingEndDate = DateTime.Now.AddDays(1),
};
var didBook = await bookingApi.MakingBookingAsync(carBooking);
var bookings = await bookingApi.GetBookingsAsync();
var newBooking = bookings.FirstOrDefault(
x => x.BookerName == carBooking.BookerName);
Assert.True(didBook);
Assert.True(newBooking != null);
var didRemoveBooking = await bookingApi.RemoveBookingAsync(newBooking.ID);
var bookingsAfterRemove = await bookingApi.GetBookingsAsync();
var newBookingStillExists = bookingsAfterRemove.Exists(
x => x.BookerName == carBooking.BookerName);
Assert.True(didRemoveBooking);
Assert.True(newBookingStillExists == false);
}
private async void MakeBooking()
{
using (LoadingManager.CreateLoadingScope())
{
var user = await _authenticationService.GetProfileAsync();
var carBooking = new CarBooking()
{
BookerName = user.Name,
BookerId = user.UserId,
BookingStartDate = bookingDate,
BookingEndDate = bookingDate.AddDays(1),
};
var didMakeBooking = await _bookingApi.MakingBookingAsync(carBooking);
if (didMakeBooking)
{
_toastService.ShortAlert("Booking as been made");
ScheduleReminder();
_navigationService.GoBack();
}
else
{
_toastService.ShortAlert("Failed to make the booking");
}
}
}
public void CreateCarBooking(CarBooking carBooking)
{
using IDbConnection connection = new MySqlConnection(DatabaseConnection.GetConnectionString());
connection.Execute($"INSERT INTO Bookings" +
$" (fk_pick_up_location_id, fk_drop_off_location_id, fk_car_id, fk_customer_id, pick_up_time, drop_off_time) " +
$"VALUES ('{carBooking.PickUpLocation.Id}', '{carBooking.DropOffLocation.Id}', '{carBooking.Car.Id}', '{carBooking.Customer.Id}', '{carBooking.TimeOfDropOff}', '{carBooking.TimeOfPickUp}');");
}
// Car service price calculation.
public double CarRentalCalculation(CarBooking carBooking)
{
double priceA = 0.0, priceB = 0.0, price = 0.0;
if (carBooking.DriverAge < 45)
{
priceB = (50 - carBooking.DriverAge) * 200;
}
else
{
priceB = (carBooking.DriverAge - 40) * 225;
}
if (carBooking.NumberOfSeats <= 5)
{
priceA = (carBooking.CarModel - 2010) * 600;
}
else
{
priceA = (carBooking.CarModel - 2010) * 900;
}
price = priceA + priceB;
if (carBooking.FuelType == "Diesel")
{
price = price + (price * 0.2);
}
return(Math.Round(price, 2));
}
public async Task <bool> AddBookingAsync([FromBody] CarBooking carDay)
{
var bookingKey = carDay.BookingStartDate.ToString("MM/dd/yyyy h:mm tt");
var hasBookingKey = HttpContext.Session.Keys.Contains(bookingKey);
if (hasBookingKey)
{
throw new Exception("Someone is alredy trying to make the booking");
}
try
{
HttpContext.Session.SetInt32(bookingKey, 1);
_logger.LogInformation($"Started adding booking, bookerName: {carDay?.BookerName}");
_context.CarBookings.Add(carDay);
_logger.LogInformation($"Added, bookerName: {carDay?.BookerName}");
var result = await _context.SaveChangesAsync();
_logger.LogInformation($"Result = {result}, bookerName: {carDay?.BookerName}");
return(result > 0);
}
catch (Exception ex)
{
_logger.LogInformation("Failed to post, ex:" + ex.Message);
throw;
}
finally
{
HttpContext.Session.Remove(bookingKey);
}
}
private static async Task <DialogTurnResult> SetPreferredCars(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
CarBooking booking = GetCarBookingObj(stepContext);
booking.PickupTime = ((String)stepContext.Result);
stepContext.Values["CarBookingObj"] = booking;
return(await stepContext.BeginDialogAsync(nameof(ChooseCarDialog), null, cancellationToken));
}
private static async Task <DialogTurnResult> SetPickupLocationStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
CarBooking booking = GetCarBookingObj(stepContext);
booking.Name = ((String)stepContext.Result);
stepContext.Values["CarBookingObj"] = booking;
var question = $"Hey **{booking.Name}**, Kindly provide your pickup location?";
return(await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = MessageFactory.Text(question) }, cancellationToken));
}
private static async Task <DialogTurnResult> SetPickupTimeStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
CarBooking booking = GetCarBookingObj(stepContext);
booking.DropOffLocation = ((String)stepContext.Result);
stepContext.Values["CarBookingObj"] = booking;
var question = $"I have saved your drop off location as **{booking.DropOffLocation}**.\n\n Kindly provide a suitable pickup time?";
return(await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = MessageFactory.Text(question) }, cancellationToken));
}
public void NavigateToBookingDetails(CarBooking carBooking)
{
var carBookingAsJson = JsonConvert.SerializeObject(carBooking);
var parms = new Dictionary <string, string>()
{
{ BookingDetailsViewModel.BookingParameterKey, carBookingAsJson }
};
NavigateTo(nameof(BookingDetailsView), parms);
}
public void ConfirmCarBooking()
{
CarController carBook = new CarController();
CarBooking payment = new CarBooking();
object res = carBook.ConfirmCarBooking(payment);
Assert.IsNotNull(res);
//Assert.AreNotSame(2, payment.CarType.IndexOf("Luxury"));
Assert.IsNull(payment.paymentDetails);
}
private async Task <DialogTurnResult> DisplaySummaryStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
CarBooking booking = GetCarBookingObj(stepContext);
booking.PrimaryCar = (string)(stepContext.Result as IList)[0];
booking.SecondaryCar = (string)(stepContext.Result as IList)[1];
string summary = $"Hey **{booking.Name}**, \n\nThanks for booking a car with SuperTaxi.\n\n You will be picked up from **{booking.PickupLocation}** at **{booking.PickupTime}** and will be dropped at **{booking.DropOffLocation}**.\n\nCar chosen for your trip is **{booking.PrimaryCar}**. In the **{booking.PrimaryCar}** is not available, we will be arranging a **{booking.SecondaryCar}**.\n\n Thanks again for your business.\n\nRegards Super Taxi";
await stepContext.Context.SendActivityAsync($"{summary}");
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
public override async Task OnViewInitializedAsync(Dictionary <string, string> navigationParameters)
{
booking = NavigationParameterParser.JsonConvertParameter <CarBooking>(
navigationParameters[BookingParameterKey]);
var bookingTitle = DateTimeToStringHelper.GetTitleFromDate(booking.BookingStartDate);
DateTitle = $"{bookingTitle}{System.Environment.NewLine}by {booking.BookerName}";
var user = await _authenticationService.GetProfileAsync();
IsBooker = booking.BookerId == user.UserId;
}
public async void BookingControllerTests_AddBooking()
{
var carBooking = new CarBooking
{
BookerName = "Mathias",
BookingStartDate = DateTime.Now,
BookingEndDate = DateTime.Now.AddDays(1),
BookerId = "1234",
};
var didBook = await _carTimesController.AddBookingAsync(carBooking);
Assert.True(didBook);
}
// testCase5
public void CountNumberOfServices()
{
HomePage homePage = new HomePage(Browser)
.ChooseBusinessClass();
BusinessClass businessClass = new BusinessClass(Browser)
.SelectFirstBusinessCar();
CarBooking carBooking = new CarBooking(Browser)
.InputDaysQuantity(2)
.ClickOrderButton();
Assert.AreNotEqual("0 0.00 BYN", carBooking.GetCartTotalText());
}
private static async Task <DialogTurnResult> BranchOutStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
CarBooking booking = GetCarBookingObj(stepContext);
booking.InterestedInSurvey = ((FoundChoice)stepContext.Result).Value;
if (booking.InterestedInSurvey == "Yes")
{
return(await stepContext.BeginDialogAsync(nameof(SurveyDialog), null, cancellationToken));
}
else
{
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
}
public void BookCarForZeroDays()
{
Logger.Log.Info("Start BookCarForZeroDays test.");
HomePage homePage = new HomePage(Driver)
.ChooseBusinessClass();
BusinessClass businessClass = new BusinessClass(Driver)
.SelectFirstBusinessCar();
CarBooking carBooking = new CarBooking(Driver)
.ClickOrderButton();
Assert.AreEqual(WarningsAndLetterings.EnterCorrectDays, carBooking.GetAlertText());
}
public void CountNumberOfServices()
{
Logger.Log.Info("Start CountNumberOfServices test.");
HomePage homePage = new HomePage(Driver)
.ChooseBusinessClass();
BusinessClass businessClass = new BusinessClass(Driver)
.SelectFirstBusinessCar();
CarBooking carBooking = new CarBooking(Driver)
.InputDaysQuantity(RandomGenerator.GetRandomDaysQuantity())
.ClickOrderButton();
Assert.AreNotEqual(WarningsAndLetterings.TotalOfEmptyCart, carBooking.GetCartTotalText());
}
public override Task <ComfirmReply> CreateCarBookingGRPC(BookingRequest request, ServerCallContext context)
{
MomService mom = new MomService();
CarBooking carBooking = new CarBooking(new Location(request.PickUpadress, request.PickUpcity, request.PickUpzipcode, request.PickUpcountry),
new Location(request.Dropoffadress, request.Dropoffcity, request.Dropoffzipcode, request.Dropoffcountry),
new Car(request.Doors, request.Fueltype, request.Type, request.DriversLicense, request.Price, request.Animals, request.CarLocationId, request.Brand, request.Model, request.Color, request.CarAvailablity),
new Customer(request.Name, request.LastName, request.Gender, request.DriversLicense),
new DateTime(request.PickupYear, request.PickUpMonth, request.PickUpDay, request.PickUpHour, request.PickUpMinute, 00),
new DateTime(request.DropoffYear, request.DropoffMonth, request.DropoffDay, request.DropoffHour, request.DropoffMinute, 00));
mom.SendOrderMessage(carBooking);
// kører db face execute here. return om det gik godt eller ej.
DbFacade.CreateCarBooking(carBooking);
return(base.CreateCarBookingGRPC(request, context));
}
public void BookCarAndCancelBooking()
{
Logger.Log.Info("Start BookCarAndCancelBooking test.");
HomePage homePage = new HomePage(Driver)
.ChooseBusinessClass();
BusinessClass businessClass = new BusinessClass(Driver)
.SelectFirstBusinessCar();
CarBooking carBooking = new CarBooking(Driver)
.InputDaysQuantity(RandomGenerator.GetRandomDaysQuantity())
.ClickOrderButton()
.OpenCartPreview()
.RemoveBooking();
Assert.AreEqual(WarningsAndLetterings.TotalOfEmptyCart, carBooking.GetCartTotalText());
}
public Object ConfirmCarBooking(CarBooking carPayment)
{
try
{
using (SqlConnection connection = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString))
{
connection.Open();
string sql = "INSERT INTO Payment(PaymentAmount,PaymentDate,StripePaymentID, UserID) VALUES(@param1,@param2,@param3,@param4); SELECT TOP 1 (PaymentID) from Payment order by PaymentID desc";
SqlCommand cmd = new SqlCommand(sql, connection);
cmd.Parameters.Add("@param1", SqlDbType.Float).Value = carPayment.paymentDetails.PaymentAmount / 10000;
cmd.Parameters.Add("@param2", SqlDbType.DateTime).Value = carPayment.paymentDetails.PaymentDate;
cmd.Parameters.Add("@param3", SqlDbType.NVarChar).Value = carPayment.paymentDetails.StripePaymentID;
cmd.Parameters.Add("@param4", SqlDbType.NVarChar).Value = carPayment.paymentDetails.UserID;
cmd.CommandType = CommandType.Text;
var newId = cmd.ExecuteScalar();
sql = "INSERT INTO CarBooking(UserID,PaymentID,CarType,PossibleModels,PickUpLocation,PickUpDate,PickUpTime,DropOffDate,DropOffTime) VALUES(@param1,@param2,@param3,@param4,@param5,@param6,@param7,@param8,@param9); SELECT TOP 1 (CarID) from CarBooking order by CarID desc";
cmd = new SqlCommand(sql, connection);
cmd.Parameters.Add("@param1", SqlDbType.NVarChar).Value = carPayment.paymentDetails.UserID;
cmd.Parameters.Add("@param2", SqlDbType.Int).Value = newId;
cmd.Parameters.Add("@param3", SqlDbType.VarChar).Value = carPayment.CarType;
cmd.Parameters.Add("@param4", SqlDbType.VarChar).Value = carPayment.PossibleModels;
cmd.Parameters.Add("@param5", SqlDbType.VarChar).Value = carPayment.PickUpLocation;
cmd.Parameters.Add("@param6", SqlDbType.NVarChar).Value = carPayment.PickUpDate;
cmd.Parameters.Add("@param7", SqlDbType.NVarChar).Value = carPayment.PickUpTime;
cmd.Parameters.Add("@param8", SqlDbType.NVarChar).Value = carPayment.DropOffDate;
cmd.Parameters.Add("@param9", SqlDbType.NVarChar).Value = carPayment.DropOffTime;
cmd.CommandType = CommandType.Text;
newId = cmd.ExecuteScalar();
connection.Close();
return(newId);
}
}
catch (Exception ex)
{
Exceptions exceptions = new Exceptions();
exceptions.ExceptionMessage = "Error in BookFlight() :" + ex.InnerException;
return(exceptions);
}
}
public async Task <IActionResult> New([FromBody] CarBooking carBooking)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (User.Identity.Name.Equals(carBooking.UserId.ToString()) || User.IsInRole("Admin"))
{
try
{
var user = await _usersDBContext.User.SingleOrDefaultAsync(s =>
s.UserId.Equals(carBooking.UserId));
var detail = _context.Car.Where(s => s.CarId.Equals(carBooking.CarId))
.Include(s => s.Cmp).ThenInclude(s => s.Crent).Include(s => s.Ctype);
_context.CarBooking.Add(carBooking);
await _context.SaveChangesAsync();
// EmailAddress address = new EmailAddress();
EmailMessage message = new EmailMessage("Car Booking", "Hi " + user.Name + ",<br/><br/>" +
"You have just booked for a car using our a web services, the full details of the booking are: <br/>" +
detail.First().Ctype.Name + "<br/>" + detail.First().Cmp.CompanyName + "<br/>" +
"<br/>" + "Booked date for pickUp: " + carBooking.BookDate +
"<br/>PayType: " + carBooking.PayType + "<br/>Total: R" + carBooking.Total +
"<br/><br/>Kind Regards,<br/>Booking.com");
message.FromAddresses.Add(new EmailAddress("Booking.com", "*****@*****.**"));
message.ToAddresses.Add(new EmailAddress(user.Name, user.Email));
new Send(message, _emailConfiguration)//.To(message, _emailConfiguration)
;
return(CreatedAtAction("GetFlBooking", new { id = carBooking.BookDate }, carBooking));
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(BadRequest("Internal error."));
}
}
return(Unauthorized());
}
public async Task <IActionResult> Create([Bind("BookingID,StartDate,FinishDate,DaysTaken,UserID,CarID,TotalPrice")] CarBooking carBooking)
{
if (ModelState.IsValid)
{
//DateTime date1 = carBooking.StartDate;
//DateTime date2 = carBooking.FinishDate;
//int daysDiff = ((TimeSpan)(date2 - date1)).Days;
//ViewData["DaysTaken"] = daysDiff;
carBooking.BookingConfirmed = false;
_context.Add(carBooking);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Booked), new { id = carBooking.BookingID }));
}
ViewData["CarID"] = new SelectList(_context.Car, "CarID", "CarID", carBooking.CarID);
//return View(carBooking, carBooking.CarID));
return(RedirectToAction(nameof(Create), new { id = carBooking.CarID }));
}
public void SendOrderMessage(CarBooking booking)
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "FinishedOrders", type: ExchangeType.Fanout);
var message = booking.ToString();
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish(exchange: "FinishedOrders",
routingKey: "",
basicProperties: null,
body: body);
}
}
public async Task BookingApi_MakeABooking_DidBook()
{
var bookingApi = Container.Resolve <IBookingApi>();
var carBooking = new CarBooking()
{
BookerName = "Gabriella" + Guid.NewGuid(),
BookingStartDate = DateTime.Now,
BookingEndDate = DateTime.Now.AddDays(1),
};
var didBook = await bookingApi.MakingBookingAsync(carBooking);
var bookings = await bookingApi.GetBookingsAsync();
var didFindBooking = bookings.Exists(
x => x.BookerName == carBooking.BookerName);
Assert.True(didBook);
Assert.True(didFindBooking);
}
public async Task <bool> MakingBookingAsync(
CarBooking booking,
CancellationToken token = default(CancellationToken))
{
try
{
token.ThrowIfCancellationRequested();
var url = $"{Route}/makebooking";
var didBook = await Executor.Post(url, booking);
return(didBook);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("Failed to send booking, ex: " + ex.Message);
}
return(false);
}
public void BookCarWithEmptyInfo()
{
Logger.Log.Info("Start BookCarWithEmptyInfo test.");
HomePage homePage = new HomePage(Driver)
.ChooseBusinessClass();
BusinessClass businessClass = new BusinessClass(Driver)
.SelectFirstBusinessCar();
CarBooking carBooking = new CarBooking(Driver)
.InputDaysQuantity(RandomGenerator.GetRandomDaysQuantity())
.ClickOrderButton()
.GoToCheckout();
Checkout checkout = new Checkout(Driver)
.SubmitCheckout();
Assert.AreNotEqual(String.Empty, checkout.GetErrorMessage());
}
private async Task <DialogTurnResult> DisplaySummaryStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
CarBooking booking = GetCarBookingObj(stepContext);
booking.PickupTime = ((String)stepContext.Result);
string summary = $"Hey **{booking.Name}**, \n\nThanks for booking a car with SuperTaxi.\n\n You will be picked up from **{booking.PickupLocation}** at **{booking.PickupTime}** and will be dropped at **{booking.DropOffLocation}**.\n\n Thanks again for your business.\n\nRegards Super Taxi";
await stepContext.Context.SendActivityAsync($"{summary}");
IList <string> interestedInSurvey = new List <string>();
interestedInSurvey.Add("Yes");
interestedInSurvey.Add("No");
string surveyMessage = $"Would you like to spend a minute to provide feedback on our services";
return(await stepContext.PromptAsync("SurveyChoice", new PromptOptions()
{
Prompt = MessageFactory.Text(surveyMessage),
Choices = ChoiceFactory.ToChoices(interestedInSurvey),
}, cancellationToken));
}
