public async Task UpdateBookingShouldUpdateFieldsAsync()
{
// arrange
var booking = new BookingEntity {
Id = Guid.NewGuid(), UserEntityId = _currentUserEntity.Id
};
_bookingList.Add(booking);
var model = new UpdateBookingModel
{
BookingStatusCode = "testBookingUpdate",
SelfBooked = true,
DateOfBooking = DateTime.UtcNow.ToLocalTime(),
OtherBookingDetails = "testOtherBookingDetails"
};
// act
var result = await _bookingsQueryProcessor.Update(booking.Id, model);
// assert
result.Should().Be(booking);
result.BookingStatusCode.Should().Be(model.BookingStatusCode);
result.SelfBooked.Should().Be(model.SelfBooked);
result.UserEntityId.Should().Be(_currentUserEntity.Id);
_unitOfWorkMock.Verify(x => x.CommitAsync());
}
public async Task <BookingModel> PutAsync(Guid id, [FromBody] UpdateBookingModel model)
{
var item = await _bookingsQuery.Update(id, model);
var resultModel = _mapper.Map <BookingModel>(item);
return(resultModel);
}
public Booking UpdateBooking(UpdateBookingModel model, Booking entity)
{
model.CopyTo(entity);
if (model.RemoveServiceIds != null)
{
RemoveBookingAttachedServices(model.RemoveServiceIds);
}
return(entity);
}
public ValidationData ValidateUpdateBooking(ClaimsPrincipal principal,
Member manager,
Booking entity,
UpdateBookingModel model)
{
var validationData = new ValidationData();
var userId = principal.Identity.Name;
if (entity.Status == BookingStatusValues.PROCESSING)
{
var bookMemberId = entity.BookMemberId;
var managerIds = _memberService.QueryManagersOfMember(bookMemberId)
.Select(o => o.UserId).ToList();
if (!managerIds.Contains(userId))
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
}
else if (entity.Status == BookingStatusValues.VALID)
{
var areaCode = entity.Room.BuildingAreaCode;
var managerIds = _memberService.QueryManagersOfArea(areaCode)
.Select(o => o.UserId).ToList();
if (!managerIds.Contains(userId))
{
validationData.Fail(code: AppResultCode.AccessDenied);
}
}
else
{
validationData.Fail(mess: "Invalid status", code: AppResultCode.FailValidation);
}
if (model.RoomCode != entity.RoomCode)
{
var room = _roomService.Rooms.Code(model.RoomCode).FirstOrDefault();
if (room == null)
{
validationData.Fail(mess: "Room not found", AppResultCode.FailValidation);
}
else
if (!CheckAvailabilityOfRoomForBooking(userId, entity, room))
{
validationData.Fail(mess: "New room is not available", AppResultCode.FailValidation);
}
else
{
validationData.TempData["room"] = room;
}
}
return(validationData);
}
public async Task <IActionResult> UpdateBooking(int id, UpdateBookingModel model)
{
var entity = _service.Bookings.Id(id).FirstOrDefault();
if (entity == null)
{
return(NotFound(AppResult.NotFound()));
}
var member = _memberService.Members.Id(UserId).FirstOrDefault();
var validationData = _service.ValidateUpdateBooking(User, member, entity, model);
if (!validationData.IsValid)
{
return(BadRequest(AppResult.FailValidation(data: validationData)));
}
var fromStatus = entity.Status;
AppEvent ev;
using (var trans = context.Database.BeginTransaction())
{
_service.UpdateBooking(model, entity);
var history = _service.CreateHistoryForUpdateBooking(entity, member);
//log event
ev = _sysService.GetEventForBookingProcessing(history);
_sysService.CreateAppEvent(ev);
//end log event
context.SaveChanges();
trans.Commit();
}
//notify using members
var notiData = new Dictionary <string, string>
{
{ "event", ev.Type },
{ "id", entity.Id.ToString() }
};
var updatePerson = fromStatus == BookingStatusValues.PROCESSING ? "department manager" :
"location manager";
var usingMemberIds = entity.UsingMemberIds.Split('\n');
var notiMemberIds = usingMemberIds.Where(o => o != UserId).ToList();
await NotiHelper.Notify(notiMemberIds, new Notification
{
Title = $"Booking {entity.Code} has been updated by your {updatePerson}",
Body = $"{UserEmail} has just updated your booking of room {entity.RoomCode}. Press for more detail"
}, data : notiData);
return(NoContent());
}
public async Task <BookingEntity> Update(Guid id, UpdateBookingModel model)
{
var booking = GetQuery().FirstOrDefault(b => b.Id == id);
if (booking == null)
{
throw new NotFoundException("Booking not found");
}
booking.BookingStatusCode = model.BookingStatusCode;
booking.DateOfBooking = model.DateOfBooking;
booking.SelfBooked = model.SelfBooked;
booking.OtherBookingDetails = model.OtherBookingDetails;
booking.ModifyDate = DateTime.UtcNow.ToLocalTime();
booking.ModifyUserId = _securityContext.UserEntity.Id.ToString();
booking.IsDeleted = model.IsDeleted;
await _uniOfWork.CommitAsync();
return(booking);
}
public void updateBookingDetails(UpdateBookingModel model)
{
var todayDate = DateTime.Today;
DateTime datecheck = new DateTime();
datecheck = Convert.ToDateTime(model.date);
if (datecheck > todayDate)
{
var bookingDetails = (BookingDetailsModel)Session["selectedBookingDetails"];
var bookingUpdate = db.Venue_Booking.Where(b => b.Venue_Booking_Seq.Equals(bookingDetails.booking_seq)).FirstOrDefault();
var test = bookingUpdate.Venue_Booking_Seq;
//get the time and date components
DateTime bookingTime = Convert.ToDateTime(model.time);
var timeTimespan = bookingTime.TimeOfDay;
var bookingDate = datecheck;
//calculate the start time of the new session
DateTime startDateTime = new DateTime(bookingDate.Year, bookingDate.Month, bookingDate.Day, timeTimespan.Hours, timeTimespan.Minutes, timeTimespan.Seconds);
//calculate the end time of the new session
var duration = Convert.ToDateTime(model.length).TimeOfDay;
DateTime endDateTime = startDateTime.Add(duration);
var buildingFloorId = (from b in db.Building_Floor
where b.Building_ID.Equals(model.building_id) && b.Campus_ID.Equals(model.campus_id)
select b.Building_Floor_ID).FirstOrDefault();
bookingUpdate.DateTime_From = startDateTime;
bookingUpdate.DateTime_To = endDateTime;
bookingUpdate.Campus_ID = model.campus_id;
bookingUpdate.Building_ID = model.building_id;
bookingUpdate.Building_Floor_ID = buildingFloorId;
bookingUpdate.Venue_ID = model.venue_id;
db.Entry(bookingUpdate).State = EntityState.Modified;
db.SaveChanges();
//record action
global.addAudit("Bookings", "Bookings: Update Booking", "Update", User.Identity.Name);
}
else
{
var bookingDetails = (BookingDetailsModel)Session["selectedBookingDetails"];
var bookingUpdate = db.Venue_Booking.Where(b => b.Venue_Booking_Seq.Equals(bookingDetails.booking_seq)).FirstOrDefault();
TempData["Message"] = "Invalid date entry. Date is in the past";
TempData["classStyle"] = "warning";
ViewBag.Campus = from c in db.Campus
select c;
ViewBag.Building = from b in db.Buildings
where b.Campus_ID.Equals(bookingUpdate.Campus_ID)
select b;
var venues = db.findBookingVenuesFunc(bookingUpdate.DateTime_From, bookingUpdate.DateTime_To, "Discussion", bookingUpdate.Campus_ID).ToList();
var currentVenue = db.Venues.Where(v => v.Venue_ID.Equals(bookingUpdate.Venue_ID)).FirstOrDefault();
venues.Add(currentVenue);
ViewBag.Venue = venues;
RedirectToAction("updateBookingDetails", "Booking", model);
}
}
public ActionResult updateBookingDetails()
{
var bookingDetails = (BookingDetailsModel)Session["selectedBookingDetails"];
var booking = db.Venue_Booking.Where(b => b.Venue_Booking_Seq.Equals(bookingDetails.booking_seq)).FirstOrDefault();
if (booking.Booking_Type.Booking_Type_Name == "Training")
{
TempData["Message"] = "Unfortunately unable to update training session!";
TempData["classStyle"] = "danger";
if (User.IsInRole("Admin"))
{
return(RedirectToAction("employeeViewBookings"));
}
else
{
return(RedirectToAction("ViewBookings"));
}
}
else
{
UpdateBookingModel a = new UpdateBookingModel
{
booking_seq = bookingDetails.booking_seq,
building = bookingDetails.building,
campus = bookingDetails.campus,
date = bookingDetails.date,
startDate = booking.DateTime_From,
endDate = booking.DateTime_To,
person_id = bookingDetails.person_id,
time = booking.DateTime_From.TimeOfDay.ToString(),
venue = bookingDetails.venue,
campus_id = booking.Campus_ID,
building_id = booking.Building_ID,
building_floor_id = booking.Building_Floor_ID,
venue_id = booking.Venue_ID,
length = booking.DateTime_To.Subtract(booking.DateTime_From).ToString().Substring(0, 5),
};
//get xml
var settingsPath = Path.Combine(Server.MapPath("~"), "settings.xml");
XElement doc = XElement.Load(settingsPath);
//get list of durations
List <string> durations = (from el in doc.Elements("discussionduration")
select el.Value).ToList();
durations.Sort();
ViewBag.Durations = durations;
//get start/closing time
var open = doc.Elements("opentime").First();
var close = doc.Elements("closetime").First();
ViewBag.Open = open;
ViewBag.Close = close;
ViewBag.Campus = from c in db.Campus
select c;
ViewBag.Building = from b in db.Buildings
where b.Campus_ID.Equals(booking.Campus_ID)
select b;
var venues = db.findBookingVenuesFunc(booking.DateTime_From, booking.DateTime_To, "Discussion", booking.Campus_ID).ToList();
var currentVenue = db.Venues.Where(v => v.Venue_ID.Equals(booking.Venue_ID)).FirstOrDefault();
venues.Add(currentVenue);
ViewBag.Venue = venues;
ModelState.Clear();
return(View(a));
}
}
