public async Task CancelExchangeTest()
{
IMongoDatabase database = _mongoFixture.MongoClient.GetDatabase("StudentsDB");
StudentService studentSrv = new StudentService(database);
BlockChangesService blockChangeService = new BlockChangesService(database);
var options = GetProxyOptions();
var schoolScheduleProxy = new SchoolScheduleProxy(options);
var schoolCourseProxy = new SchoolCourseProxy(options);
CourseService courseService = new CourseService(_loggerMockCourse.Object, database, schoolScheduleProxy, schoolCourseProxy);
Course course = await CreateAndAddCourse("Programovanie", "11111", courseService);
Block block1 = CreateBlock(BlockType.Laboratory, Day.Monday, 2, 7, course.Id);
Block block2 = CreateBlock(BlockType.Laboratory, Day.Wednesday, 2, 10, course.Id);
Block block3 = CreateBlock(BlockType.Laboratory, Day.Wednesday, 2, 8, course.Id);
Student student = new Student();
await studentSrv.AddAsync(student);
BlockChangeRequest blockToChange = CreateBlockChangeRequest(block2, block1, student.Id);
BlockChangeRequest blockToChange1 = CreateBlockChangeRequest(block3, block1, student.Id);
(await blockChangeService.AddAndFindMatch(blockToChange)).Should().Be((null, null));
(await blockChangeService.AddAndFindMatch(blockToChange1)).Should().Be((null, null));
blockChangeService.FindWaitingStudentRequests(student.Id).Result.Count.Should().Be(2);
(await blockChangeService.CancelExchangeRequest(blockToChange1)).Should().Be(true);
blockChangeService.FindWaitingStudentRequests(student.Id).Result.Count.Should().Be(1);
}
private async Task SetDoneStatus(BlockChangeRequest request)
{
if (request.Status == ExchangeStatus.Done)
{
await new Task(() => { throw new ArgumentException("You cannot exchange requests which are already exchanged!"); });
}
request.Status = ExchangeStatus.Done;
await _blockChangesCollection.ReplaceOneAsync(x => x.Id == request.Id, request);
}
private async Task RemoveStudentRequests(BlockChangeRequest request)
{
await _blockChangesCollection.DeleteManyAsync(x => x.StudentId == request.StudentId &&
x.BlockFrom.CourseId == request.BlockFrom.CourseId &&
x.BlockFrom.StartHour == request.BlockFrom.StartHour &&
x.BlockFrom.Day == request.BlockFrom.Day &&
x.BlockFrom.Duration == request.BlockFrom.Duration &&
x.Status == ExchangeStatus.WaitingForExchange);
}
public async Task <IActionResult> CancelExchangeRequest([FromBody] BlockChangeRequest request)
{
var response = await _blockChangesService.CancelExchangeRequest(request);
if (response)
{
return(Ok(response));
}
return(ErrorResponse($"Cannot cancel request from student {request.StudentId} because it was changed"));
}
private BlockChangeRequest CreateBlockChangeRequest(Block blockFrom, Block blockTo, Guid studentId)
{
BlockChangeRequest blockToChange = new BlockChangeRequest();
blockToChange.DateOfCreation = DateTime.Now;
blockToChange.BlockFrom = blockFrom.Clone();
blockToChange.BlockTo = blockTo.Clone();
blockToChange.StudentId = studentId;
return(blockToChange);
}
private async Task <BlockChangeRequest> FindExchange(BlockChangeRequest blockRequest)
{
return(await _blockChangesCollection.Find(
x => (x.BlockTo.CourseId == blockRequest.BlockFrom.CourseId &&
x.BlockTo.Day == blockRequest.BlockFrom.Day &&
x.BlockTo.Duration == blockRequest.BlockFrom.Duration &&
x.BlockTo.StartHour == blockRequest.BlockFrom.StartHour &&
x.BlockFrom.CourseId == blockRequest.BlockTo.CourseId &&
x.BlockFrom.Day == blockRequest.BlockTo.Day &&
x.BlockFrom.Duration == blockRequest.BlockTo.Duration &&
x.BlockFrom.StartHour == blockRequest.BlockTo.StartHour &&
x.StudentId != blockRequest.StudentId &&
x.Status != ExchangeStatus.Done)).SortBy(x => x.DateOfCreation).FirstOrDefaultAsync());
}
public async Task <bool> CancelExchangeRequest(BlockChangeRequest request)
{
BlockChangeRequest a = null;
if (request.Status == ExchangeStatus.WaitingForExchange)
{
a = await _blockChangesCollection.FindOneAndDeleteAsync(
x => x.StudentId == request.StudentId &&
x.BlockFrom.CourseId == request.BlockFrom.CourseId &&
x.BlockFrom.StartHour == request.BlockFrom.StartHour &&
x.BlockFrom.Day == request.BlockFrom.Day &&
x.BlockFrom.Duration == request.BlockFrom.Duration &&
x.Status == request.Status);
}
return(a != null);
}
public async Task <IActionResult> ExchangeConfirm([FromBody] ExchangeRequestModel request)
{
try
{
var blockChangeRequest = new BlockChangeRequest();
blockChangeRequest.BlockFrom = BlockForExchangeModel.ConvertToBlock(request.BlockFrom);
blockChangeRequest.BlockTo = BlockForExchangeModel.ConvertToBlock(request.BlockTo);
blockChangeRequest.Status = ExchangeStatus.WaitingForExchange;
blockChangeRequest.DateOfCreation = DateTime.Now;
blockChangeRequest.StudentId = Guid.Parse(request.StudentId);
var res = await _blockChangesService.AddAndFindMatch(blockChangeRequest);
if (res != (null, null))
{
var student1 = await _studentService.FindByIdAsync(res.Item1.StudentId);
student1.Timetable.RemoveBlock(res.Item1.BlockFrom.BlockId);
student1.Timetable.AddNewBlock(res.Item1.BlockTo.Clone());
await _studentService.UpdateStudentAsync(student1);
var user1 = await _userService.GetUserByIdAsync(student1.UserId.ToString());
if (user1 == null)
{
string message = $"Cannot find user with ID {res.Item1.StudentId}.";
_logger.LogError(message);
return(NotFound(message));
}
var student2 = await _studentService.FindByIdAsync(res.Item2.StudentId);
student2.Timetable.RemoveBlock(res.Item2.BlockFrom.BlockId);
student2.Timetable.AddNewBlock(res.Item2.BlockTo.Clone());
await _studentService.UpdateStudentAsync(student2);
var user2 = await _userService.GetUserByIdAsync(student2.UserId.ToString());
if (user2 == null)
{
string message = $"Cannot find user with ID {res.Item2.StudentId}.";
_logger.LogError(message);
return(NotFound(message));
}
string callbackUrl1 = new Uri(_baseUrl, $@"getStudentTimetable/{user1.Email}").ToString();
string callbackUrl2 = new Uri(_baseUrl, $@"getStudentTimetable/{user2.Email}").ToString();
if (!_emailService.SendConfirmationEmail(user1.Email, callbackUrl1, "ConfirmExchangeEmail"))
{
string message = $"Error when sending confirmation email to user {user1.Email}.";
_logger.LogError(message);
}
if (!_emailService.SendConfirmationEmail(user2.Email, callbackUrl2, "ConfirmExchangeEmail"))
{
string message = $"Error when sending confirmation email to user {user2.Email}.";
_logger.LogError(message);
}
return(Ok(res));
}
return(Ok(null));
}
catch
{
string message = $"Error when creating block change request";
_logger.LogError(message);
return(ErrorResponse(message));
}
}
public async Task ExchangeRequests_ExchangingRequests_ExchangedRequests()
{
IMongoDatabase database = _mongoFixture.MongoClient.GetDatabase("StudentsDB");
StudentService studentSrv = new StudentService(database);
BlockChangesService blockChangeService = new BlockChangesService(database);
var options = GetProxyOptions();
var schoolScheduleProxy = new SchoolScheduleProxy(options);
var schoolCourseProxy = new SchoolCourseProxy(options);
CourseService courseService = new CourseService(_loggerMockCourse.Object, database, schoolScheduleProxy, schoolCourseProxy);
Course course = await CreateAndAddCourse("Programovanie", "11111", courseService);
Course course2 = await CreateAndAddCourse("Programovanie", "11111", courseService);
Block block1 = CreateBlock(BlockType.Laboratory, Day.Monday, 2, 7, course.Id);
Block block2 = CreateBlock(BlockType.Laboratory, Day.Wednesday, 2, 10, course.Id);
Block block3 = CreateBlock(BlockType.Laboratory, Day.Tuesday, 2, 15, course.Id);
Block block4 = CreateBlock(BlockType.Laboratory, Day.Friday, 2, 18, course2.Id);
Student student1 = new Student();
Student student2 = new Student();
Student student3 = new Student();
await studentSrv.AddAsync(student1);
await studentSrv.AddAsync(student2);
await studentSrv.AddAsync(student3);
BlockChangeRequest blockToChange1 = CreateBlockChangeRequest(block1, block2, student1.Id);
BlockChangeRequest blockToChange2 = CreateBlockChangeRequest(block1, block3, student1.Id);
BlockChangeRequest blockToChange3 = CreateBlockChangeRequest(block1, block2, student2.Id);
BlockChangeRequest blockToChange4 = CreateBlockChangeRequest(block1, block3, student2.Id);
BlockChangeRequest blockToChange5 = CreateBlockChangeRequest(block4, block2, student3.Id);
BlockChangeRequest blockToChange = CreateBlockChangeRequest(block2, block1, student3.Id);
ValueTuple <BlockChangeRequest, BlockChangeRequest> result = new ValueTuple <BlockChangeRequest, BlockChangeRequest>();
result = (null, null);
(await blockChangeService.AddAndFindMatch(blockToChange1)).Should().Equals(result);
(await blockChangeService.AddAndFindMatch(blockToChange2)).Should().Equals(result);
(await blockChangeService.AddAndFindMatch(blockToChange3)).Should().Equals(result);
(await blockChangeService.AddAndFindMatch(blockToChange4)).Should().Equals(result);
(await blockChangeService.AddAndFindMatch(blockToChange5)).Should().Equals(result);
result = (blockToChange, blockToChange1);
(await blockChangeService.AddAndFindMatch(blockToChange)).Should().Equals(result);
blockChangeService.FindAllStudentRequests(student1.Id).Result.Count.Should().Be(1);
blockChangeService.FindAllStudentRequests(student2.Id).Result.Count.Should().Be(2);
blockChangeService.FindAllStudentRequests(student3.Id).Result.Count.Should().Be(2);
blockChangeService.FindWaitingStudentRequests(student1.Id).Result.Count.Should().Be(0);
blockChangeService.FindWaitingStudentRequests(student2.Id).Result.Count.Should().Be(2);
blockChangeService.FindWaitingStudentRequests(student3.Id).Result.Count.Should().Be(1);
BlockChangeRequest blockToChange6 = CreateBlockChangeRequest(block3, block2, student1.Id);
(await blockChangeService.AddAndFindMatch(blockToChange6)).Should().Be((null, null));
blockChangeService.FindWaitingStudentRequests(student1.Id).Result.Count.Should().Be(1);
blockChangeService.FindWaitingStudentRequests(student2.Id).Result.Count.Should().Be(2);
blockChangeService.FindWaitingStudentRequests(student3.Id).Result.Count.Should().Be(1);
}
public static SuccessfulExchangeNotification Create(BlockChangeRequest requestOfUserToNotify,
BlockChangeRequest requestOfOtherUser)
{
return(new SuccessfulExchangeNotification(requestOfUserToNotify.StudentId, requestOfUserToNotify.Id));
}
private async Task <(BlockChangeRequest, BlockChangeRequest)> MakeExchangeAndDeleteRequests(BlockChangeRequest request)
{
var requestForExchange = await FindExchange(request);
if (requestForExchange == null)
{
return(null, null);
}
await SetDoneStatus(request);
await SetDoneStatus(requestForExchange);
await RemoveStudentRequests(request);
await RemoveStudentRequests(requestForExchange);
return(request, requestForExchange);
}
private async Task AddAsync(BlockChangeRequest entityToAdd)
{
entityToAdd.Id = Guid.NewGuid();
await _blockChangesCollection.InsertOneAsync(entityToAdd);
}
/// <summary>
///
/// </summary>
/// <param name="blockChangeRequest"></param>
/// <returns>bool value if corresponding second BlockChangeRequest was found and the found BlockChangeRequest</returns>
public async Task <(BlockChangeRequest, BlockChangeRequest)> AddAndFindMatch(BlockChangeRequest blockChangeRequest)
{
await AddAsync(blockChangeRequest);
return(await MakeExchangeAndDeleteRequests(blockChangeRequest));
}
