// Get bookingDto from Web, create booking object and save to db
public void CreateBooking(BookingDTO bookingDto)
{
Booking booking = Mapper.Map <BookingDTO, Booking>(bookingDto);
_unitOfWork.Bookings.Create(booking);
_unitOfWork.Save();
}
public async Task <bool> Update(BookingDTO booking)
{
var isBookingExists = await _unitOfWork.Bookings.FindBookingById(booking.BookingId);
if (isBookingExists == null)
{
return(false);
}
isBookingExists.ItemPrice = booking.ItemPrice;
isBookingExists.MerchantBill = booking.MerchantBill;
isBookingExists.CourierBill = booking.CourierBill;
isBookingExists.ReceiverBill = booking.ReceiverBill;
isBookingExists.ItemPrice = booking.ItemPrice;
isBookingExists.ConditionCharge = booking.ConditionCharge;
isBookingExists.TotalAmmount = booking.TotalAmount;
await _unitOfWork.CompleteAsync();
// var receiver = await _unitOfWork.Receivers.GetReciverById(booking.ReceiverId);
// receiver.ZoneId = booking.ZoneId;
// receiver.Name = booking.ReceiverName;
var bookingItem = await _unitOfWork.BookingItems.FindBookingItemById(booking.BookingId);
bookingItem.IsConditionChargeApply = booking.IsConditionCharge;
bookingItem.IsInCity = booking.IsInCity;
bookingItem.IsOutCity = booking.IsOutCity;
bookingItem.ItemAttributeId = booking.ItemAttributeId;
await _unitOfWork.CompleteAsync();
return(true);
}
public void Create(BookingDTO item)
{
if (item.StatusId <= 0 || item.GuestId <= 0 || item.RoomId <= 0)
{
throw new ArgumentOutOfRangeException();
}
if (item.DateFrom.CompareTo(item.DateTo) >= 0)
{
throw new ArgumentException("Start date must be less than end date");
}
if (item.AdultQuantity <= 0)
{
throw new ArgumentOutOfRangeException();
}
if (item.ChildQuantity < 0)
{
throw new ArgumentOutOfRangeException();
}
Booking newBooking = toEntityMapper.Map <BookingDTO, Booking>(item);
database.Bookings.Create(newBooking);
database.Save();
}
public async Task <IActionResult> BookMovie([FromBody] BookingDTO booking)
{
if (booking == null)
{
return(StatusCode(400, new { message = Constants.InvalidInput("booking") }));
}
if (!ModelState.IsValid)
{
return(StatusCode(400, new { message = Constants.InvalidInput("booking") }));
}
int totalSeatsSelected = booking.SeatNo.Split(',').Count();
if (totalSeatsSelected > 5)
{
return(StatusCode(400, new { message = Constants.MaxBooking }));
}
int bookedId = await this.seatBookingService.BookMovie(booking);
if (bookedId <= 0)
{
return(StatusCode(500, new { message = Constants.UnknownErrors }));
}
return(Created("bookingDetails", new
{ id = bookedId, Seats = booking.SeatNo, Date = booking.BookingDate, Amount = booking.Amount }));
}
public BookingDTO AcceptBooking([FromBody] BookingDTO booking)
{
Booking Booking = _repos.AcceptBooking(booking);
BookingDTO BookingDTO = _mapper.Map <Booking, BookingDTO> (Booking);
return(BookingDTO);
}
public ActionResult DeleteBooking(CancelBookingViewModel booking)
{
try
{
if (ModelState.IsValid)
{
ClientDTO client = new ClientDTO {
Name = booking.Name, Surname = booking.Surname, BirthDate = booking.BirthDate
};
ClientDTO newClient = clientService.GetClientByInfo(client);
var bookingDTO = new BookingDTO
{
HotelID = booking.HotelID,
RoomNumber = booking.RoomNumber,
ClientID = newClient.ClientID,
StartDate = booking.StartDate,
EndDate = booking.EndDate,
PeopleQuantity = booking.PeopleQuantity
};
bookingService.CancelBooking(bookingDTO);
ViewBag.SuccessMsg = "Successfully canceled booking.";
return(View(booking));
}
}
catch (ValidationException ex)
{
ModelState.AddModelError(ex.Property, ex.Message);
ViewBag.CancelError = ex.Message;
return(View(booking));
}
return(View(booking));
}
/// <summary>
/// Fetch the latest booking
/// </summary>
/// <returns></returns>
public BookingDTO LatestBooking()
{
int id = dBEntities.BookingDetails.Max(x => x.OrderId);
BookingDTO bookingDTO = AutoMapper.Mapper.Map <BookingDTO>(dBEntities.BookingDetails.FirstOrDefault(myid => myid.OrderId == id));
return(bookingDTO);
}
public BookingRequest(BookingDTO bookingDto, RideDTO rideDto, EmployeeDTO employeeDto, ClientDTO clientDto)
{
BookingDto = bookingDto;
RideDto = rideDto;
EmployeeDto = employeeDto;
ClientDto = clientDto;
}
/// <summary>
/// Update Booking detail
/// </summary>
/// <param name="id"></param>
/// <param name="bookingDTO"></param>
/// <returns></returns>
public bool UpdateBooking(int id, BookingDTO bookingDTO)
{
var entity = dBEntities.BookingDetails.FirstOrDefault(o => o.OrderId == id);
if (entity == null)
{
return(false);
}
else
{
entity.CampId = bookingDTO.CampId;
entity.TotalDays = bookingDTO.TotalDays;
entity.ContactNo = bookingDTO.ContactNo;
entity.BillAddress = bookingDTO.BillAddress;
entity.CheckIn = bookingDTO.CheckIn;
entity.CheckOut = bookingDTO.CheckOut;
entity.Amount = bookingDTO.Amount;
// entity.BookingNo = bookingDTO.BookingNo;
entity.State = bookingDTO.State;
entity.Country = bookingDTO.Country;
entity.ZIP = bookingDTO.ZIP;
dBEntities.SaveChanges();
return(true);
}
}
/// <summary>
/// Adding a new booking to the database
/// </summary>
/// <param name="bookingDTO"></param>
public void Book(BookingDTO bookingDTO)
{
Room room = Database.Rooms.Get(bookingDTO.RoomId);
if (room == null)
{
throw new ValidationException("Комната не найдена", "");
}
int days = Math.Abs((bookingDTO.CheckIn - bookingDTO.CheckOut).Days);
decimal sum = room.Price * days;
Booking booking = new Booking
{
RoomId = room.Id,
Sum = sum,
IsPaid = false,
CheckIn = bookingDTO.CheckIn.Date,
CheckOut = bookingDTO.CheckOut.Date,
UserEmail = bookingDTO.UserEmail,
UserId = bookingDTO.UserId,
Time = DateTime.Now
};
Database.Bookings.Create(booking);
Database.Save();
logger.Log(LogLevel.Info, "На пользователя " + booking.UserEmail + " в базу данных было занесено новое " +
"бронирование №" + booking.Id + ".");
}
public async System.Threading.Tasks.Task AddBookingMemberAsyncTestAsync()
{
var options = new DbContextOptionsBuilder <SportCenterDBContext>()
.UseInMemoryDatabase(databaseName: "BookingManager_AddBookingMemberAsyncTestAsync")
.Options;
// Example element
var booking = new BookingDTO()
{
BookingDate = new System.DateTime(2019, 10, 10, 0, 0, 0),
CourtId = 1,
MemberId = 2,
};
// Add the element
using (var context = new SportCenterDBContext(options))
{
var manager = new BookingManager(context);
await manager.AddBookingMemberAsync(booking);
}
//Checks if exists in the context
using (var context = new SportCenterDBContext(options))
{
context.Bookings.Should().NotBeNull();
context.Bookings.Count().Should().Be(1);
context.Bookings.First().BookingDate.Should().BeSameDateAs(new System.DateTime(2019, 10, 10, 0, 0, 0));
context.Bookings.First().CourtForeignKey.Should().Be(1);
context.Bookings.First().MemberForeignKey.Should().Be(2);
}
}
private IEnumerable <ApplicationUser> MapToApplicationUsers(
BookingDTO bookingDTO, ApplicationUser mainUser = null)
{
var users = new List <ApplicationUser>();
foreach (var member in bookingDTO.Members)
{
users.Add(
new ApplicationUser
{
Name = member.Name,
Surname = member.Surname,
Gender = member.Gender,
PhoneNumber =
mainUser?.PhoneNumber ?? bookingDTO.Mobile,
Email = bookingDTO.EmailAddress,
UserName = bookingDTO.EmailAddress,
CreatedAt = DateTime.Now,
CategoryId = member.CategoryId
}
);
}
return(users);
}
private void btnAddBooking_Click(object sender, EventArgs e)
{
if (bookingRoomDetails.Count == 0)
{
MessageBox.Show("Please add booking room", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
var newBooking = new BookingDTO()
{
BookingId = BookingBUS.NextId(),
EmployeeId = this.employee.EmployeeId,
Customer = new CustomerDTO()
{
CustomerId = CustomerBUS.NextId(),
Name = txtName.Text,
Address = txtAddress.Text,
Phone = txtPhone.Text,
Fax = txtFax.Text,
Telex = txtTelex.Text
},
CreatedDate = DateTime.Now,
BookingDetails = this.bookingRoomDetails
};
newBooking.BookingDetails.ForEach(b => b.Room = null);
BookingBUS.AddBooking(newBooking);
this.bookingDTOBindingSource.DataSource = BookingBUS.GetBookings();
this.ReloadGridViewRoomAndBookingDetail();
}
public Booking()
{
InitializeComponent();
DTO = new BookingDTO();
sqlCon = new SqlConnection("Data Source=DESKTOP-63Q74F5;Initial Catalog=Project;Integrated Security=True");
cmd = new SqlCommand();
}
public BookingDTO Create([FromBody] BookingDTO booking)
{
Booking Booking = _repos.Create(booking);
BookingDTO BookingDTO = _mapper.Map <Booking, BookingDTO> (Booking);
return(BookingDTO);
}
public BookingDTO GetById([FromQuery] int id)
{
Booking Booking = _repos.GetById(id);
BookingDTO BookingDTO = _mapper.Map <Booking, BookingDTO> (Booking);
return(BookingDTO);
}
public BookingDTO Update(int Id, Location Source, Location Destination, float Distance, int OfferId)
{
Booking Booking = _repos.Update(Id, Source, Destination, Distance, OfferId);
BookingDTO BookingDTO = _mapper.Map <Booking, BookingDTO> (Booking);
return(BookingDTO);
}
// TODO move somewhere
private int?FindAvailableSpace(BookingDTO booking)
{
var intersectingBookings = bookingRepository.FindAllAsQueryable(i =>
i.GarageId == booking.GarageId &&
i.StartDateTime <booking.EndDateTime &&
i.EndDateTime> booking.StartDateTime &&
i.Id != booking.Id);
var takenSLs = intersectingBookings.Select(j => j.ServiceLineId).ToList();
var freeSLs = garageRepository.FindById(booking.GarageId).ServiceLanes.Where(i => !i.Deleted && !takenSLs.Contains(i.Id)).ToList();
if (booking.Type != Models.Enums.VehicleType.Car)
{
freeSLs = freeSLs.Where(i => i.VansTrucks).ToList();
}
if (freeSLs.Count == 0)
{
return(null);
}
else
{
return(freeSLs.OrderBy(i => i.VansTrucks).First().Id);
}
}
public ActionResult Edit(BookingDTO booking)
{
// if car type or hotel changed or check for tyre slots here
UpdateBooking(booking);
var line = FindAvailableSpace(booking);
if (line == null)
{
ModelState.AddModelError(nameof(BookingDTO.GarageId), "No free service lines available in this garage at this time");
}
else
{
booking.ServiceLineId = line.Value;
}
if (ModelState.IsValid)
{
var entity = bookingRepository.FindById(booking.Id);
entity.ChangedAt = DateTime.Now;
entity.Edited = true;
bookingRepository.Update(BookingAssembler.Update(entity, booking));
return(RedirectToAction("Index"));
}
ViewBag.Garages = garageRepository.FindAllAsQueryable(i => !i.Deleted);
return(View(booking));
}
public void Update(int id, BookingDTO value)
{
var data = new Booking()
{
BookingGuest = new Guest()
{
Id = value.BookingGuest.Id,
Name = value.BookingGuest.Name,
Surname = value.BookingGuest.Surname
},
BookingRoom = new Room()
{
Id = value.BookingRoom.Id,
Name = value.BookingRoom.Name,
RoomCategory = new Category()
{
Id = value.BookingRoom.RoomCategory.Id,
Name = value.BookingRoom.RoomCategory.Name,
Price = value.BookingRoom.RoomCategory.Price,
Bed = value.BookingRoom.RoomCategory.Bed
}
},
BookingDate = value.BookingDate,
EnterDate = value.EnterDate,
LeaveDate = value.LeaveDate,
Set = value.Set
};
Database.Bookings.Update(id, data);
Database.Save();
}
public async Task <IActionResult> Add(BookingDTO booking)
{
//Save Receiver
// var receiver = new Receiver
// {
// Id = Guid.NewGuid().ToString(),
// Name = booking.ReceiverName,
// Address = booking.ReceiverAddress,
// Phone = booking.ReceiverPhone,
// Email = booking.ReceiverEmail,
// ZoneId = booking.ZoneId
// };
// receiver = await _unitOfWork.Receivers.Add(receiver);
var receiver = await _receiverService.Add(booking);
//get receiverId
var receiverId = receiver.Id;
var totalBooking = _context.Bookings.Count();
var courierIdTemp = "0001"; //remove after
var bookingSerialNo = Extensions.GenerateSerialForBooking(courierIdTemp, booking.MerchantIdentity, totalBooking + 1);
//Place Booking
var placeBooking = new Booking
{
Id = Guid.NewGuid().ToString(),
ReceiverId = receiverId,
MerchantId = booking.MerchantId,
BookingDate = DateTime.Now,
TotalAmmount = booking.TotalAmount,
Discount = booking.Discount,
ItemPrice = booking.ItemPrice,
SerialNo = bookingSerialNo,
MerchantBill = booking.MerchantBill,
CourierBill = booking.CourierBill,
ReceiverBill = booking.ReceiverBill,
ConditionCharge = booking.ConditionCharge
};
placeBooking.Status = "Pending";
var bookingId = placeBooking.Id;
await _unitOfWork.Bookings.Add(placeBooking);
//Save BookingItems
var bookingItem = new BookingItem
{
BookingId = bookingId,
ItemAttributeId = booking.ItemAttributeId,
IsInCity = booking.IsInCity,
IsOutCity = booking.IsOutCity,
IsConditionChargeApply = booking.IsConditionCharge
};
await _unitOfWork.BookingItems.Add(bookingItem);
var result = await _unitOfWork.CompleteAsync();
if (result == 0)
{
return(BadRequest("error occured"));
}
return(Ok());
}
public ActionResult SpinVirtual(int id)
{
string ipAdd, userName, pass;
using (Db db = new Db())
{
BookingDTO dto = db.Bookings.Find(id);
ipAdd = dto.IPAddress;
userName = dto.Username;
pass = dto.Password;
}
string VM = @"c:\temp\virtual.bat";
string REDIRECT = @"c:\temp\redirect.bat";
string Del = @"c:\temp\delete.bat";
if (!System.IO.File.Exists(REDIRECT))
{
// Create a file to write to.
using (StreamWriter sw = System.IO.File.CreateText(REDIRECT))
{
sw.WriteLine("cd C:/temp");
sw.WriteLine("virtual.bat");
}
}
if (!System.IO.File.Exists(VM))
{
// Create a file to write to.
using (StreamWriter sw = System.IO.File.CreateText(VM))
{
sw.WriteLine("@echo off");
//sw.WriteLine("cmdkey /generic:" + '"' + "192.168.15.41" + '"' + " /user:"******"' + "SGMAIL" + Regex.Escape("\r") + "alphjoshua.batula" + '"' + " /pass:"******"' + "P@ssw0rd" + '"');
//sw.WriteLine("mstsc /f /v:" + '"' + "192.168.15.41" + '"');
//sw.WriteLine("cmdkey /delete:" + '"' + "192.168.15.41" + '"');
sw.WriteLine("cmdkey /generic:" + '"' + ipAdd + '"' + " /user:"******"' + userName + '"' + " /pass:"******"' + pass + '"');
sw.WriteLine("mstsc /f /v:" + '"' + ipAdd + '"');
sw.WriteLine("cmdkey /delete:" + '"' + ipAdd + '"');
}
}
if (!System.IO.File.Exists(Del))
{
// Create a file to write to.
using (StreamWriter sw = System.IO.File.CreateText(Del))
{
sw.WriteLine("@echo off");
sw.WriteLine("del virtual.bat");
sw.WriteLine("del redirect.bat");
sw.WriteLine("del delete.bat");
}
}
string command = "/C cd C:/temp/ & @echo off & redirect.bat & delete.bat";
System.Diagnostics.Process.Start("cmd.exe", command);
TempData["Success"] = "Connecting remotely to Virtual Machine...";
return(RedirectToAction("my-bookings"));
}
public void UpsertBookingReception(BookingDTO bookingDTO, int loggedUserID)
{
if (!UserPermissionHelper.GetPermissions(loggedUserID).Contains(UserServ.Helpers.UserPermission.Enums.PermissionTypeEnum.CanAdmBookings))
{
throw new Exception("Access denied");
}
_UpsertBooking(bookingDTO, loggedUserID);
}
public IHttpActionResult Update(BookingDTO dto)
{
var model = _mapper.Map <BookingModel>(dto);
model = _bookingService.Update(model);
return(Ok(model));
}
public void MemberIdTest()
{
BookingDTO booking = new BookingDTO();
booking.MemberId = 2;
booking.MemberId.Should().Be(2);
}
public void BookingDateTest()
{
BookingDTO booking = new BookingDTO();
booking.BookingDate = new DateTime(2019, 01, 20, 00, 00, 00);
booking.BookingDate.Should().BeSameDateAs(new DateTime(2019, 01, 20, 00, 00, 00));
}
public void SportIdTest()
{
BookingDTO booking = new BookingDTO();
booking.SportId = 2;
booking.SportId.Should().Be(2);
}
public async Task <ActionResult> CurrentBookings(BookingDTO search)
{
var currentbookings = await new SearchService(AUTHTOKEN, p_mobileNo).SearchCurrentBookingAsync(search);
var bookingSearchVM = new BookingSearchDTO();
bookingSearchVM.booking = currentbookings;
return(View("SearchBookingHistory", bookingSearchVM));
}
public static void AddBooking(BookingDTO booking)
{
using (var context = new HotelContext())
{
context.Bookings.Add(Mapper.Map <BookingDTO, Booking>(booking));
context.SaveChanges();
}
}
public BookingDTO Insert(BookingDTO _booking)
{
using (CarRentalEntities context = new CarRentalEntities())
{
Booking booking = context.usp_Booking_Insert(_booking.is_Personal_Car_Used, _booking.id_Request_Booking, _booking.Licence_Plate).FirstOrDefault();
return(bookingMapping.MapToBookingDTO(booking));
}
}
