public override ValidationResult Validate(SessionRequestDto entity)
{
var validation = base.Validate(entity);
if (validation.Errors.Any())
{
return(validation);
}
var hasComponent = _componentRepository.GetComponentsByModule(entity.ModuleId);
if (!hasComponent.Any())
{
validation.Errors.Add("You can't open a session without any components");
}
var classroomByModule = _classroomRepository.GetClassroomByModule(entity.ModuleId);
if (classroomByModule == null)
{
validation.Errors.Add($"No classroom was assigned to {entity.ModuleId}");
}
var session = _repository.GetOpenSessions(entity.ModuleId).ToList();
if (session.Count >= 1)
{
validation.Errors.Add($"A session for {entity.ModuleId} was already opened");
}
return(validation);
}
public async Task <IActionResult> sessions([FromBody] SessionRequestDto sessionRequest)
{
string token = string.Empty;
User user = null;
var tokenStr = await AuthService.LoginByPWD(sessionRequest.email, sessionRequest.password);
if (!string.IsNullOrEmpty(tokenStr))
{
var response = new SessionResponseDto
{
id = token,
user_id = user.UserId.ToHex24()
};
return(Json(response, MyJsonConvert.GetLeanoteOptions()));
}
else
{
var response = new SessionResponseDto
{
error = "Invalid username or password"
};
//（禁止） 服务器拒绝请求。
Response.StatusCode = (int)HttpStatusCode.Forbidden;
return(Json(response, MyJsonConvert.GetLeanoteOptions()));
}
}
public async void RequestSession_Returns_OkObjectResult_With_SessionRequestDto()
{
var userId = Guid.NewGuid();
var roomId = Guid.NewGuid();
var startTime = new DateTime(2018, 1, 1, 10, 0, 0, DateTimeKind.Unspecified);
var endTime = startTime.AddHours(2);
_identity.Setup(i => i.IsAuthenticated).Returns(true);
_identity.Setup(i => i.Name).Returns(userId.ToString());
_identity.Setup(i => i.Claims).Returns(new List <Claim>
{
new Claim(ClaimTypes.Name, userId.ToString()),
new Claim(ApiClaimTypes.TimeZoneId, "1"),
new Claim(ApiClaimTypes.TimeZoneName, "Central Standard Time"),
new Claim(ApiClaimTypes.TimeZoneUtcOffset, "-6")
});
var room = new RoomDto
{
Id = roomId
};
var expectedModel = new SessionRequestDto
{
Id = Guid.NewGuid(),
RoomId = roomId,
RequestingUserId = userId,
RequestedTime = new DateRangeDto {
Start = startTime, End = endTime
}
};
_roomService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(room));
_roomService
.Setup(s => s.RequestSessionAsync(It.IsAny <SessionRequestDto>()))
.Returns(Task.FromResult(expectedModel));
var result = await _roomsController.RequestSession(roomId, expectedModel.RequestedTime);
Assert.IsType <OkObjectResult>(result);
var okResult = result as OkObjectResult;
Assert.IsType <SessionRequestDto>(okResult.Value);
var actual = okResult.Value as SessionRequestDto;
Assert.Equal(expectedModel.Id, actual.Id);
Assert.Equal(expectedModel.RoomId, actual.RoomId);
Assert.Equal(expectedModel.RequestingUserId, actual.RequestingUserId);
Assert.Equal(expectedModel.RequestedTime.Start, actual.RequestedTime.Start);
Assert.Equal(expectedModel.RequestedTime.End, actual.RequestedTime.End);
}
public async Task <SessionResponseDto> Close(SessionRequestDto sessionRequest)
{
var session = GetCurrentSession(sessionRequest);
session.EndTime = DateTime.UtcNow.FromUtcToGmt();
var updatedSession = await _sessionRepository.UpdateSession(session);
var(totalStudents, finishedStudents) = GetStudentStats(updatedSession);
return(_mapper.Map <SessionResponseDto>((totalStudents, finishedStudents, updatedSession)));
}
public async Task <SessionResponseDto> Open(SessionRequestDto sessionRequest)
{
var sessionModel = _mapper.Map <Session>(sessionRequest);
sessionModel.StartTime = DateTime.UtcNow.FromUtcToGmt();
var savedSession = await _sessionRepository.SaveSession(sessionModel);
var(totalStudents, finishedStudents) = GetStudentStats(savedSession);
return(_mapper.Map <SessionResponseDto>((totalStudents, finishedStudents, savedSession)));
}
public async Task <IActionResult> CloseSession(SessionRequestDto sessionRequest)
{
var validationResult = _closeSessionRequestDtoValidator.Validate(sessionRequest);
if (validationResult.Errors.Any())
{
return(BadRequest(validationResult));
}
var sessionResponseDto = await _sessionProcessor.Close(sessionRequest);
return(Ok(sessionResponseDto));
}
public async Task <SessionRequestDto> RequestSessionAsync(SessionRequestDto model)
{
var requestedDateRange = model.RequestedTime != null
? DateRange.Create(model.RequestedTime.Start, model.RequestedTime.End)
: null;
var room = await _roomRepository.GetAsync(model.RoomId);
var newModel = room.RequestSession(model.RequestingUserId, requestedDateRange, model.RoomFunctionId, _sessionScheduleValidator);
var entity = await _roomRepository.RequestSessionAsync(newModel);
var result = _mapper.Map <SessionRequestDto>(entity);
return(result);
}
public async void RejectSessionRequest_Returns_OkObjectResult_With_Rejected_SessionRequestDto(string reason)
{
var userId = Guid.NewGuid();
var roomId = Guid.NewGuid();
var startTime = DateTime.Now;
var endTime = startTime.AddHours(2);
_identity.Setup(i => i.IsAuthenticated).Returns(true);
_identity.Setup(i => i.Name).Returns(userId.ToString());
var room = new RoomDto
{
Id = roomId
};
var expectedModel = new SessionRequestDto
{
Id = Guid.NewGuid(),
RoomId = roomId,
RequestingUserId = userId,
RequestedTime = new DateRangeDto {
Start = startTime, End = endTime
},
SessionRequestStatusId = (int)SessionRequestStatusId.Rejected,
RejectedReason = reason
};
_roomService
.Setup(s => s.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(room));
_roomService
.Setup(s => s.RejectSessionRequestAsync(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <string>()))
.Returns(Task.FromResult(expectedModel));
var result = await _roomsController.RejectSessionRequest(roomId, expectedModel.Id, reason);
Assert.IsType <OkObjectResult>(result);
var okResult = result as OkObjectResult;
Assert.IsType <SessionRequestDto>(okResult.Value);
var actual = okResult.Value as SessionRequestDto;
Assert.Equal(expectedModel.SessionRequestStatusId, actual.SessionRequestStatusId);
Assert.Equal(expectedModel.RejectedReason, actual.RejectedReason);
}
private Session GetCurrentSession(SessionRequestDto sessionRequest)
{
var sessions = _sessionRepository.GetOpenSessions(sessionRequest.ModuleId).ToList();
if (sessions.Count > 1)
{
throw new Exception($"Multiple open session for {sessionRequest.ModuleId} found!");
}
if (sessions.Count == 0)
{
throw new Exception($"No open session for {sessionRequest.ModuleId} found!");
}
return(sessions.First());
}
public async void RequestSessionAsync_Returns_New_SessionRequestDto()
{
var studioId = Guid.NewGuid();
var room = Room.Create(studioId, "Room");
var userId = Guid.NewGuid();
var startTime = DateTime.Now;
var endTime = startTime.AddHours(2);
var requestedTime = DateRange.Create(startTime, endTime);
var entity = room.RequestSession(userId, requestedTime, null, _sessionScheduleValidator.Object);
var requestedTimeDto = new DateRangeDto {
Start = startTime, End = endTime
};
_roomRepository
.Setup(r => r.GetAsync(It.IsAny <Guid>()))
.Returns(Task.FromResult(room));
_roomRepository
.Setup(r => r.RequestSessionAsync(It.IsAny <SessionRequest>()))
.Returns(Task.FromResult(entity));
_sessionScheduleValidator
.Setup(v => v.ValidateAsync(It.IsAny <Guid>(), It.IsAny <Guid?>(), It.IsAny <DateRange>()))
.Returns(Task.FromResult(SessionScheduleValidatorResult.Success));
var dto = new SessionRequestDto
{
RoomId = room.Id,
RequestingUserId = userId,
RequestedTime = new DateRangeDto {
Start = startTime, End = endTime
}
};
var result = await _roomService.RequestSessionAsync(dto);
Assert.NotNull(result);
Assert.Equal(entity.Id, result.Id);
Assert.Equal(entity.RoomId, result.RoomId);
Assert.Equal(entity.RoomFunctionId, result.RoomFunctionId);
Assert.Equal(entity.RequestingUserId, result.RequestingUserId);
Assert.Equal(entity.RequestedStartTime, result.RequestedTime.Start);
Assert.Equal(entity.RequestedEndTime, result.RequestedTime.End);
}
public override ValidationResult Validate(SessionRequestDto entity)
{
var validation = base.Validate(entity);
if (validation.Errors.Any())
{
return(validation);
}
var session = _repository.GetOpenSessions(entity.ModuleId).ToList();
if (session.Count == 0)
{
validation.Errors.Add("No open session found!");
}
return(validation);
}
public async Task <IActionResult> RequestSession(Guid id, [FromBody] DateRangeDto requestedTime)
{
var room = await _roomService.GetAsync(id);
if (room == null)
{
return(NotFound());
}
var model = new SessionRequestDto
{
RoomId = room.Id,
RequestingUserId = UserId.Value,
RequestedTime = requestedTime
};
model.RequestedTime?.ConvertToUtc(UserTimeZone.Name);
var request = await _roomService.RequestSessionAsync(model);
return(Ok(request));
}
