public void Search_ViewModel_RedirectToIndexWithQueryAndPageNum()
{
//Arrange
var viewModel = new AvailabilityViewModel()
{
SearchTerm = "test",
PageNum = 2
};
//Act
var result = _controller.Search(viewModel) as RedirectToRouteResult;
//Assert
result.Should().NotBeNull();
result.RouteValues.Should().HaveCount(3);
var routeValue = result.RouteValues["action"];
routeValue.Should().Be("Index");
var routeValue1 = result.RouteValues["query"];
routeValue1.Should().Be(viewModel.SearchTerm);
var routeValue2 = result.RouteValues["pageNum"];
routeValue2.Should().Be(viewModel.PageNum);
}
public async Task <ActionResult <dynamic> > Availability(AvailabilityViewModel reservationIn)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ValidationProblemDetails(ModelState)));
}
if (string.IsNullOrWhiteSpace(reservationIn.CronoExpression))
{
var freeResources = await _reservationService.Availability(reservationIn.Start, reservationIn.End, reservationIn.ResourceType, reservationIn.ResourceSubTypes, null);
return(freeResources);
}
else
{
var expression = CronExpression.Parse(reservationIn.CronoExpression);
var occurrences = expression.GetOccurrences(
reservationIn.Start,
reservationIn.End,
fromInclusive: true,
toInclusive: true);
if (occurrences == null)
{
return(null);
}
var freeResources = await _reservationService.Availability(reservationIn.Start, reservationIn.End, reservationIn.ResourceType, reservationIn.ResourceSubTypes, occurrences);
return(freeResources);
}
}
public async Task ShouldPassDatesProperly()
{
// arrange
var state = new ScheduleState();
var StartDate = new DateTime(2019, 8, 25, 14, 0, 0);
var EndDate = new DateTime(2019, 8, 25, 16, 0, 0);
// Act
var sut = new AvailabilityViewModel()
{
MyScheduleState = state,
ScheduleRepository = _ScheduleRepository.Object
};
sut.MySchedule = new Schedule {
Id = 1
};
sut.NewScheduleItem.StartDateTime = StartDate;
sut.NewScheduleItem.EndDateTime = EndDate;
sut.NewScheduleItem.Name = "Interview with Emma";
var results = await sut.AddNewScheduleItem();
// Assert
results.Should().BeEmpty();
_ScheduleRepository.Verify(r => r.AddNewScheduleItem(It.IsAny <Schedule>(),
It.Is <ScheduleItem>(i => i.StartDateTime == StartDate && i.EndDateTime == EndDate)),
Times.Once, "Did not load the schedule item properly");
}
public async Task <IActionResult> Enquire(Booking booking)
{
var errors = new List <string>();
booking.IsPendingApproval = true;
if (ModelState.IsValid)
{
//check date interception with other booking
{
if (booking.DateFrom < DateTime.Now || booking.DateTo < DateTime.Now)
{
return(await LoadEnquirePage(booking.CottageId,
new List <string>() { "Please select dates in the future" }));
}
if (booking.DateFrom > booking.DateTo)
{
return(await LoadEnquirePage(booking.CottageId,
new List <string>() { "The start date cannot be before the end date." }));
}
var bookingsOnCottage = await _bookingRepository.FindAysnc(b => b.CottageId == booking.CottageId);
var bookingsInFuture = bookingsOnCottage.Where(b => b.DateFrom >= booking.DateFrom || b.DateTo >= booking.DateFrom).ToList();
foreach (var futureBooking in bookingsInFuture)
{
if (_dateCheckerService.DoDatesIntercept(booking.DateFrom, booking.DateTo,
futureBooking.DateFrom, futureBooking.DateTo))
{
errors.Add("This cottage is already booked across those dates please check the calendar.");
return(await LoadEnquirePage(booking.CottageId,
errors));
}
}
}
int accountId = int.Parse(HttpContext.User.Claims
.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier)?.Value);
int customerId = await _customerRepository.GetCustomerByAccountIdAsync(accountId);
booking.CustomerId = customerId;
await _bookingRepository.AddAysnc(booking);
await _bookingRepository.SaveAsync();
var vm = new AvailabilityViewModel();
vm.Cottages = (List <Cottage>) await _cottageRepository.GetCottagesWithImagesAsync();
return(View("EmailSent", new EmailSentViewModel
{
EmailAddress = "*****@*****.**",
Message = "Please expect a response in the next few days from\n the cottages owners confirming your booking request."
}));
}
return(await LoadEnquirePage(booking.CottageId));
}
public ActionResult Availability(int id)
{
var carerHoliday = carerService.GetCarerHoliday(id);
if (carerHoliday == null)
{
carerHoliday = new Common.Models.CarerHoliday()
{
CarerID = id
};
}
var model = new AvailabilityViewModel()
{
Carer = carerService.GetCarer(id),
CarerAvailability = carerService.GetCarerAvailability(id),
CarerHoliday = carerHoliday
};
var headerInfo = new Dictionary <string, string>
{
{ "Last Updated", model.CarerAvailability.Max(x => x.UpdatedDate)?.ToString("dd/MM/yyyy") }
};
ViewBag.HeaderInfo = headerInfo;
return(View(model));
}
public IActionResult Configure()
{
AvailabilityViewModel Model = new AvailabilityViewModel();
string UserMail = this._UserManager.GetUserEmail(this.User);
int MedicKey = this._UserManager.GetMedicKeyByEmail(UserMail);
List <Availability>[] AvailabilityList = _GetEventsListFromUser(MedicKey);
Model.AvailabilityList = AvailabilityList;
return(View(Model));
}
public async Task <IActionResult> Index()
{
var cottages = await _cottageRepository.GetCottagesVisibleToClientsWithImagesAsync();
var vm = new AvailabilityViewModel {
Cottages = cottages
};
return(View("Availability", vm));
}
public AvailabilityViewModel PrepareModifyModel(int vehicleId, bool isEditMode = false)
{
var model = new AvailabilityViewModel
{
DateFrom = DateTime.Now,
DateTo = DateTime.Now.AddDays(1)
};
model.VehicleId = vehicleId;
var locations = _locationBusiness.GetAll();
model.Locations = Mapper.Map <List <LocationModel>, List <LocationViewModel> >(locations);
model.IsEditMode = isEditMode;
return(model);
}
public async Task <IActionResult> Availability(BookingTypes bookingType, SeatTypes seatType, ErrorCode errorCode)
{
if (seatType == default(SeatTypes))
{
seatType = bookingType == BookingTypes.StandardOrderVisit ? SeatTypes.StdRRSeat : SeatTypes.BulkOrderSeat;
}
var model = new AvailabilityViewModel
{
BookingType = bookingType,
SeatType = seatType,
AvailableBookings = await _availabilityService.GetAvailabilityAsync(seatType),
ErrorMessage = errorCode.ToMessage()
};
return(View(model));
}
public async Task ShouldReturnAppropriateValidationMessages()
{
// arrange
var state = new ScheduleState();
// Act
var sut = new AvailabilityViewModel()
{
MyScheduleState = state,
ScheduleRepository = _ScheduleRepository.Object
};
await sut.AddNewScheduleItem();
// Assert
_ScheduleRepository.Verify(r => r.AddNewScheduleItem(It.IsAny <Schedule>(), It.IsAny <ScheduleItem>()),
Times.Never, "Should not have attempted to save the schedule");
}
public ActionResult Index(string query = null, int pageNum = 0)
{
var bookableAvailability = _userAvailabilityService
.GetFutureBookableAvailabilitiesPaged(User.Identity.GetUserId(), pageNum, out int totalPages, query);
var viewModel = new AvailabilityViewModel()
{
Availability = Mapper.Map <IEnumerable <UserAvailabilityViewModel> >(bookableAvailability),
SearchTerm = query,
PageNum = pageNum,
TotalPages = totalPages,
Controller = "Appointment",
Action = "Index"
};
return(View("BookableAppointments", viewModel));
}
public ActionResult Modify(AvailabilityViewModel model, bool isEditMode = false)
{
if (model.DateFrom.Date < DateTime.Now.Date)
{
ModelState.AddModelError("", "Date from must be greater than date now or equals.");
}
if (model.DateFrom.Date >= model.DateTo.Date)
{
ModelState.AddModelError("", "Date to must be greater than date from.");
}
if (ModelState.IsValid)
{
var dbModel = Mapper.Map <AvailabilityViewModel, AvailabilityModel>(model);
if (model.Id > 0)
{
_availabilityBusiness.Edit(dbModel);
}
else
{
var isAdded = _availabilityBusiness.Add(dbModel);
if (!isAdded)
{
ModelState.AddModelError("", "Availability exists.");
var validModel = PrepareModifyModel(model.VehicleId, isEditMode);
model.DateFrom = model.DateFrom;
model.DateTo = model.DateTo;
return(View("Modify", validModel));
}
}
return(RedirectToAction("Index", new { vehicleId = model.VehicleId, isEditMode = isEditMode }));
}
var viewModel = PrepareModifyModel(model.VehicleId, isEditMode);
model.DateFrom = model.DateFrom;
model.DateTo = model.DateTo;
return(View("Modify", viewModel));
}
public ActionResult Availability(AvailabilityViewModel model)
{
var success = true;
try
{
model.CarerAvailability.ForEach(x => x.UpdatedByAdmin = true);
carerService.SaveCarerAvailability(model.CarerAvailability);
carerService.SaveCarerHoliday(model.CarerHoliday);
}
catch (Exception ex)
{
success = false;
loggingService.LogException(ex);
}
SetFeedbackMessage(success,
"Availability has been saved.",
"There has been an error whilst saving the availability.");
return(RedirectToSamePage());
}
public static AvailabilityViewModel UpdateCategory(this AvailabilityViewModel model)
{
var month = "";
var found = false;
var index = 0;
AvailableSeatGroup group = null;
foreach (var record in model.AvailableBookings)
{
if (record.AvailableSeats > 0 && !found)
{
found = true;
record.Id = "first-available";
model.FirstAvailableDate = record.Date.ToString("dddd dd MMMM yyyy");
}
else
{
record.Id = $"row-{index}";
}
if (month != record.Date.ToString("MMMM yyyy"))
{
month = record.Date.ToString("MMMM yyyy");
if (group != null)
{
model.AvailableSeatGroups.Add(group);
}
group = new AvailableSeatGroup
{
Month = month,
StartIndex = index
};
}
group.EndIndex = index;
index++;
}
model.AvailableSeatGroups.Add(group);
return(model);
}
public IEnumerable <SearcherViewModel> GetAllDestinationOffered(int id, DateTime date)
{
List <SearcherViewModel> listSearcher = new List <SearcherViewModel>();
IEnumerable <DestinationOffered> destinations = _destinationOffered.GetDestinationOfferedsByStationID(id);
if (destinations != null && destinations.Any())
{
foreach (DestinationOffered destination in destinations)
{
List <AvailabilityViewModel> availabilities = new List <AvailabilityViewModel>();
IEnumerable <VehicleDeparture> vehicles = _vehicleDeparture.GetVehicleDeparturesByDestinationId(destination.Id, date);
if (vehicles != null && vehicles.Any())
{
foreach (VehicleDeparture vehicle in vehicles)
{
AvailabilityViewModel availability = new AvailabilityViewModel()
{
Id = vehicle.Id,
DepartureDate = vehicle.DateTime,
Status = vehicle.State,
VehiclePlaque = vehicle.Plaque
};
availabilities.Add(availability);
}
}
SearcherViewModel searcherView = new SearcherViewModel()
{
StationId = destination.DestinationId,
CompanyName = destination.CompanyNit,
Price = destination.DestinationPrice,
Availability = availabilities.AsEnumerable()
};
listSearcher.Add(searcherView);
}
}
return(listSearcher.AsEnumerable());
}
public async Task <ActionResult <AvailabilityViewModel> > UpdateAvailabilityAsync(
AvailabilityViewModel availabilityViewModel)
{
if (availabilityViewModel == null || availabilityViewModel.Id == Guid.Empty)
{
return(BadRequest("No valid availability received"));
}
if (availabilityViewModel.ShiftId == Guid.Empty)
{
return(BadRequest("No valid shiftId received"));
}
if (availabilityViewModel.ParticipationId == Guid.Empty)
{
return(BadRequest("No valid participationId received"));
}
if (availabilityViewModel.Type == AvailibilityType.Scheduled)
{
return(BadRequest("Nice try, You cannot schedule yourself"));
}
try
{
Availability availability = (await availabilityService.GetAvailability(availabilityViewModel.Id)).Data;
if (availability == null)
{
return(BadRequest("Unable to convert availabilityViewModel to Availability"));
}
if (availability.Type == AvailibilityType.Scheduled)
{
return(BadRequest("Cannot modify availability when user is already scheduled"));
}
if (!availability.RowVersion.SequenceEqual(availabilityViewModel.RowVersion))
{
return(BadRequest("Outdated entity received"));
}
availability.Preference = availabilityViewModel.Preference;
availability.Type = availabilityViewModel.Type;
string oid = IdentityHelper.GetOid(HttpContext.User.Identity as ClaimsIdentity);
availability.LastEditBy = oid;
TaskResult <Availability> result = await availabilityService.UpdateAvailability(availability);
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
AvailabilityViewModel vm = AvailabilityViewModel.CreateVm(result.Data);
return(Ok(vm));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(SaveAvailabilityAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult <Availability> > SaveAvailabilityAsync(AvailabilityViewModel availabilityViewModel)
{
if (availabilityViewModel == null)
{
return(BadRequest("No valid availability received"));
}
if (availabilityViewModel.ShiftId == Guid.Empty)
{
return(BadRequest("No valid shiftId received"));
}
if (availabilityViewModel.ParticipationId == Guid.Empty)
{
return(BadRequest("No valid participationId received"));
}
if (availabilityViewModel.Type == AvailibilityType.Scheduled)
{
return(BadRequest("Nice try, You cannot schedule yourself"));
}
try
{
Availability availability =
(await availabilityService.GetAvailability((Guid)availabilityViewModel.ParticipationId,
availabilityViewModel.ShiftId)).Data;
if (availability != null)
{
return(UnprocessableEntity(new ErrorViewModel
{
Type = Type.Error, Message = "Availability already exists"
}));
}
availability = AvailabilityViewModel.CreateAvailability(availabilityViewModel);
if (availability == null)
{
return(BadRequest("Unable to convert availabilityViewModel to Availability"));
}
if (availability.Participation == null || availability.Shift == null)
{
return(BadRequest("Unable to add Participation and/of shift to Availability"));
}
availability.Participation = null;
availability.Shift = null;
string oid = IdentityHelper.GetOid(HttpContext.User.Identity as ClaimsIdentity);
availability.LastEditBy = oid;
TaskResult <Availability> result;
if (availability.Id == Guid.Empty)
{
result = await availabilityService.AddAvailability(availability);
}
else
{
return(BadRequest("Cannot update existing Availability with post method"));
}
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
return(Ok(AvailabilityViewModel.CreateVm(result.Data)));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(SaveAvailabilityAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public ActionResult SearchBookable(AvailabilityViewModel viewModel)
{
return(RedirectToAction("Index", new { query = viewModel.SearchTerm, pageNum = viewModel.PageNum }));
}
public JsonResult Availability([FromBody] AvailabilityViewModel model)
{
return(Json(null));
}
public async Task <ActionResult <List <ShiftViewModel> > > ExportDataAsync(Guid projectId)
{
if (projectId == Guid.Empty)
{
return(BadRequest("No valid id."));
}
try
{
TaskListResult <Shift> result = await shiftService.ExportDataAsync(projectId);
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
if (result.Data == null || result.Data.Count == 0)
{
return(Ok(new List <ShiftViewModel>()));
}
List <ShiftViewModel> shiftVmList = new List <ShiftViewModel>();
List <PersonViewModel> personViewModels = new List <PersonViewModel>();
foreach (Shift shift in result.Data)
{
ShiftViewModel shiftVm = ShiftViewModel.CreateVm(shift);
shiftVm.Availabilities = new List <AvailabilityViewModel>();
foreach (Availability availability in shift.Availabilities)
{
PersonViewModel pvm;
Guid id = availability.Participation.PersonId;
if (personViewModels.FirstOrDefault(pvms => pvms.Id == id) == null)
{
TaskResult <User> person = await personService.GetUserAsync(id);
pvm = PersonViewModel.CreateVmFromUser(person.Data,
Extensions.GetInstance(b2CExtentionApplicationId));
personViewModels.Add(pvm);
}
else
{
pvm = personViewModels.FirstOrDefault(pvm => pvm.Id == id);
}
AvailabilityViewModel avm = AvailabilityViewModel.CreateVm(availability);
avm.Participation.Person = pvm;
shiftVm.Availabilities.Add(avm);
}
shiftVmList.Add(shiftVm);
}
return(Ok(shiftVmList));
}
catch (Exception ex)
{
string message = GetType()
.Name + "Error in " + nameof(GetShiftAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
