public async Task <ActionResult <StudentGroupDto> > PostStudentGroup(CreateStudentGroupDto studentGroup)
{
var isStudentGroupNameExist = await _studentGroupService
.IsGroupNameExistAsync(studentGroup.Name);
if (isStudentGroupNameExist.Data)
{
return(Result <StudentGroupDto> .Error(ErrorCode.UnprocessableEntity, "Group name already exists").ToActionResult());
}
var resStudentGroup = await _studentGroupService.CreateStudentGroupAsync(studentGroup);
return(resStudentGroup.ToActionResult());
}
public async Task <Result <StudentGroupDto> > CreateStudentGroupAsync(CreateStudentGroupDto studentGroupDto)
{
try
{
if (studentGroupDto == null)
{
return(Result <StudentGroupDto> .GetError(ErrorCode.ValidationError, "StudentGroupDto is null"));
}
if (await _unitOfWork.StudentGroupRepository.IsGroupNameExistAsync(studentGroupDto.Name))
{
return(Result <StudentGroupDto> .GetError(ErrorCode.UnprocessableEntity, "Group name already exists"));
}
var studentGroup = new StudentGroup
{
Name = studentGroupDto.Name,
CourseId = studentGroupDto.CourseId,
StartDate = studentGroupDto.StartDate,
FinishDate = studentGroupDto.FinishDate,
};
_unitOfWork.StudentGroupRepository.Add(studentGroup);
if (studentGroupDto?.StudentIds.Count != 0)
{
var students = await _unitOfWork.StudentRepository.GetStudentsByIdsAsync(studentGroupDto.StudentIds);
studentGroup.StudentsOfStudentGroups = new List <StudentOfStudentGroup>();
for (int i = 0; i < students.Count; i++)
{
studentGroup.StudentsOfStudentGroups.Add(new StudentOfStudentGroup
{
StudentId = students[i].Id,
Student = students[i]
});
}
}
if (studentGroupDto?.MentorIds.Count != 0)
{
var mentors = await _unitOfWork.MentorRepository.GetMentorsByIdsAsync(studentGroupDto.MentorIds);
studentGroup.MentorsOfStudentGroups = new List <MentorOfStudentGroup>();
for (int i = 0; i < mentors.Count; i++)
{
studentGroup.MentorsOfStudentGroups.Add(new MentorOfStudentGroup
{
MentorId = mentors[i].Id,
Mentor = mentors[i]
});;
}
}
await _unitOfWork.CommitAsync();
return(Result <StudentGroupDto> .GetSuccess(_mapper.Map <StudentGroupDto>(studentGroup)));
}
catch (Exception ex)
{
_unitOfWork.Rollback();
Console.WriteLine(ex.Message);
return(Result <StudentGroupDto> .GetError(ErrorCode.InternalServerError, "Internal error"));
}
}
public async Task <CreateStudentGroupDto> AddStudentGroupAsync(long id, CreateStudentGroupDto addDto, string accessToken)
{
var createStudentGroup = await _apiUtil.CreateAsync($"{_config.Value.Urls.Api.Https}/api/student_groups", addDto, accessToken);
return(createStudentGroup);
}
public async Task <ActionResult <StudentGroupDto> > PostStudentGroup([FromBody] CreateStudentGroupDto studentGroup)
{
var resStudentGroup = await _studentGroupService.CreateStudentGroupAsync(studentGroup);
return(resStudentGroup.ToActionResult());
}
public async Task <Result <StudentGroupDto> > CreateStudentGroupAsync(CreateStudentGroupDto studentGroupDto)
{
try
{
if (studentGroupDto == null)
{
return(Result <StudentGroupDto> .Error(ErrorCode.ValidationError, "StudentGroupDto is null"));
}
var studentGroup = new StudentGroup
{
Name = studentGroupDto.Name,
CourseId = studentGroupDto.CourseId,
StartDate = studentGroupDto.StartDate,
FinishDate = studentGroupDto.FinishDate,
};
_unitOfWork.StudentGroupRepository.Add(studentGroup);
if (studentGroupDto?.StudentIds.Count != 0)
{
var students = await _unitOfWork.StudentRepository.GetStudentsByIdsAsync(studentGroupDto.StudentIds);
studentGroup.StudentsOfStudentGroups = new List <StudentOfStudentGroup>();
for (int i = 0; i < students.Count; i++)
{
studentGroup.StudentsOfStudentGroups.Add(new StudentOfStudentGroup
{
Student = students[i]
});
}
}
if (studentGroupDto?.MentorIds.Count != 0)
{
var mentors = await _unitOfWork.MentorRepository.GetMentorsByIdsAsync(studentGroupDto.MentorIds);
studentGroup.MentorsOfStudentGroups = new List <MentorOfStudentGroup>();
for (int i = 0; i < mentors.Count; i++)
{
studentGroup.MentorsOfStudentGroups.Add(new MentorOfStudentGroup
{
Mentor = mentors[i]
});;
}
}
await _unitOfWork.CommitAsync();
return(Result <StudentGroupDto> .Success(_mapper.Map <StudentGroupDto>(studentGroup)));
}
catch
{
_unitOfWork.Rollback();
return(Result <StudentGroupDto> .Error(ErrorCode.InternalServerError, "Internal error"));
}
}
public async Task <IActionResult> AddStudentGroup(long id, CreateStudentGroupDto data)
{
var updatedStudentGroup = await _studentGroupService.AddStudentGroupAsync(id, data, _protector.Unprotect(Request.Cookies["accessToken"]));
return(RedirectToAction("AllStudentGroups", "StudentGroup"));
}
public async Task CreateStudentGroup()
{
//Arrange
var newStudentGroup = new CreateStudentGroupDto()
{
Name = "New_test_name",
CourseId = 2,
StartDate = DateTime.Now.Date,
FinishDate = DateTime.Now.AddMonths(3).Date,
StudentIds = new List <long>()
{
1, 2, 3, 4
},
MentorIds = new List <long>()
{
8, 9
}
};
var existingStudentGroup = new CreateStudentGroupDto()
{
Name = "Exists_test_name",
CourseId = 3,
StartDate = DateTime.Now.AddMonths(3).Date,
FinishDate = DateTime.Now.AddMonths(6).Date,
StudentIds = new List <long>()
{
5, 6, 7, 8
},
MentorIds = new List <long>()
{
10, 11
}
};
var withoutMentorsAndStudentsStudentGroup = new CreateStudentGroupDto()
{
Name = "Unique_test_name",
CourseId = 3,
StartDate = DateTime.Now.AddMonths(3).Date,
FinishDate = DateTime.Now.AddMonths(6).Date,
StudentIds = new List <long>(),
MentorIds = new List <long>()
};
var studentGroupRepositoryMock = new Mock <IStudentGroupRepository>();
var studentsRepositoryMock = new Mock <IStudentRepository>();
var mentorsRepositoryMock = new Mock <IMentorRepository>();
studentGroupRepositoryMock.Setup(x => x.Add(It.IsAny <StudentGroup>()));
studentsRepositoryMock.Setup(x => x.GetStudentsByIdsAsync(newStudentGroup.StudentIds))
.ReturnsAsync(new List <Student>()
{
new Student {
Id = 1
},
new Student {
Id = 2
},
new Student {
Id = 3
},
new Student {
Id = 4
}
});
mentorsRepositoryMock.Setup(x => x.GetMentorsByIdsAsync(newStudentGroup.MentorIds))
.ReturnsAsync(new List <Mentor>()
{
new Mentor {
Id = 18
},
new Mentor {
Id = 19
}
});
studentsRepositoryMock.Setup(x => x.GetStudentsByIdsAsync(withoutMentorsAndStudentsStudentGroup.StudentIds))
.ReturnsAsync(new List <Student>());
mentorsRepositoryMock.Setup(x => x.GetMentorsByIdsAsync(withoutMentorsAndStudentsStudentGroup.MentorIds))
.ReturnsAsync(new List <Mentor>());
studentGroupRepositoryMock.Setup(x => x.IsGroupNameExistAsync(newStudentGroup.Name))
.ReturnsAsync(false);
studentGroupRepositoryMock.Setup(x => x.IsGroupNameExistAsync(existingStudentGroup.Name))
.ReturnsAsync(true);
_unitOfWorkMock.Setup(x => x.StudentGroupRepository).Returns(studentGroupRepositoryMock.Object);
_unitOfWorkMock.Setup(x => x.StudentRepository).Returns(studentsRepositoryMock.Object);
_unitOfWorkMock.Setup(x => x.MentorRepository).Returns(mentorsRepositoryMock.Object);
var studentGroupService = new StudentGroupService(
_unitOfWorkMock.Object,
_mapper,
_loggerMock.Object
);
//Act
var successResult = await studentGroupService.CreateStudentGroupAsync(newStudentGroup);
var groupNameExistResult = await studentGroupService.CreateStudentGroupAsync(existingStudentGroup);
var nullGroupResult = await studentGroupService.CreateStudentGroupAsync(null);
var withoutMentorsAndStudentsGroupResult = await studentGroupService.CreateStudentGroupAsync(withoutMentorsAndStudentsStudentGroup);
//Assert
Assert.NotNull(successResult.Data);
Assert.Equal(newStudentGroup.Name, successResult.Data.Name);
Assert.Equal(ErrorCode.UnprocessableEntity, groupNameExistResult.Error.Code);
Assert.Equal(ErrorCode.ValidationError, nullGroupResult.Error.Code);
Assert.True(withoutMentorsAndStudentsGroupResult.Data.StudentIds.Count == 0);
Assert.True(withoutMentorsAndStudentsGroupResult.Data.MentorIds.Count == 0);
}
