// обновить файл решения
public async Task <OperationDetailDTO> UpdateSolutionFileAsync(int fileID, string newUserFileName, string newUniqueFileName)
{
var detail = new OperationDetailDTO();
try
{
var file = await _context.SolutionFiles.FindAsync(fileID);
if (file == null)
{
detail.ErrorMessages.Add("Ошибка при обновлении файла решения задачи: файл не найден.");
}
file.FileName = newUserFileName;
file.Path = SolutionFilePath + newUniqueFileName;
file.FileURI = SolutionFileURI + newUniqueFileName;
_context.SolutionFiles.Update(file);
await _context.SaveChangesAsync();
detail.Succeeded = true;
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add("Ошибка при обновлени файла решения задачи: " + e.Message);
return(detail);
}
}
public async Task <IActionResult> DeleteRepoAsync([FromBody] int[] id)
{
var detail = new OperationDetailDTO();
try
{
var res = await _teacherService.DeleteRepositoryAsync(id[0]);
if (res.Succeeded)
{
detail.Succeeded = true;
foreach (var path in res.Data)
{
var filePath = _environment.WebRootPath + path;
if (System.IO.File.Exists(filePath))
{
System.IO.File.Delete(filePath);
}
}
}
return(Ok(detail));
}
catch (Exception e)
{
detail.ErrorMessages.Add("Ошибка на сервере при удалении файлов репозитория. Описании ошибки: " + e.Message);
Debug.WriteLine(e.InnerException);
Debug.WriteLine("Source :" + e.Source);
return(Ok(detail));
}
}
// получение данных профиля преподавателя
public async Task <OperationDetailDTO <TeacherDTO> > GetProfileDataAsync()
{
var detail = new OperationDetailDTO <TeacherDTO>();
try
{
var currentUserEntity = await GetUserFromClaimsAsync();
var teacherEntity = await _context.Teachers
.Include(t => t.User)
.Include(t => t.Department)
.ThenInclude(d => d.Faculty)
.Where(t => t.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
var dto = TeacherDTO.Map(teacherEntity);
detail.Succeeded = true;
detail.Data = dto;
return(detail);
}
catch (Exception e)
{
detail.Succeeded = false;
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
public async Task <OperationDetailDTO <List <string> > > DeleteRepositoryAsync(int id)
{
var detail = new OperationDetailDTO <List <string> >();
var removingFiles = new List <string>();
var entity = await _context.RepositoryModels
.Include(r => r.Files)
.Where(r => r.Id == id)
.FirstOrDefaultAsync();
if (entity != null)
{
foreach (var fileEntity in entity.Files)
{
removingFiles.Add(fileEntity.Path);
}
_context.RepositoryModels.Remove(entity);
await _context.SaveChangesAsync();
detail.Data = removingFiles;
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Репозиторий не найден.");
}
return(detail);
}
// test
public async Task <OperationDetailDTO <List <SubjectDTO> > > GetRepositoryListFilters()
{
var detail = new OperationDetailDTO <List <SubjectDTO> >();
var resultSubjectDTOList = new List <SubjectDTO>();
var currentUserEntity = await GetUserFromClaimsAsync();
var teacherEntity = await _context.Teachers
.Where(t => t.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
IQueryable <RepositoryModel> repositories = from r in _context.RepositoryModels
.Include(r => r.Teacher)
.Include(r => r.Subject)
.Where(r => r.TeacherId == teacherEntity.Id)
select r;
foreach (var repo in repositories)
{
SubjectDTO subjectDTO;
if ((subjectDTO = resultSubjectDTOList.FirstOrDefault(s => s.Id == repo.SubjectId)) != null)
{
}
else
{
subjectDTO = SubjectDTO.Map(repo.Subject);
resultSubjectDTOList.Add(subjectDTO);
}
}
detail.Data = resultSubjectDTOList;
detail.Succeeded = true;
return(detail);
}
public async Task <OperationDetailDTO <StudentDTO> > GetProfileDataAsync()
{
var detail = new OperationDetailDTO <StudentDTO>();
try
{
var currentUserEntity = await GetUserFromClaimsAsync();
var studentEntity = await _context.Students
.Include(s => s.User)
.Include(s => s.Group)
.ThenInclude(g => g.Faculty)
.Where(s => s.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
var dto = StudentDTO.Map(studentEntity);
detail.Succeeded = true;
detail.Data = dto;
return(detail);
}
catch (Exception e)
{
detail.Succeeded = false;
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
public async Task <OperationDetailDTO> UpdateRepositoryAsync(RepositoryCreateModelDTO dto)
{
var detail = new OperationDetailDTO();
if (dto != null)
{
var repoEntity = await _context.RepositoryModels
.FindAsync(dto.Id);
if (repoEntity == null)
{
detail.ErrorMessages.Add("Репозиторий не найден.");
return(detail);
}
repoEntity.ContentText = dto.ContentText;
repoEntity.Name = dto.Name;
_context.RepositoryModels.Update(repoEntity);
await _context.SaveChangesAsync();
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Объекта параметра репозитория был равен null");
}
return(detail);
}
public async Task <OperationDetailDTO <RepositoryDTO> > GetRepositoryByID(int id)
{
var detail = new OperationDetailDTO <RepositoryDTO>();
try
{
var repoEntity = await _context.RepositoryModels
.Include(r => r.Files)
.FirstOrDefaultAsync(r => r.Id == id);
if (repoEntity != null)
{
var dto = RepositoryDTO.Map(repoEntity);
detail.Data = dto;
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Репозиторий не найден");
}
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
// done
public async Task <OperationDetailDTO> CloseTaskAsync(int id)
{
var detail = new OperationDetailDTO <TaskDTO>();
try
{
var entity = await _context.TaskModels.FindAsync(id);
if (entity == null)
{
detail.ErrorMessages.Add("Задача не найдена.");
return(detail);
}
entity.IsOpen = false;
entity.UpdateDate = DateTime.Now;
_context.TaskModels.Update(entity);
await _context.SaveChangesAsync();
detail.Succeeded = true;
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
// удаление из БД группы
public async Task <OperationDetailDTO> DeleteGroupAsync(int id)
{
var detail = new OperationDetailDTO();
try
{
var group = await _context.Groups.FindAsync(id);
if (group != null)
{
_context.Groups.Remove(group);
await _context.SaveChangesAsync();
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Ошибка при удалении: группа не найдена");
}
return(detail);
}
catch (Exception e)
{
return(new OperationDetailDTO {
Succeeded = false, ErrorMessages = { _serverErrorMessage + e.Message }
});
}
}
public async Task <OperationDetailDTO <TaskDTO> > GetTaskByIDAsync(int id)
{
var detail = new OperationDetailDTO <TaskDTO>();
try
{
var entity = await _context.TaskModels.FindAsync(id);
if (entity != null)
{
var dto = TaskDTO.Map(entity);
detail.Succeeded = true;
detail.Data = dto;
}
else
{
detail.ErrorMessages.Add("Задание не найдено.");
}
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
}
return(detail);
}
// TEST: files for solutions
// done
public async Task <OperationDetailDTO <TaskDTO> > GetTaskByIDAsync(int id)
{
var detail = new OperationDetailDTO <TaskDTO>();
var resultTaskDTO = new TaskDTO();
var resSolutionDTOList = new List <SolutionDTO>();
var resStudentDTOList = new List <StudentDTO>();
try
{
var entity = await _context.TaskModels
.Include(t => t.Group)
.Include(t => t.TaskStudentItems)
.Include(t => t.Solutions)
.Include(t => t.Subject)
.Include(t => t.Type)
.Include(t => t.File)
.Include(t => t.Teacher)
.FirstOrDefaultAsync(t => t.Id == id);
if (entity == null)
{
detail.ErrorMessages.Add("Задача не найдена.");
return(detail);
}
foreach (var ts in entity.TaskStudentItems)
{
var studentEntuty = await _context.Students.FindAsync(ts.StudentId);
resStudentDTOList.Add(StudentDTO.Map(studentEntuty));
}
// [files]
foreach (var solution in entity.Solutions)
{
var solutionEntity = await _context.Solutions
.Include(s => s.File)
.Where(s => s == solution)
.FirstOrDefaultAsync();
resSolutionDTOList.Add(SolutionDTO.Map(solutionEntity));
}
resultTaskDTO = TaskDTO.Map(entity);
_taskService.GetCurrentTimePercentage(ref resultTaskDTO);
resultTaskDTO.Solutions = resSolutionDTOList;
resultTaskDTO.Students = resStudentDTOList;
detail.Data = resultTaskDTO;
detail.Succeeded = true;
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
public async Task <OperationDetailDTO> UpdateProfileDataAsync(StudentDTO newStudentDTO)
{
var detail = new OperationDetailDTO <TeacherDTO>();
try
{
List <string> errorMessages = new List <string>();
var currentUserEntity = await GetUserFromClaimsAsync();
var studentUser = await _context.Users
.Where(u => u.Id == currentUserEntity.Id)
.FirstOrDefaultAsync();
if (!UserValidator.Validate(newStudentDTO, out errorMessages))
{
detail.ErrorMessages = errorMessages;
return(detail);
}
if (await _context.StudentRegisterRequests.AnyAsync(x => x.UserName == newStudentDTO.UserName) ||
await _context.TeacherRegisterRequests.AnyAsync(x => x.UserName == newStudentDTO.UserName) ||
newStudentDTO.UserName != studentUser.UserName && await _userManager.FindByNameAsync(newStudentDTO.UserName) != null)
{
detail.ErrorMessages.Add("Пользователь с таким именем пользователя уже существует, подберите другое.");
return(detail);
}
if (studentUser != null)
{
studentUser.Email = newStudentDTO.Email;
studentUser.UserName = newStudentDTO.UserName;
var validateRes = _userValidator.ValidateAsync(_userManager, studentUser);
if (validateRes.Result.Succeeded)
{
await _userManager.UpdateNormalizedEmailAsync(studentUser);
await _userManager.UpdateNormalizedUserNameAsync(studentUser);
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Данные пользователя не прошли валидацию. Подробнее: " + validateRes.Result.Errors.ToList());
return(detail);
}
await _context.SaveChangesAsync();
}
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
public async Task <IActionResult> AddStudentRegRequestAsync([FromBody] StudentRegisterDTO dto)
{
var test = JsonConvert.SerializeObject(dto);
var detail = new OperationDetailDTO();
var res = await _accountService.CreateStudentRegisterRequestAsync(dto);
detail = res;
return(Ok(detail));
}
// --приём заявки преподавтеля
public async Task <OperationDetailDTO> CreateTeacherAsync(TeacherRegisterRequest registerEntity)
{
OperationDetailDTO resultDetail;
List <string> errors = new List <string>();
try
{
var user = GetTeacherUserFromRegEntity(registerEntity);
var userResult = await _userManager.CreateAsync(user, registerEntity.PasswordHash);
if (userResult.Succeeded)
{
var roleResult = await _userManager.AddToRoleAsync(user, Role.Types.Teacher.ToString());
if (roleResult.Succeeded)
{
resultDetail = new OperationDetailDTO {
Succeeded = true
};
}
else
{
await _userManager.DeleteAsync(user);
foreach (var error in userResult.Errors)
{
errors.Add("Ошибка при регистрации пользователя-преподавателя. Код ошибки: " + error.Code + ". Описание ошибки: " + error.Description);
}
resultDetail = new OperationDetailDTO {
Succeeded = false, ErrorMessages = errors
};
}
}
else
{
foreach (var error in userResult.Errors)
{
errors.Add("Ошибка при регистрации пользователя-преподавателя. Код ошибки: " + error.Code + " Описание ошибки: " + error.Description);
}
resultDetail = new OperationDetailDTO {
Succeeded = false, ErrorMessages = errors
};
}
return(resultDetail);
}
catch (Exception e)
{
errors.Add(_serverErrorMessage + e.Message);
return(new OperationDetailDTO {
Succeeded = false, ErrorMessages = errors
});
}
}
public async Task <OperationDetailDTO> UpdatePasswordAsync(PasswordUpdateDTO dto)
{
var detail = new OperationDetailDTO();
if (dto == null)
{
detail.ErrorMessages.Add("Параметр, полученный от клиентского приложения, был равен null");
return(detail);
}
try
{
var user = await GetUserFromClaimsAsync();
if (String.IsNullOrEmpty(dto.CurrentPassword) || String.IsNullOrEmpty(dto.NewPassword))
{
detail.ErrorMessages.Add("Введены некорректные данные.");
return(detail);
}
var passwordRes = _userManager.PasswordHasher.VerifyHashedPassword(user, user.PasswordHash, dto.CurrentPassword);
if (passwordRes == PasswordVerificationResult.Success)
{
var passwordResetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
var passwordResetResult = await _userManager.ResetPasswordAsync(user, passwordResetToken, dto.NewPassword);
if (passwordResetResult.Succeeded)
{
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Некорректно введён новый пароль.");
foreach (var error in passwordResetResult.Errors.ToList())
{
detail.ErrorMessages.Add(error.Description);
}
}
}
else
{
detail.ErrorMessages.Add("Введён неверный текущий пароль.");
}
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
public async Task <IActionResult> AddFileForRepositoryaAsync()
{
string repoFileLoadPath = _environment.WebRootPath + "\\Files\\" + "\\RepoFiles\\";
var detail = new OperationDetailDTO();
try
{
var allForms = Request.Form;
StringValues repoIdString;
var taskIdRes = allForms.TryGetValue(allForms.Keys.First(), out repoIdString);
var strId = repoIdString.ToString();
var id = Convert.ToInt32(strId);
var file = Request.Form.Files[0];
if (file != null)
{
var fileName = file.FileName;
var fileRes = new OperationDetailDTO();
var newFileName = System.Guid.NewGuid() + fileName;
using (var fileStream = System.IO.File.Create(repoFileLoadPath + newFileName))
{
file.CopyTo(fileStream);
}
fileRes = await _repoService.AddFileToRepoAsync(id, fileName, newFileName);
if (!fileRes.Succeeded)
{
detail.ErrorMessages.Add("Не удалось загрузить файл для репозитория.");
detail.ErrorMessages.AddRange(fileRes.ErrorMessages);
return(Ok(detail));
}
else
{
detail.Succeeded = true;
return(Ok(detail));
}
}
else
{
detail.ErrorMessages.Add("Файл равен null");
return(Ok(detail));
}
}
catch (Exception e)
{
detail.ErrorMessages.Add("Ошибка на сервере при загрузке файлов: " + e.Message);
Debug.WriteLine(e.InnerException);
Debug.WriteLine("Source :" + e.Source);
return(Ok(detail));
}
}
// test
public async Task <OperationDetailDTO <List <RepositoryDTO> > > GetRepositoriesFromDBAsync(FilterDTO[] filters = null)
{
var detail = new OperationDetailDTO <List <RepositoryDTO> >();
var resultList = new List <RepositoryDTO>();
var currentUserEntity = await GetUserFromClaimsAsync();
var teacherEntity = await _context.Teachers
.Include(t => t.User)
.Where(t => t.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
var repos = from r in _context.RepositoryModels
.Where(r => r.TeacherId == teacherEntity.Id)
.Include(r => r.Subject)
.Include(r => r.Files)
select r;
repos.OrderBy(r => r.Name);
if (filters != null)
{
foreach (var filter in filters)
{
switch (filter.Name)
{
case "subjectId":
{
var value = Convert.ToInt32(filter.Value);
if (value > 0)
{
repos = repos.Where(r => r.SubjectId == value);
}
break;
}
}
}
}
foreach (var entity in repos)
{
var repoDTO = RepositoryDTO.Map(entity);
resultList.Add(repoDTO);
}
detail.Data = resultList;
detail.Succeeded = true;
return(detail);
}
public async Task <OperationDetailDTO <List <RepositoryDTO> > > GetRepositoriesFromDBAsync(FilterDTO[] filters)
{
var detail = new OperationDetailDTO <List <RepositoryDTO> >();
try
{
var resultList = new List <RepositoryDTO>();
var repos = from r in _context.RepositoryModels
.Include(r => r.Subject)
.Include(r => r.Files)
.Include(r => r.Teacher)
select r;
repos.OrderBy(r => r.Teacher.Name);
if (filters != null)
{
foreach (var filter in filters)
{
switch (filter.Name)
{
case "subjectId":
{
var value = Convert.ToInt32(filter.Value);
if (value > 0)
{
repos = repos.Where(r => r.SubjectId == value);
}
break;
}
}
}
}
foreach (var entity in repos)
{
var repoDTO = RepositoryDTO.Map(entity);
resultList.Add(repoDTO);
}
detail.Data = resultList;
detail.Succeeded = true;
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
}
return(detail);
}
public async Task <OperationDetailDTO> AddFileToRepoAsync(int id, string userfileName, string uniquefileName = null)
{
var detail = new OperationDetailDTO();
try
{
var repo = await _context.RepositoryModels.FindAsync(id);
if (repo != null)
{
RepoFile newFile;
if (uniquefileName != null)
{
newFile = new RepoFile
{
RepositoryModel = repo,
FileName = userfileName,
Path = RepoFilePath + uniquefileName,
FileURI = RepoFileURI + uniquefileName
};
}
else
{
newFile = new RepoFile
{
RepositoryModel = repo,
FileName = userfileName,
Path = RepoFilePath + userfileName,
FileURI = RepoFileURI + userfileName
};
}
await _context.RepoFiles.AddAsync(newFile);
await _context.SaveChangesAsync();
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Ошибка при добавлении файла: репозиторий не найден.");
}
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add("Ошибка при добавлении файла к репозиторию " + e.Message);
return(detail);
}
}
// добавить файл к задаче
public async Task <OperationDetailDTO> AddFileToTaskAsync(int taskID, string userFileName, string uniquefileName = null)
{
var detail = new OperationDetailDTO();
try
{
var task = await _context.TaskModels.FindAsync(taskID);
if (task != null)
{
TaskFile newFile;
if (uniquefileName != null)
{
newFile = new TaskFile
{
TaskModel = task,
FileName = userFileName,
Path = TaskFilePath + uniquefileName,
FileURI = TaskFileURI + uniquefileName,
};
}
else
{
newFile = new TaskFile
{
TaskModel = task,
FileName = userFileName,
Path = TaskFilePath + userFileName,
FileURI = TaskFileURI + userFileName,
};
}
await _context.TaskFiles.AddAsync(newFile);
await _context.SaveChangesAsync();
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Ошибка при добавлении файла: задание не найдено.");
}
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add("Ошибка при добавлении файла к заданию. " + e.Message);
return(detail);
}
}
// добавить файл к решению
public async Task <OperationDetailDTO> AddFileToSolutionAsync(int solutionID, string userFileName, string uniquefileName = null)
{
var detail = new OperationDetailDTO();
try
{
var solution = await _context.Solutions.FindAsync(solutionID);
if (solution != null)
{
SolutionFile newFile;
if (uniquefileName != null)
{
newFile = new SolutionFile
{
Solution = solution,
FileName = userFileName,
Path = SolutionFilePath + uniquefileName,
FileURI = SolutionFileURI + uniquefileName,
};
}
else
{
newFile = new SolutionFile
{
Solution = solution,
FileName = userFileName,
Path = SolutionFilePath + userFileName,
FileURI = SolutionFileURI + userFileName,
};
}
await _context.SolutionFiles.AddAsync(newFile);
await _context.SaveChangesAsync();
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Ошибка при добавлении файла: решениие задачи не найдено.");
}
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add("Ошибка при добавлении файла к решению задачи. " + e.Message);
return(detail);
}
}
// создание сущности задачи и добавление в БД
public async Task <OperationDetailDTO <string> > CreateNewTaskAsync(TaskCreateModelDTO dto = null)
{
var detail = new OperationDetailDTO <string>();
try
{
var currentUserEntity = await GetUserFromClaimsAsync();
var teacherEntity = await _context.Teachers
.Include(t => t.User)
.Where(t => t.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
if (dto != null)
{
var newTask = TaskCreateModelDTO.Map(dto);
newTask.TeacherId = teacherEntity.Id;
await AddStudentsToTaskAsync(newTask, dto.StudentIds);
await _context.TaskModels.AddAsync(newTask);
await _context.SaveChangesAsync();
var createdTask = await _context.TaskModels.FirstOrDefaultAsync(t => t == newTask);
if (createdTask != null)
{
detail.Data = createdTask.Id.ToString();
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add(_serverErrorMessage + "При создании задачи что-то пошло не так.");
}
return(detail);
}
else
{
detail.ErrorMessages.Add("Параметр модели создаваемой задачи был равен NULL.");
return(detail);
}
}
catch (Exception e)
{
detail.ErrorMessages.Add(e.Message);
return(detail);
}
}
// test
// add try - catch
public async Task <OperationDetailDTO <string> > CreateNewRepositoryAsync(RepositoryCreateModelDTO dto = null)
{
var detail = new OperationDetailDTO <string>();
if (dto != null)
{
var currentUserEntity = await GetUserFromClaimsAsync();
var teacherEntity = await _context.Teachers
.Where(t => t.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
var subject = await _context.Subjects.FindAsync(dto.SubjectId);
if (subject != null)
{
var repositoryEntity = RepositoryCreateModelDTO.Map(dto);
repositoryEntity.Teacher = teacherEntity;
repositoryEntity.Subject = subject;
await _context.RepositoryModels.AddAsync(repositoryEntity);
await _context.SaveChangesAsync();
var createdRepo = await _context.RepositoryModels.FirstOrDefaultAsync(r => r == repositoryEntity); // by id ?
if (createdRepo != null)
{
detail.Data = createdRepo.Id.ToString();
detail.Succeeded = true;
}
else
{
detail.ErrorMessages.Add("Не удалось получить созданный репозиторий");
}
}
else
{
detail.ErrorMessages.Add("Параметр учебного предмета создаваемого репозитория был равен NULL");
}
return(detail);
}
else
{
detail.ErrorMessages.Add("Входные данные создаваемого репозитория равны NULL");
return(detail);
}
}
// Test
public async Task <OperationDetailDTO <List <SubjectDTO> > > GetRepoCreateSubjectFiltersAsync()
{
var detail = new OperationDetailDTO <List <SubjectDTO> >();
var resultSubjectDTOList = new List <SubjectDTO>();
var subjects = await _context.Subjects.ToListAsync();
foreach (var sub in subjects)
{
resultSubjectDTOList.Add(SubjectDTO.Map(sub));
}
detail.Data = resultSubjectDTOList;
detail.Succeeded = true;
return(detail);
}
public async Task <IActionResult> SignInAsync([FromBody] UserLoginDTO dto)
{
OperationDetailDTO <SignInDetailDTO> detailResult = new OperationDetailDTO <SignInDetailDTO>();
var serviceResult = await _accountService.SignInAsync(dto);
try
{
if (!serviceResult.Succeeded)
{
detailResult.ErrorMessages = serviceResult.ErrorMessages;
return(Ok(detailResult));
}
else
{
var userRoles = serviceResult.Data.UserRoles;
var tokenResult = _jwtTokenGenerator.Generate(serviceResult.Data.User, userRoles);
//HttpContext.Response.Cookies.Append(".AspNetCore.Application.Id",
//tokenResult.AccessToken, new CookieOptions { MaxAge = TimeSpan.FromMinutes(60) });
//HttpContext.Response.Cookies.Append("token",
// tokenResult.AccessToken, new CookieOptions { MaxAge = TimeSpan.FromMinutes(60) });
detailResult = new OperationDetailDTO <SignInDetailDTO>
{
Succeeded = true,
Data = new SignInDetailDTO
{
Role = serviceResult.Data.UserRoles.FirstOrDefault().ToLowerInvariant(),
IdToken = tokenResult.AccessToken
},
};
return(Ok(detailResult));
}
}
catch (Exception e)
{
detailResult.ErrorMessages.Add("Произошло исключение на сервере при попытке авторизации. " + e.Message);
return(Ok(detailResult));
}
}
public async Task <OperationDetailDTO> UpdateSolutionAsync(SolutionCreateModelDTO dto)
{
var detail = new OperationDetailDTO <TaskDTO>();
try
{
if (dto == null)
{
detail.ErrorMessages.Add("Объект входного параметра был равен NULL.");
return(detail);
}
var entity = await _context.Solutions.FindAsync(dto.Id);
if (entity == null)
{
detail.ErrorMessages.Add("Решение задачи не найдено.");
return(detail);
}
entity.ContentText = dto.ContentText;
entity.CreationDate = DateTime.Now;
if (String.IsNullOrEmpty(entity.ContentText))
{
detail.ErrorMessages.Add("Данные решения задачи введены некорректно. Поробуйте снова.");
return(detail);
}
_context.Solutions.Update(entity);
await _context.SaveChangesAsync();
detail.Succeeded = true;
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
public async Task <OperationDetailDTO <List <SubjectDTO> > > GetRepoFiltersAsync()
{
var detail = new OperationDetailDTO <List <SubjectDTO> >();
try
{
var currentUserEntity = await GetUserFromClaimsAsync();
var studentEntity = await _context.Students
.Include(s => s.Group)
.ThenInclude(g => g.Faculty)
.Where(s => s.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
var resultSubjectDTOList = new List <SubjectDTO>();
var subjects = await _context.Subjects
.Include(s => s.Repositories)
.Where(s => s.Repositories.Count > 0)
.ToListAsync();
foreach (var subject in subjects)
{
SubjectDTO subjectDTO = SubjectDTO.Map(subject);
resultSubjectDTOList.Add(subjectDTO);
}
resultSubjectDTOList.OrderBy(s => s.Name);
detail.Data = resultSubjectDTOList;
detail.Succeeded = true;
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
}
return(detail);
}
public async Task <OperationDetailDTO <string> > CreateSolutionAsync(SolutionCreateModelDTO dto)
{
var detail = new OperationDetailDTO <string>();
try
{
var currentUserEntity = await GetUserFromClaimsAsync();
var studentEntity = await _context.Students
.Include(s => s.User)
.Where(s => s.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
if (dto != null)
{
var taskEntity = await _context.TaskModels.FindAsync(dto.TaskId);
if (taskEntity == null)
{
detail.ErrorMessages.Add("Задача не найдена.");
return(detail);
}
Solution solutionEntity = new Solution
{
ContentText = dto.ContentText,
Student = studentEntity,
TaskModel = taskEntity,
CreationDate = DateTime.Now
};
if (taskEntity.FinishDate > solutionEntity.CreationDate)
{
solutionEntity.InTime = true;
}
await _context.Solutions.AddAsync(solutionEntity);
await _context.SaveChangesAsync();
var createdSolution = await _context.Solutions.FirstOrDefaultAsync(t => t == solutionEntity);
if (createdSolution != null)
{
detail.Succeeded = true;
detail.Data = createdSolution.Id.ToString();
}
else
{
detail.ErrorMessages.Add(_serverErrorMessage + "При создании решения задачи что-то пошло не так.");
}
return(detail);
}
else
{
detail.ErrorMessages.Add("Параметр модели создаваемого решения был равен NULL.");
return(detail);
}
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
public async Task <OperationDetailDTO <TaskDTO> > GetTaskByIDAsync(int id)
{
var detail = new OperationDetailDTO <TaskDTO>();
var resultTaskDTO = new TaskDTO();
SolutionDTO resSolutionDTO = null;
Solution solutionEntity;
try
{
var currentUserEntity = await GetUserFromClaimsAsync();
var studentEntity = await _context.Students
.Include(s => s.User)
.Include(s => s.Solutions)
.Where(s => s.UserId == currentUserEntity.Id)
.FirstOrDefaultAsync();
var taskEntity = await _context.TaskModels
.Include(t => t.Group)
.Include(t => t.Solutions)
.Include(t => t.Subject)
.Include(t => t.Type)
.Include(t => t.File)
.Include(t => t.Teacher)
.Include(t => t.TaskStudentItems)
.FirstOrDefaultAsync(t => t.Id == id);
if (taskEntity == null)
{
detail.ErrorMessages.Add("Задача не найдена.");
return(detail);
}
resultTaskDTO = TaskDTO.Map(taskEntity);
_taskService.GetCurrentTimePercentage(ref resultTaskDTO);
solutionEntity = await _context.Solutions
.Include(s => s.Student)
.Include(s => s.File)
.Where(s => s.TaskId == id)
.Where(s => s.StudentId == studentEntity.Id)
.FirstOrDefaultAsync();
if (solutionEntity != null)
{
resSolutionDTO = SolutionDTO.Map(solutionEntity);
}
resultTaskDTO.Solution = resSolutionDTO;
resultTaskDTO.Solutions = null;
detail.Data = resultTaskDTO;
detail.Succeeded = true;
return(detail);
}
catch (Exception e)
{
detail.ErrorMessages.Add(_serverErrorMessage + e.Message);
return(detail);
}
}
