public virtual async Task <IActionResult> CreateBooking(CreateBookingDTO booking)
{
var result = new JsonResult <string>();
try
{
ShortId.SetCharacters(CHARACTERS);
var pendingBooking = await _service.GetPendingBookingByClientIdAsync(booking.PendingBookingId);
var entity = new Booking
{
Id = ShortId.Generate(true, false, 8).ToUpper(),
Date = DateTime.Now,
Email = booking.Email,
Name = booking.Name,
Phone = booking.Phone,
ScheduleId = pendingBooking.EvenScheduleId
};
entity.BookingPositions = pendingBooking
.PendingBookingPositions
.Select(x => new BookingPosition
{
BookingId = entity.Id,
ServicePlacePositionId = x.ServicePlacePositionId
})
.ToList();
entity = await _service.CreateBookingAsync(entity);
await _hubContext.Clients.All.RecieveNewBooking(_mapper.Map <Booking, BookingDTO>(entity));
result.Success = true;
result.Result = entity.Id;
SmtpMail oMail = new SmtpMail("TryIt");
SmtpClient oSmtp = new SmtpClient();
oMail.From = "*****@*****.**";
oMail.To = booking.Email;
oMail.Subject = "Sikeres foglalás";
oMail.TextBody = $"Köszönjük a foglalásod. Az azonosító: {entity.Id}.";
SmtpServer oServer = new SmtpServer("smtp.gmail.com");
oServer.Port = 587;
oServer.ConnectType = SmtpConnectType.ConnectSSLAuto;
oServer.User = "******";
oServer.Password = "";
oSmtp.SendMail(oServer, oMail);
}
catch (BookingException)
{
result.Message = "Valaki más már tett foglalást a kiválasztott hely(ek)re.";
}
catch
{
// TODO log
result.Message = "A foglalási kérelmet nem lehet elindítani váratlan hiba miatt.";
}
return(Ok(result));
}
public Booking CreateBooking(CreateBookingDTO booking)
{
return(new Booking
{
Name = booking.Name,
BookingDateTime = booking.BookingDateTime,
Flexibility = booking.Flexibility,
VehicleSize = booking.VehicleSize,
ContactNumber = booking.ContactNumber,
EmailAddress = booking.EmailAddress,
Approved = false
});
}
/*
* public async Task<Booking> Create(Booking s)
* {
* //Create a supplement.
* await _bookingDB.InsertOneAsync(s);
* return s;
* }*/
public async Task <CreateBookingDTO> Create(CreateBookingDTO dto)
{
var s = _mapper.Map <Booking>(dto);
if (string.IsNullOrWhiteSpace(s.Customerid))
{
s.Customerid = ObjectId.GenerateNewId().ToString();
}
await _bookingDB.InsertOneAsync(s);
s.BookedDays = null;
_publisher.Created(s);
return(dto);
}
public void CreateBookingAsync_ShouldThrowArgumentNullException_WhenArgumentIsNull(
BookingService bookingService)
{
// ARRANGE
CreateBookingDTO createBooking = null;
// ACT
Func <Task <int> > result = async() => await bookingService.CreateBookingAsync(createBooking);
// ASSERT
result.Should().Throw <ArgumentNullException>()
.WithMessage("*createBooking*");
}
/// <summary>
/// Create a new booking in the database
/// </summary>
/// <param name="createBooking">New booking</param>
/// <returns></returns>
public async Task <int> CreateBookingAsync(CreateBookingDTO createBooking)
{
if (createBooking == null)
{
throw new ArgumentNullException(nameof(createBooking));
}
var booking = _bookingFactory.CreateBooking(createBooking);
Validate(booking);
var result = await _bookingRepository.CreateAsync(booking);
return(result);
}
public void CreateBookingAsync_ShouldValidationException_WhenEmailAddressIsInvalid(
CreateBookingDTO createBooking,
BookingService bookingService)
{
// ARRANGE
createBooking.Name = "nbnb";
// ACT
Func <Task <int> > result = async() => await bookingService.CreateBookingAsync(createBooking);
// ASSERT
result.Should().Throw <ValidationException>()
.WithMessage("Booking is invalid");
}
public async Task CreateBookingAsync_ShouldAddBooking_WhenThereIsNoErrors(
CreateBookingDTO createBooking,
[Frozen] IRepository <Booking> bookingRepository,
BookingService bookingService)
{
// ARRANGE
createBooking.EmailAddress = "*****@*****.**";
bookingRepository.CreateAsync(Arg.Any <Booking>()).Returns(1);
// ACT
var result = await bookingService.CreateBookingAsync(createBooking);
// ASSERT
result.Should().Be(1);
}
public void CreateBookingAsync_ShouldValidationException_WhenContactNumberIsEmpty(
CreateBookingDTO createBooking,
BookingService bookingService)
{
// ARRANGE
createBooking.Name = "nbnb";
createBooking.EmailAddress = "*****@*****.**";
createBooking.ContactNumber = "";
// ACT
Func <Task <int> > result = async() => await bookingService.CreateBookingAsync(createBooking);
// ASSERT
result.Should().Throw <ValidationException>()
.WithMessage("Booking is invalid");
}
public static void PostBooking(Response responseObj, CreateBookingDTO createBooking)
{
var json = JsonConvert.SerializeObject(createBooking);
var data = new StringContent(json, Encoding.UTF8, "application/json");
var url = "http://localhost:9090/booking";
using var client = new HttpClient();
var response = client.PostAsync(url, data).Result;
string result = response.Content.ReadAsStringAsync().Result;
if (result == "false")
{
responseObj.Succeded = false;
}
else
{
responseObj.Succeded = true;
}
}
public static void CreateBooking()
{
CreateBookingDTO createBooking = new CreateBookingDTO(
new List <string> {
"323M"
}, "123cjohn3", 5, DateTime.Parse("2020-12-12"), DateTime.Parse("2021-07-01"), false);
Response response = new Response();
Requests.PostBooking(response, createBooking);
bool hasPostedBooking = response.Succeded;
if (hasPostedBooking)
{
Console.WriteLine("Booking has been created!");
}
else
{
Console.WriteLine(
"Booking request failed, you may receive a phone call shortly if we feel that we can help you book your room(s)"
);
}
}
public async Task <IActionResult> Create([FromBody] CreateBookingDTO s)
{
var result = await _bookingService.Create(s);
return(NoContent());
}
