public async Task <IActionResult> Update([FromBody] UpdateStudentDto model)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
try
{
var entity = await _uow.StudentRepository.GetByIdAsync(model.Id, track : true);
if (entity is null)
{
NotifyError("Student not found!");
return(CustomResponse());
}
if (!string.IsNullOrWhiteSpace(model.Name))
{
entity.AlterName(model.Name);
}
if (model.BirthDate.HasValue)
{
entity.AlterBirthDate(model.BirthDate.Value);
}
await _uow.CommitAsync();
return(CustomResponse(_mapper.Map <StudentDto>(entity)));
}
catch (Exception ex)
{
return(CustomResponse(ex));
}
}
public async Task <bool> UpdateStudent(Guid id, UpdateStudentDto model, string fields)
{
var student = await _service.Query(id, false);
student.UpdateTime = DateTime.Now;
return(await _service.Update(CommonClass.SetModelValue(model, student, fields)));
}
public async Task <IActionResult> UpdateStudent([FromBody] UpdateStudentModel updateStudentModel)
{
UpdateStudentDto updateStudentDto = _mapper.Map <UpdateStudentDto>(updateStudentModel);
await _studentService.UpdateStudentAsync(updateStudentDto);
return(Ok());
}
public async Task <ActionResult> Edit(int id, CreateStudentViewModel studentViewModel)
{
var temp = await _studentService.FindById(id);
var existingCode = await _studentService.FindByCode(studentViewModel.Account);
if (existingCode == null || existingCode.Account == temp.Account)
{
var student = new UpdateStudentDto
{
Account = studentViewModel.Account,
Email = studentViewModel.Email,
Campus = studentViewModel.Campus,
FirstName = studentViewModel.FirstName,
SecondName = studentViewModel.SecondName,
FirstSurname = studentViewModel.FirstSurname,
SecondSurname = studentViewModel.SecondSurname,
Careers = studentViewModel.Careers,
Settlement = studentViewModel.Settlement,
Id = id
};
await _studentService.Update(id, student);
return(Ok());
}
else
{
return(BadRequest("Ya existe un Estudiante con este numero de Cuenta"));
}
}
public async Task UpdateStudentAsync(UpdateStudentDto updateStudentDto)
{
try
{
if (updateStudentDto == null)
{
throw new ArgumentNullException(nameof(updateStudentDto));
}
Student studenteToBeUpdated = await _unitOfWork.Repository <Student>().GetEntityByIdAsync(updateStudentDto.StudentId);
if (studenteToBeUpdated != null)
{
studenteToBeUpdated.StudentName = updateStudentDto.StudentName;
studenteToBeUpdated.CountryId = updateStudentDto.CountryId;
studenteToBeUpdated.DateOfBirth = updateStudentDto.DateOfBirth;
studenteToBeUpdated.Email = updateStudentDto.Email;
studenteToBeUpdated.PhoneNumber = updateStudentDto.PhoneNumber;
studenteToBeUpdated.SpokenLanguage = updateStudentDto.SpokenLanguage;
_unitOfWork.Repository <Student>().UpdateEntity(studenteToBeUpdated);
await _unitOfWork.SaveChangesAsync();
}
}
catch (Exception)
{
throw;
}
}
public void Update(UpdateStudentDto dto)
{
var student = _DB.Students.Find(dto.Id);
student.Score = dto.Score;
_DB.Students.Update(student);
_DB.SaveChanges();
}
public async Task <IActionResult> UpdateStudent(
int id, [FromBody] UpdateStudentDto student)
{
var command = _mapper.Map <EditStudentInfoCommand>(student);
command.StudentId = id;
return(FromResult(await _messages.DispatchAsync(command)));
}
public async Task <Result <StudentDto> > UpdateStudentAsync(long studentId, UpdateStudentDto studentModel)
{
try
{
var foundStudent = await _unitOfWork.StudentRepository.GetByIdAsync(studentId);
if (foundStudent == null)
{
return(Result <StudentDto> .Error(ErrorCode.NotFound, "Student not found"));
}
var isEmailChangableTo = await _accountService
.IsEmailChangableToAsync((long)foundStudent.AccountId, studentModel.Email);
if (!isEmailChangableTo)
{
return(Result <StudentDto> .Error(ErrorCode.ValidationError,
"Email is already taken!"));
}
foundStudent.Account.Email = studentModel.Email ?? foundStudent.Account.Email;
foundStudent.Account.FirstName = studentModel.FirstName ?? foundStudent.Account.FirstName;
foundStudent.Account.LastName = studentModel.LastName ?? foundStudent.Account.LastName;
if (studentModel.StudentGroupIds != null)
{
var currentStudentGroupsOfStudent = foundStudent.StudentsOfStudentGroups;
var newStudentsOfStudentGroup = new List <StudentOfStudentGroup>();
foreach (var newStudentGroupId in studentModel.StudentGroupIds)
{
newStudentsOfStudentGroup.Add(new StudentOfStudentGroup
{
StudentGroupId = newStudentGroupId,
StudentId = foundStudent.Id
});
}
_unitOfWork.StudentGroupRepository.UpdateManyToMany(currentStudentGroupsOfStudent, newStudentsOfStudentGroup);
}
await _unitOfWork.CommitAsync();
return(Result <StudentDto> .Success(_mapper.Map <StudentDto>(foundStudent)));
}
catch
{
_unitOfWork.Rollback();
return(Result <StudentDto> .Error(ErrorCode.InternalServerError,
"Cannot update student."));
}
}
public async Task <ActionResult> UpdateStudent([FromRoute] Guid id, [FromBody] UpdateStudentDto updateStudentDto, CancellationToken ct)
{
if (!await _studentService.ExistsAsync(id, ct))
{
return(NotFound());
}
var studentToReturn = await _studentService.UpdateStudentAsync(id, updateStudentDto, ct);
if (studentToReturn == null)
{
return(BadRequest());
}
return(Ok(studentToReturn));
}
public async Task <StudentDto> PartialUpdateStudentAsync(Guid id, UpdateStudentDto updateStudentDto, CancellationToken ct)
{
var studentEntity = await _uow.Students.GetAsync(id, ct);
_mapper.Map(updateStudentDto, studentEntity);
await _uow.Students.UpdateAsync(studentEntity, id, ct, studentEntity.RowVersion);
await _uow.SaveChangesAsync(ct);
studentEntity = await _uow.Students.GetAsync(id, ct);
var studentDto = _mapper.Map <StudentDto>(studentEntity);
return(studentDto);
}
public async Task <StudentDto> UpdateStudentAsync(Guid id, UpdateStudentDto updateStudentDto, CancellationToken ct)
{
StudentDto studentDto = null;
var updatedEntity = _mapper.Map <Student>(updateStudentDto);
updatedEntity.Id = id;
await _uow.Students.UpdateAsync(updatedEntity, id, ct, updatedEntity.RowVersion);
await _uow.SaveChangesAsync(ct);
var studentEntity = await _uow.Students.GetAsync(id, ct);
studentDto = _mapper.Map <StudentDto>(studentEntity);
return(studentDto);
}
public async Task <IActionResult> UpdateStudent(Guid id, [FromBody] UpdateStudentDto model,
[FromQuery] string fields)
{
try
{
if (!await _manager.UpdateStudent(id, model, fields))
{
return(Ok(new JsonMessageResult("修改失败！", 0, null)));
}
return(NoContent());
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(Ok(new JsonMessageResult(e.Message, 0, null)));
}
}
public async Task <ActionResult <StudentDto> > Update([FromBody] UpdateStudentDto updateStudent)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var UpdateStudent = _mapper.Map <UpdateStudentDto, Student>(updateStudent);
var StudentToUpdate = await _StudentService.GetStudentById(updateStudent.Id);
if (StudentToUpdate == null)
{
return(NotFound());
}
await _StudentService.UpdateStudent(StudentToUpdate, UpdateStudent);
var updatedStudent = await _StudentService.GetStudentById(updateStudent.Id);
var result = _mapper.Map <Student, StudentDto>(updatedStudent);
return(Ok(result));
}
public async Task <ActionResult> UpdateStudent([FromBody] UpdateStudentDto studentDto)
{
await _studentService.UpdateStudent(studentDto);
return(Ok());
}
public async Task <IActionResult> UpdateStudent(long id, UpdateStudentDto data)
{
var updatedStudent = await _studentService.UpdateStudentAsync(id, data, Request.Cookies["accessToken"]);
return(RedirectToAction("AllStudents", "Students"));
}
public async Task <ActionResult> PutStudent(long studentId, UpdateStudentDto studentModel)
{
var updatedStudent = await _studentService.UpdateStudentAsync(studentId, studentModel);
return(updatedStudent.ToActionResult());
}
public async Task StudentUpdate()
{
//Arrange
var existingEmail = "*****@*****.**";
var emptyUpdateStudentDto = new UpdateStudentDto();
var successUpdateStudentDto = new UpdateStudentDto()
{
Email = "*****@*****.**",
FirstName = "FirstNameUpdated",
LastName = "LastNameUpdated"
};
var student = new Student()
{
Id = 5,
AccountId = 10,
Account = new Account()
{
Id = 10,
Email = "*****@*****.**"
}
};
var alreadyExistingEmailUpdateStudentDto = new UpdateStudentDto()
{
Email = existingEmail,
FirstName = "updateTest",
LastName = "updateTest"
};
var alreadyExistingEmailStudent = new Student()
{
Id = 6,
AccountId = 11,
Account = new Account()
{
Id = 11,
Email = existingEmail
}
};
_accountServiceMock.Setup(x => x.IsEmailChangableToAsync(
(long)student.AccountId, successUpdateStudentDto.Email))
.ReturnsAsync(true);
_accountServiceMock.Setup(x => x.IsEmailChangableToAsync(
(long)alreadyExistingEmailStudent.AccountId, existingEmail))
.ReturnsAsync(false);
var studentRepositoryMock = new Mock <IStudentRepository>();
studentRepositoryMock.Setup(x => x.GetByIdAsync(5))
.ReturnsAsync(student);
studentRepositoryMock.Setup(x => x.GetByIdAsync(6))
.ReturnsAsync(alreadyExistingEmailStudent);
_unitOfWorkMock.Setup(x => x.StudentRepository).Returns(studentRepositoryMock.Object);
var studentService = new StudentService(
_accountServiceMock.Object,
_unitOfWorkMock.Object,
_mapper,
_notificationServiceMock.Object
);
//Act
var nonExistingId = await studentService
.UpdateStudentAsync(0, emptyUpdateStudentDto);
var successResult = await studentService
.UpdateStudentAsync(5, successUpdateStudentDto);
var alreadyExistingEmailResult = await studentService
.UpdateStudentAsync(6, alreadyExistingEmailUpdateStudentDto);
//Assert
Assert.Equal(ErrorCode.NotFound, nonExistingId.Error.Code);
Assert.NotNull(successResult.Data);
Assert.Equal(successUpdateStudentDto.Email, successResult.Data.Email);
Assert.Equal(successUpdateStudentDto.FirstName, successResult.Data.FirstName);
Assert.Equal(successUpdateStudentDto.LastName, successResult.Data.LastName);
Assert.Equal(ErrorCode.ValidationError, alreadyExistingEmailResult.Error.Code);
}
public IActionResult Update([FromBody] UpdateStudentDto dto)
{
_service.Update(dto);
return(Ok(GetResponse()));
}
public async Task <UpdateStudentDto> UpdateStudentAsync(long id, UpdateStudentDto UpdateDto, string accessToken)
{
var updatedStudent = await _apiUtil.PutAsync($"{_config.Value.Urls.Api.Https}/api/students/{id}", UpdateDto, accessToken);
return(updatedStudent);
}
