public void Book_AvailabilityExists_ReturnViewPopulatedBookFormViewModel()
{
//Arrange
var availability = new UserAvailability()
{
Id = 1,
DateTime = DateTime.Now
};
_mockAvailabilityService.Setup(m => m.GetAvailability(It.IsAny <int>())).Returns(availability);
var types = new AppointmentType[] { new AppointmentType() };
_mockAppointmentService.Setup(m => m.GetAppointmentTypes()).Returns(types);
var times = new TimeSpan[] { new TimeSpan() };
_mockAppointmentService.Setup(m => m.GetAppointmentStartTimes(availability)).Returns(times);
_mockAppointmentService.Setup(m => m.GetAppointmentEndTimes(availability)).Returns(times);
//Act
var result = _controller.Book(1) as ViewResult;
var model = result.Model as BookFormViewModel;
//Assert
result.Should().NotBeNull();
result.ViewName.Should().Be("BookForm");
model.Availability.Id.Should().Be(availability.Id);
model.Types.Should().HaveCount(1);
model.StartTime.Should().Be(availability.GetStartTime());
model.SelectableStartTimes.Should().BeEquivalentTo(times);
model.SelectableEndTimes.Should().BeEquivalentTo(times);
}
public static double GetTotalOverlap(this CSGOTeam team, ApplicationUser user)
{
double total = 0;
foreach (TeamAvailability practice in team.PracticeSchedule.Where(d => d.Available))
{
UserAvailability availability = user.Availability.SingleOrDefault(a => a.Day == practice.Day && a.Available);
if (availability != null)
{
/* CASE 0
* user |------------|
* team |----------------------|
* OR
* user |------------|
* team |----------------------|
*/
if (practice.To <= availability.From || practice.From >= availability.To)
{
continue;
}
/* CASE 1
* user |------------|
* team |----------------------|
*/
if (practice.From <= availability.From && practice.To >= availability.To)
{
total += (availability.To - availability.From).TotalHours;
}
/* CASE 2
* user |----------------------|
* team |------------|
*/
else if (practice.From >= availability.From && practice.To <= availability.To)
{
total += (practice.To - practice.From).TotalHours;
}
/* CASE 3
* user |---------|
* team |------------|
*/
else if (practice.To > availability.From)
{
total += (practice.To - availability.From).TotalHours;
}
/* CASE 4
* user |---------|
* team |------------|
*/
else if (practice.From < availability.To)
{
total += (availability.To - practice.From).TotalHours;
}
}
}
return(total);
}
public ServiceResult UpdateAvailability(UserAvailability userAvailability)
{
_unitOfWork.UserAvailability.Update(userAvailability);
_unitOfWork.Complete();
return(new ServiceResult(true));
}
public IActionResult Put(int id, [FromBody] UserAvailability model)
{
try
{
model.ModifiedBy = base.CurrentUser.Id;
var result = _service.UpdateAvailability(model);
if (result != "accepted" && result != "unavailable")
{
// Audit Log
var audit = new AuditLog
{
UserId = CurrentUser.Id,
EntityId = id.ToString(),
EntityType = AuditLogs.EntityType.Unavailability,
ActionType = AuditLogs.ActionType.UpdatedUnavailability,
PostValue = Serializer.Serialize(model),
DistrictId = CurrentUser.DistrictId,
OrganizationId = CurrentUser.OrganizationId == "-1" ? null : CurrentUser.OrganizationId
};
_audit.InsertAuditLog(audit);
return(Json("success"));
}
return(Json(result));
}
catch (Exception ex)
{
}
finally
{
}
return(null);
}
public IActionResult Delete(int id)
{
try
{
var model = new UserAvailability();
model.AvailabilityId = id;
model.ArchivedBy = base.CurrentUser.Id;
var result = _service.DeleteAvailability(model);
// Audit Log
var audit = new AuditLog
{
UserId = CurrentUser.Id,
EntityId = id.ToString(),
EntityType = AuditLogs.EntityType.Unavailability,
ActionType = AuditLogs.ActionType.DeletedUnavailability,
DistrictId = CurrentUser.DistrictId,
OrganizationId = CurrentUser.OrganizationId == "-1" ? null : CurrentUser.OrganizationId
};
_audit.InsertAuditLog(audit);
return(Ok(result));
}
catch (Exception ex)
{
}
finally
{
}
return(null);
}
public void Book__InvalidModel_ShouldReloadPageWithErrors()
{
//Arrange
var availability = new UserAvailability()
{
Id = 113,
DateTime = DateTime.Parse("21/09/2018 15:50"),
TimeSpan = new TimeSpan(2, 0, 0)
};
_mockAvailabilityService.Setup(m => m.GetAvailability(It.IsAny <int>())).Returns(availability);
var viewModel = new BookFormViewModel()
{
Availability = new UserAvailabilityViewModel()
{
Id = 113,
DateTime = DateTime.Parse("21/09/2018 15:50"),
TimeSpan = new TimeSpan(2, 0, 0)
}
};
_controller.ModelState.AddModelError("test", "test");
//Act
var result = _controller.Book(viewModel) as ViewResult;
//Assert
result.Should().NotBeNull();
result.ViewName.Should().Be("BookForm");
result.Model.Should().BeOfType <BookFormViewModel>();
_controller.ModelState.IsValid.Should().Be(false);
}
public IEnumerable <TimeSpan> GetAppointmentStartTimes(UserAvailability availability)
{
var startTime = availability.GetStartTime();
return(new TimeSpan().HoursOfTheDay()
.Where(t => t >= startTime));
}
public IActionResult ProvideAvailability(UserAvailability model)
{
if (ModelState.IsValid)
{
string currentUser = HttpContext.Session.GetString("Uid");
int userid = GetCurrentUserID(currentUser);
bool existantdate = false;
model.availability.UserId = userid;
foreach (Availability availability in _Availability.GetAvailabilities)
{
if (availability.UserId == userid && availability.team_id == availability.team_id)
{
if (availability.work_date == model.availability.work_date)
{
existantdate = true;
break;
}
}
}
if (existantdate == false)
{
_Availability.Add(model.availability);
}
}
return(RedirectToAction("TeamInfoPage", "Team", new { t = model.availability.team_id }));
}
public UserAvailabilityEditViewModel(bool forUser, UserAvailability userAvailability, List <User> users, User selectedUser)
{
Users = new ObservableCollection <User>(forUser ? new List <User>() : users);
ForUser = forUser;
var user = LoginHelper.GetLoggedInUser().User;
if (userAvailability != null)
{
UserAvailability = userAvailability;
UserAvailability.User = forUser ? user : Users.FirstOrDefault(u => u.UserId == UserAvailability.UserId);
}
else
{
UserAvailability = userAvailability ?? new UserAvailability()
{
UserId = user.UserId, Status = ForUser ? 0 : 1, StartTimeTimezonedValue = new DateTime(2000, 1, 1), EndTimeTimezonedValue = new DateTime(2000, 1, 1)
};
UserAvailability.User = forUser ? user : Users.FirstOrDefault(u => u.UserId == (selectedUser == null ? user.UserId : selectedUser.UserId));
}
if (UserAvailability.UserAvailabilityId != null)
{
var day = (DayOfWeek)UserAvailability.DayOfWeekValue;
var boolDay = this.GetType().GetProperty(day.ToString(), System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
boolDay.SetValue(this, true);
}
this.SaveCommand = new Command(async(status) => await saveAvailability(Convert.ToInt16(status)));
}
private async System.Threading.Tasks.Task editAvailability(UserAvailability availability)
{
var page = new UserAvailabilityEditPage();
var editViewModel = new UserAvailabilityEditViewModel(viewModel.ForUser, availability, viewModel.Users.ToList(), viewModel.SelectedUser);
page.BindingContext = editViewModel;
await((MainPage)App.Current.MainPage).NavigateTo(page, true);
}
public async System.Threading.Tasks.Task ExecuteDeleteCommand(UserAvailability availability)
{
if (await runTask(async() => await DataService.DeleteItemAsync("userAvailability", availability.UserAvailabilityIdValue),
"Are you sure you want to delete this availability?"))
{
await ExecuteLoadAvailabilityCommand();
}
}
public void CreateAvailability_ValidAvailability_ServiceResultSuceeded()
{
var userAvailability = new UserAvailability();
var result = _service.CreateAvailability(userAvailability);
result.Succeeded.Should().BeTrue();
}
public void GetAppointmentStartTimes_AvailabilityStartTime0000_ReturnsTimeSpansGreaterThanavailabiltyStartTime()
{
var availability = new UserAvailability()
{
DateTime = new DateTime(2018, 10, 5, 0, 0, 0)
};
var result = _service.GetAppointmentStartTimes(availability);
result.Any(t => t < availability.GetStartTime()).Should().BeFalse();
result.Should().HaveCount(24);
}
public void GetStartTime_DateTimeHasMinutes_ReturnedTimeSpanOnlyHours()
{
var userAvailability = new UserAvailability()
{
DateTime = new DateTime(2018, 10, 6, 23, 10, 0)
};
var expectedTimespan = new TimeSpan(userAvailability.DateTime.Hour, 0, 0);
var result = userAvailability.GetStartTime();
result.Should().Be(expectedTimespan);
}
public void BookAppointment_AvailabilityNotFound_ReturnServiceFailuare()
{
var expectedResult = new ServiceResult(false, "User Availability not Found");
UserAvailability availability = null;
int availabilityId = 1;
_mockUserAvailabilityRepository.Setup(m => m.GetById(availabilityId)).Returns(availability);
var result = _service.BookAppointment("test", DateTime.Now, TimeSpan.Zero, "", 0, availabilityId);
result.Should().NotBeNull();
result.Succeeded.Should().Be(expectedResult.Succeeded);
result.ErrorMessage.Should().Be(expectedResult.ErrorMessage);
}
public void GetAppointmentEndTimes_AvailabilityStartTime0000EndTime04000_ReturnsTimeSpansGreaterThanavailabiltyStartTimeLessThanEndTime()
{
var availability = new UserAvailability()
{
DateTime = new DateTime(2018, 10, 5, 0, 0, 0),
TimeSpan = new TimeSpan(4, 0, 0)
};
var result = _service.GetAppointmentEndTimes(availability);
result.All(t => t > availability.GetStartTime()).Should().BeTrue();
result.All(t => t <= availability.GetEndTime()).Should().BeTrue();
result.Should().HaveCount(4);
}
public void Book_NoAvailabilityExists_ReturnHttpNotFound()
{
//Arrange
UserAvailability availability = null;
_mockAvailabilityService.Setup(m => m.GetAvailability(It.IsAny <int>())).Returns(availability);
//Act
var result = _controller.Book(1) as ActionResult;
//Assert
result.Should().NotBeNull();
result.Should().BeOfType <HttpNotFoundResult>();
}
public IActionResult CheckSubstituteAvailability([FromBody] UserAvailability model)
{
try
{
var result = _service.CheckSubAvailability(model);
return(Ok(result));
}
catch (Exception ex)
{
}
finally
{
}
return(null);
}
/// <summary>
/// Aktualisiert die Benutzer Verfügbarkeit
/// </summary>
/// <param name="id">Die Benutzer Id oder radioId</param>
/// <param name="userAvailability">Die Benutzer Verfügbarkeit</param>
/// <returns>Nichts</returns>
public async Task PutUserAvailability(string id, UserAvailability userAvailability)
{
if (userAvailability == null)
{
throw new ArgumentNullException(nameof(userAvailability));
}
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "interfaces/public/user/" + id + "/availability/current")
{
Content = new StringContent(System.Text.Json.JsonSerializer.Serialize(userAvailability), Encoding.UTF8, "application/json")
};
System.Text.Json.JsonSerializer.Serialize(userAvailability);
await client.SendAsync(request);
}
public void Edit__AvailabilityNotFound_ShouldReturnHttpNotFound()
{
//Arrange
UserAvailability expectedResult = null;
_mockService.Setup(m => m.GetAvailability(It.IsAny <int>()))
.Returns(expectedResult);
//Act
var result = _controller.Edit(1) as ActionResult;
//Assert
result.Should().NotBeNull();
result.Should().BeOfType <HttpNotFoundResult>();
}
public void Delete_ValidRequest_ShouldReturnSucceeded()
{
var expectedResult = new ServiceResult(true);
var availability = new UserAvailability()
{
UserId = _userId
};
_mockRepository.Setup(r => r.GetById(1)).Returns(availability);
var result = _service.DeleteAvailability(1, _userId);
result.Succeeded.Should().Be(expectedResult.Succeeded);
result.ErrorMessage.Should().Be(expectedResult.ErrorMessage);
}
public void Delete_AvailabilityForDifferentuser_ShouldReturnOk()
{
var expectedResult = new ServiceResult(false, "User does not have permission.");
var availability = new UserAvailability()
{
UserId = _userId + "-"
};
_mockRepository.Setup(r => r.GetById(1)).Returns(availability);
var result = _service.DeleteAvailability(1, _userId);
result.Succeeded.Should().Be(expectedResult.Succeeded);
result.ErrorMessage.Should().Be(expectedResult.ErrorMessage);
}
public void GetFutureUserAvailabilitiesPaged_WhenCalledValidQuery_ReturnsUserAvailabilities()
{
//Arrange
var availabilities = new UserAvailability[] { new UserAvailability() };
int pageNum = 0;
int totalPages = 3;
string query = "16/10/2018";
_mockRepository.Setup(m => m.GetFutureUserAvailabilitiesPaged(_userId, pageNum, out totalPages, query, It.IsAny <int>()))
.Returns(availabilities);
var result = _service.GetFutureUserAvailabilitiesPaged(_userId, pageNum, out totalPages, query);
result.Should().NotBeNull();
result.Should().BeEquivalentTo(availabilities);
}
public void BookAppointment_Success_ReturnServiceSuccess()
{
var expectedResult = new ServiceResult(true);
UserAvailability availability = new UserAvailability()
{
Id = 1,
};
_mockUserAvailabilityRepository.Setup(m => m.GetById(availability.Id)).Returns(availability);
var result = _service.BookAppointment("test", DateTime.Now, TimeSpan.Zero, "", 0, availability.Id);
result.Should().NotBeNull();
result.Succeeded.Should().Be(expectedResult.Succeeded);
result.ErrorMessage.Should().Be(expectedResult.ErrorMessage);
}
public void GetFutureUserAvailabilities_AvailabilityForDifferentUser_ShouldNotBeReturned()
{
var availability = new UserAvailability()
{
DateTime = DateTime.Now.AddDays(1),
UserId = "1"
};
_mockUserAvailability.SetSource(new[] { availability });
_mockContext.SetupGet(c => c.UserAvailabilties).Returns(_mockUserAvailability.Object);
var userAvailabilties = _repository.GetFutureUserAvailabilities(availability.UserId + "-");
userAvailabilties.Should().BeEmpty();
}
public void GetFutureUserAvailabilities_AvailabilityForGivenUserAndIsInTheFuture_ShouldBeReturned()
{
var availability = new UserAvailability()
{
DateTime = DateTime.Now.AddDays(1),
UserId = "1"
};
_mockUserAvailability.SetSource(new[] { availability });
_mockContext.SetupGet(c => c.UserAvailabilties).Returns(_mockUserAvailability.Object);
var userAvailabilties = _repository.GetFutureUserAvailabilities(availability.UserId);
userAvailabilties.Should().Contain(availability);
}
public IHttpActionResult SetAvailability(UserAvailability newAvailability)
{
ApplicationUser user = GetAuthUser();
UserAvailability entity = _dbContext.Users.Find(user.Id).Availability.First(a => a.Day == newAvailability.Day);
_dbContext.Entry(entity).CurrentValues.SetValues(newAvailability);
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"User availability error: ${e.Message}");
return(BadRequest("Something went wrong... "));
}
return(Ok(entity));
}
public void GetAvailability_WhenCalled_ReturnsAvailability()
{
//Arrange
var availability = new UserAvailability()
{
Id = 1
};
_mockRepository.Setup(m => m.GetById(availability.Id))
.Returns(availability);
//Act
var result = _service.GetAvailability(availability.Id);
//Assert
result.Should().NotBeNull();
result.Should().Be(availability);
}
public void GetFutureUserAvailabilitiesPaged_InvalidSearchTerm_ShouldNotBeReturned()
{
string userId = "1";
int pageNum = 0;
string searchTerm = "test";
var availability = new UserAvailability()
{
DateTime = DateTime.Now.AddDays(1),
UserId = userId
};
_mockUserAvailability.SetSource(new[] { availability });
_mockContext.SetupGet(c => c.UserAvailabilties).Returns(_mockUserAvailability.Object);
var userAvailabilties = _repository.GetFutureUserAvailabilitiesPaged(userId, pageNum, out int totalPages, searchTerm);
}
public async Task <IActionResult> SetAvailability(UserAvailability newAvailability)
{
ApplicationUser user = await GetAuthUser();
UserAvailability entity = await _dbContext.UserAvailabilities.FindAsync(user.Id, newAvailability.Day);
_dbContext.Entry(entity).CurrentValues.SetValues(newAvailability);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"User availability error: ${e.Message}");
return(BadRequest("Something went wrong... "));
}
return(Ok(entity));
}
